saasco-sdk 0.1.45 → 0.2.4

package/dist/index.js

@@ -0,0 +1,3006 @@
+// src/lib/analytics.ts
+import { isValid, parse } from "psl";
+
+// package.json
+var version = "0.2.4";
+
+// src/lib/timezones.ts
+var timezones = {
+  "Africa/Abidjan": "CI",
+  "Africa/Accra": "GH",
+  "Africa/Addis_Ababa": "ET",
+  "Africa/Algiers": "DZ",
+  "Africa/Asmara": "ER",
+  "Africa/Bamako": "ML",
+  "Africa/Bangui": "CF",
+  "Africa/Banjul": "GM",
+  "Africa/Bissau": "GW",
+  "Africa/Blantyre": "MW",
+  "Africa/Brazzaville": "CG",
+  "Africa/Bujumbura": "BI",
+  "Africa/Cairo": "EG",
+  "Africa/Casablanca": "MA",
+  "Africa/Ceuta": "ES",
+  "Africa/Conakry": "GN",
+  "Africa/Dakar": "SN",
+  "Africa/Dar_es_Salaam": "TZ",
+  "Africa/Djibouti": "DJ",
+  "Africa/Douala": "CM",
+  "Africa/El_Aaiun": "EH",
+  "Africa/Freetown": "SL",
+  "Africa/Gaborone": "BW",
+  "Africa/Harare": "ZW",
+  "Africa/Johannesburg": "ZA",
+  "Africa/Juba": "SS",
+  "Africa/Kampala": "UG",
+  "Africa/Khartoum": "SD",
+  "Africa/Kigali": "RW",
+  "Africa/Kinshasa": "CD",
+  "Africa/Lagos": "NG",
+  "Africa/Libreville": "GA",
+  "Africa/Lome": "TG",
+  "Africa/Luanda": "AO",
+  "Africa/Lubumbashi": "CD",
+  "Africa/Lusaka": "ZM",
+  "Africa/Malabo": "GQ",
+  "Africa/Maputo": "MZ",
+  "Africa/Maseru": "LS",
+  "Africa/Mbabane": "SZ",
+  "Africa/Mogadishu": "SO",
+  "Africa/Monrovia": "LR",
+  "Africa/Nairobi": "KE",
+  "Africa/Ndjamena": "TD",
+  "Africa/Niamey": "NE",
+  "Africa/Nouakchott": "MR",
+  "Africa/Ouagadougou": "BF",
+  "Africa/Porto-Novo": "BJ",
+  "Africa/Sao_Tome": "ST",
+  "Africa/Tripoli": "LY",
+  "Africa/Tunis": "TN",
+  "Africa/Windhoek": "NA",
+  "America/Adak": "US",
+  "America/Anchorage": "US",
+  "America/Anguilla": "AI",
+  "America/Antigua": "AG",
+  "America/Araguaina": "BR",
+  "America/Argentina/Buenos_Aires": "AR",
+  "America/Argentina/Catamarca": "AR",
+  "America/Argentina/Cordoba": "AR",
+  "America/Argentina/Jujuy": "AR",
+  "America/Argentina/La_Rioja": "AR",
+  "America/Argentina/Mendoza": "AR",
+  "America/Argentina/Rio_Gallegos": "AR",
+  "America/Argentina/Salta": "AR",
+  "America/Argentina/San_Juan": "AR",
+  "America/Argentina/San_Luis": "AR",
+  "America/Argentina/Tucuman": "AR",
+  "America/Argentina/Ushuaia": "AR",
+  "America/Aruba": "AW",
+  "America/Asuncion": "PY",
+  "America/Atikokan": "CA",
+  "America/Bahia": "BR",
+  "America/Bahia_Banderas": "MX",
+  "America/Barbados": "BB",
+  "America/Belem": "BR",
+  "America/Belize": "BZ",
+  "America/Blanc-Sablon": "CA",
+  "America/Boa_Vista": "BR",
+  "America/Bogota": "CO",
+  "America/Boise": "US",
+  "America/Cambridge_Bay": "CA",
+  "America/Campo_Grande": "BR",
+  "America/Cancun": "MX",
+  "America/Caracas": "VE",
+  "America/Cayenne": "GF",
+  "America/Cayman": "KY",
+  "America/Chicago": "US",
+  "America/Chihuahua": "MX",
+  "America/Costa_Rica": "CR",
+  "America/Creston": "CA",
+  "America/Cuiaba": "BR",
+  "America/Curacao": "CW",
+  "America/Danmarkshavn": "GL",
+  "America/Dawson": "CA",
+  "America/Dawson_Creek": "CA",
+  "America/Denver": "US",
+  "America/Detroit": "US",
+  "America/Dominica": "DM",
+  "America/Edmonton": "CA",
+  "America/Eirunepe": "BR",
+  "America/El_Salvador": "SV",
+  "America/Fort_Nelson": "CA",
+  "America/Fortaleza": "BR",
+  "America/Glace_Bay": "CA",
+  "America/Goose_Bay": "CA",
+  "America/Grand_Turk": "TC",
+  "America/Grenada": "GD",
+  "America/Guadeloupe": "GP",
+  "America/Guatemala": "GT",
+  "America/Guayaquil": "EC",
+  "America/Guyana": "GY",
+  "America/Halifax": "CA",
+  "America/Havana": "CU",
+  "America/Hermosillo": "MX",
+  "America/Indiana/Indianapolis": "US",
+  "America/Indiana/Knox": "US",
+  "America/Indiana/Marengo": "US",
+  "America/Indiana/Petersburg": "US",
+  "America/Indiana/Tell_City": "US",
+  "America/Indiana/Vevay": "US",
+  "America/Indiana/Vincennes": "US",
+  "America/Indiana/Winamac": "US",
+  "America/Inuvik": "CA",
+  "America/Iqaluit": "CA",
+  "America/Jamaica": "JM",
+  "America/Juneau": "US",
+  "America/Kentucky/Louisville": "US",
+  "America/Kentucky/Monticello": "US",
+  "America/Kralendijk": "BQ",
+  "America/La_Paz": "BO",
+  "America/Lima": "PE",
+  "America/Los_Angeles": "US",
+  "America/Lower_Princes": "SX",
+  "America/Maceio": "BR",
+  "America/Managua": "NI",
+  "America/Manaus": "BR",
+  "America/Marigot": "MF",
+  "America/Martinique": "MQ",
+  "America/Matamoros": "MX",
+  "America/Mazatlan": "MX",
+  "America/Menominee": "US",
+  "America/Merida": "MX",
+  "America/Metlakatla": "US",
+  "America/Mexico_City": "MX",
+  "America/Miquelon": "PM",
+  "America/Moncton": "CA",
+  "America/Monterrey": "MX",
+  "America/Montevideo": "UY",
+  "America/Montserrat": "MS",
+  "America/Nassau": "BS",
+  "America/New_York": "US",
+  "America/Nipigon": "CA",
+  "America/Nome": "US",
+  "America/Noronha": "BR",
+  "America/North_Dakota/Beulah": "US",
+  "America/North_Dakota/Center": "US",
+  "America/North_Dakota/New_Salem": "US",
+  "America/Nuuk": "GL",
+  "America/Ojinaga": "MX",
+  "America/Panama": "PA",
+  "America/Pangnirtung": "CA",
+  "America/Paramaribo": "SR",
+  "America/Phoenix": "US",
+  "America/Port-au-Prince": "HT",
+  "America/Port_of_Spain": "TT",
+  "America/Porto_Velho": "BR",
+  "America/Puerto_Rico": "PR",
+  "America/Punta_Arenas": "CL",
+  "America/Rainy_River": "CA",
+  "America/Rankin_Inlet": "CA",
+  "America/Recife": "BR",
+  "America/Regina": "CA",
+  "America/Resolute": "CA",
+  "America/Rio_Branco": "BR",
+  "America/Santarem": "BR",
+  "America/Santiago": "CL",
+  "America/Santo_Domingo": "DO",
+  "America/Sao_Paulo": "BR",
+  "America/Scoresbysund": "GL",
+  "America/Sitka": "US",
+  "America/St_Barthelemy": "BL",
+  "America/St_Johns": "CA",
+  "America/St_Kitts": "KN",
+  "America/St_Lucia": "LC",
+  "America/St_Thomas": "VI",
+  "America/St_Vincent": "VC",
+  "America/Swift_Current": "CA",
+  "America/Tegucigalpa": "HN",
+  "America/Thule": "GL",
+  "America/Thunder_Bay": "CA",
+  "America/Tijuana": "MX",
+  "America/Toronto": "CA",
+  "America/Tortola": "VG",
+  "America/Vancouver": "CA",
+  "America/Whitehorse": "CA",
+  "America/Winnipeg": "CA",
+  "America/Yakutat": "US",
+  "America/Yellowknife": "CA",
+  "Antarctica/Casey": "AQ",
+  "Antarctica/Davis": "AQ",
+  "Antarctica/DumontDUrville": "AQ",
+  "Antarctica/Macquarie": "AU",
+  "Antarctica/Mawson": "AQ",
+  "Antarctica/McMurdo": "AQ",
+  "Antarctica/Palmer": "AQ",
+  "Antarctica/Rothera": "AQ",
+  "Antarctica/Syowa": "AQ",
+  "Antarctica/Troll": "AQ",
+  "Antarctica/Vostok": "AQ",
+  "Arctic/Longyearbyen": "SJ",
+  "Asia/Aden": "YE",
+  "Asia/Almaty": "KZ",
+  "Asia/Amman": "JO",
+  "Asia/Anadyr": "RU",
+  "Asia/Aqtau": "KZ",
+  "Asia/Aqtobe": "KZ",
+  "Asia/Ashgabat": "TM",
+  "Asia/Atyrau": "KZ",
+  "Asia/Baghdad": "IQ",
+  "Asia/Bahrain": "BH",
+  "Asia/Baku": "AZ",
+  "Asia/Bangkok": "TH",
+  "Asia/Barnaul": "RU",
+  "Asia/Beirut": "LB",
+  "Asia/Bishkek": "KG",
+  "Asia/Brunei": "BN",
+  "Asia/Calcutta": "IN",
+  "Asia/Chita": "RU",
+  "Asia/Choibalsan": "MN",
+  "Asia/Colombo": "LK",
+  "Asia/Damascus": "SY",
+  "Asia/Dhaka": "BD",
+  "Asia/Dili": "TL",
+  "Asia/Dubai": "AE",
+  "Asia/Dushanbe": "TJ",
+  "Asia/Famagusta": "CY",
+  "Asia/Gaza": "PS",
+  "Asia/Hebron": "PS",
+  "Asia/Ho_Chi_Minh": "VN",
+  "Asia/Hong_Kong": "HK",
+  "Asia/Hovd": "MN",
+  "Asia/Irkutsk": "RU",
+  "Asia/Jakarta": "ID",
+  "Asia/Jayapura": "ID",
+  "Asia/Jerusalem": "IL",
+  "Asia/Kabul": "AF",
+  "Asia/Kamchatka": "RU",
+  "Asia/Karachi": "PK",
+  "Asia/Kathmandu": "NP",
+  "Asia/Khandyga": "RU",
+  "Asia/Kolkata": "IN",
+  "Asia/Krasnoyarsk": "RU",
+  "Asia/Kuala_Lumpur": "MY",
+  "Asia/Kuching": "MY",
+  "Asia/Kuwait": "KW",
+  "Asia/Macau": "MO",
+  "Asia/Magadan": "RU",
+  "Asia/Makassar": "ID",
+  "Asia/Manila": "PH",
+  "Asia/Muscat": "OM",
+  "Asia/Nicosia": "CY",
+  "Asia/Novokuznetsk": "RU",
+  "Asia/Novosibirsk": "RU",
+  "Asia/Omsk": "RU",
+  "Asia/Oral": "KZ",
+  "Asia/Phnom_Penh": "KH",
+  "Asia/Pontianak": "ID",
+  "Asia/Pyongyang": "KP",
+  "Asia/Qatar": "QA",
+  "Asia/Qostanay": "KZ",
+  "Asia/Qyzylorda": "KZ",
+  "Asia/Riyadh": "SA",
+  "Asia/Sakhalin": "RU",
+  "Asia/Samarkand": "UZ",
+  "Asia/Seoul": "KR",
+  "Asia/Shanghai": "CN",
+  "Asia/Singapore": "SG",
+  "Asia/Srednekolymsk": "RU",
+  "Asia/Taipei": "TW",
+  "Asia/Tashkent": "UZ",
+  "Asia/Tbilisi": "GE",
+  "Asia/Tehran": "IR",
+  "Asia/Thimphu": "BT",
+  "Asia/Tokyo": "JP",
+  "Asia/Tomsk": "RU",
+  "Asia/Ulaanbaatar": "MN",
+  "Asia/Urumqi": "CN",
+  "Asia/Ust-Nera": "RU",
+  "Asia/Vientiane": "LA",
+  "Asia/Vladivostok": "RU",
+  "Asia/Yakutsk": "RU",
+  "Asia/Yangon": "MM",
+  "Asia/Yekaterinburg": "RU",
+  "Asia/Yerevan": "AM",
+  "Atlantic/Azores": "PT",
+  "Atlantic/Bermuda": "BM",
+  "Atlantic/Canary": "ES",
+  "Atlantic/Cape_Verde": "CV",
+  "Atlantic/Faroe": "FO",
+  "Atlantic/Madeira": "PT",
+  "Atlantic/Reykjavik": "IS",
+  "Atlantic/South_Georgia": "GS",
+  "Atlantic/St_Helena": "SH",
+  "Atlantic/Stanley": "FK",
+  "Australia/Adelaide": "AU",
+  "Australia/Brisbane": "AU",
+  "Australia/Broken_Hill": "AU",
+  "Australia/Darwin": "AU",
+  "Australia/Eucla": "AU",
+  "Australia/Hobart": "AU",
+  "Australia/Lindeman": "AU",
+  "Australia/Lord_Howe": "AU",
+  "Australia/Melbourne": "AU",
+  "Australia/Perth": "AU",
+  "Australia/Sydney": "AU",
+  "Europe/Amsterdam": "NL",
+  "Europe/Andorra": "AD",
+  "Europe/Astrakhan": "RU",
+  "Europe/Athens": "GR",
+  "Europe/Belgrade": "RS",
+  "Europe/Berlin": "DE",
+  "Europe/Bratislava": "SK",
+  "Europe/Brussels": "BE",
+  "Europe/Bucharest": "RO",
+  "Europe/Budapest": "HU",
+  "Europe/Busingen": "DE",
+  "Europe/Chisinau": "MD",
+  "Europe/Copenhagen": "DK",
+  "Europe/Dublin": "IE",
+  "Europe/Gibraltar": "GI",
+  "Europe/Guernsey": "GG",
+  "Europe/Helsinki": "FI",
+  "Europe/Isle_of_Man": "IM",
+  "Europe/Istanbul": "TR",
+  "Europe/Jersey": "JE",
+  "Europe/Kaliningrad": "RU",
+  "Europe/Kiev": "UA",
+  "Europe/Kirov": "RU",
+  "Europe/Lisbon": "PT",
+  "Europe/Ljubljana": "SI",
+  "Europe/London": "GB",
+  "Europe/Luxembourg": "LU",
+  "Europe/Madrid": "ES",
+  "Europe/Malta": "MT",
+  "Europe/Mariehamn": "AX",
+  "Europe/Minsk": "BY",
+  "Europe/Monaco": "MC",
+  "Europe/Moscow": "RU",
+  "Europe/Oslo": "NO",
+  "Europe/Paris": "FR",
+  "Europe/Podgorica": "ME",
+  "Europe/Prague": "CZ",
+  "Europe/Riga": "LV",
+  "Europe/Rome": "IT",
+  "Europe/Samara": "RU",
+  "Europe/San_Marino": "SM",
+  "Europe/Sarajevo": "BA",
+  "Europe/Saratov": "RU",
+  "Europe/Simferopol": "UA",
+  "Europe/Skopje": "MK",
+  "Europe/Sofia": "BG",
+  "Europe/Stockholm": "SE",
+  "Europe/Tallinn": "EE",
+  "Europe/Tirane": "AL",
+  "Europe/Ulyanovsk": "RU",
+  "Europe/Uzhgorod": "UA",
+  "Europe/Vaduz": "LI",
+  "Europe/Vatican": "VA",
+  "Europe/Vienna": "AT",
+  "Europe/Vilnius": "LT",
+  "Europe/Volgograd": "RU",
+  "Europe/Warsaw": "PL",
+  "Europe/Zagreb": "HR",
+  "Europe/Zaporozhye": "UA",
+  "Europe/Zurich": "CH",
+  "Indian/Antananarivo": "MG",
+  "Indian/Chagos": "IO",
+  "Indian/Christmas": "CX",
+  "Indian/Cocos": "CC",
+  "Indian/Comoro": "KM",
+  "Indian/Kerguelen": "TF",
+  "Indian/Mahe": "SC",
+  "Indian/Maldives": "MV",
+  "Indian/Mauritius": "MU",
+  "Indian/Mayotte": "YT",
+  "Indian/Reunion": "RE",
+  "Pacific/Apia": "WS",
+  "Pacific/Auckland": "NZ",
+  "Pacific/Bougainville": "PG",
+  "Pacific/Chatham": "NZ",
+  "Pacific/Chuuk": "FM",
+  "Pacific/Easter": "CL",
+  "Pacific/Efate": "VU",
+  "Pacific/Fakaofo": "TK",
+  "Pacific/Fiji": "FJ",
+  "Pacific/Funafuti": "TV",
+  "Pacific/Galapagos": "EC",
+  "Pacific/Gambier": "PF",
+  "Pacific/Guadalcanal": "SB",
+  "Pacific/Guam": "GU",
+  "Pacific/Honolulu": "US",
+  "Pacific/Kanton": "KI",
+  "Pacific/Kiritimati": "KI",
+  "Pacific/Kosrae": "FM",
+  "Pacific/Kwajalein": "MH",
+  "Pacific/Majuro": "MH",
+  "Pacific/Marquesas": "PF",
+  "Pacific/Midway": "UM",
+  "Pacific/Nauru": "NR",
+  "Pacific/Niue": "NU",
+  "Pacific/Norfolk": "NF",
+  "Pacific/Noumea": "NC",
+  "Pacific/Pago_Pago": "AS",
+  "Pacific/Palau": "PW",
+  "Pacific/Pitcairn": "PN",
+  "Pacific/Pohnpei": "FM",
+  "Pacific/Port_Moresby": "PG",
+  "Pacific/Rarotonga": "CK",
+  "Pacific/Saipan": "MP",
+  "Pacific/Tahiti": "PF",
+  "Pacific/Tarawa": "KI",
+  "Pacific/Tongatapu": "TO",
+  "Pacific/Wake": "UM",
+  "Pacific/Wallis": "WF"
+};
+
+// src/lib/utils/domain.ts
+function getHostname(url) {
+  if (!url) {
+    return "";
+  }
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+
+// src/lib/utils/logger.ts
+var AnalyticsLogger = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  debug(...args) {
+    if (this.config.level < 3 /* DEBUG */) {
+      return;
+    }
+    const icon = "\u25CD";
+    const message = `${icon} ${this.config.label}`;
+    console.debug(
+      `%c ${message}`,
+      `background: #eee; color: #000; padding-right: 6px; border-radius: 2px;`,
+      ...args
+    );
+  }
+  /**
+   * Log debug information
+   */
+  info(...args) {
+    if (this.config.level < 2 /* INFO */) {
+      return;
+    }
+    const icon = "\u25CD";
+    const message = `${icon} ${this.config.label}`;
+    console.info(
+      `%c ${message}`,
+      `background: #eee; color: #000; padding-right: 6px; border-radius: 2px;`,
+      ...args
+    );
+  }
+  /**
+   * Log warning information
+   */
+  warn(...args) {
+    if (this.config.level < 1 /* WARN */) {
+      return;
+    }
+    const icon = "\u25CD";
+    const message = `${icon} ${this.config.label}`;
+    console.warn(
+      `%c ${message}`,
+      `background: #ffa500; color: #000; padding-right: 6px; border-radius: 2px;`,
+      ...args
+    );
+  }
+  /**
+   * Log error information
+   */
+  error(...args) {
+    const icon = "\u25CD";
+    const message = `${icon} ${this.config.label} Error`;
+    console.error(
+      `%c ${message}`,
+      "background: red; color: white; padding-right: 6px; border-radius: 2px;",
+      ...args
+    );
+    return {
+      message: args.join(" "),
+      success: false
+    };
+  }
+};
+
+// src/lib/utils/getIntegrationLoggerLevel.ts
+var isBrowser = typeof window !== "undefined";
+var isServer = !isBrowser;
+function getIntegrationLoggerLevel(integrationName, debug) {
+  let urlDebug = false;
+  if (!isServer) {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const paramName = `saasco-debug-${integrationName}`;
+      const paramValue = urlParams.get(paramName);
+      if (paramValue === "true") {
+        urlDebug = true;
+      }
+    } catch {
+    }
+  }
+  return urlDebug || debug ? 3 /* DEBUG */ : 1 /* WARN */;
+}
+
+// src/lib/utils/uuid.ts
+import { v4 } from "@lukeed/uuid";
+function uuid() {
+  return v4();
+}
+
+// src/lib/getBrowserContext.ts
+function getBrowserContext() {
+  const isBrowser6 = typeof window !== "undefined";
+  if (!isBrowser6) {
+    throw new Error("getBrowserContext can only be called in browser");
+  }
+  const customNavigator = navigator;
+  const $locale = customNavigator?.languages && customNavigator?.languages.length ? customNavigator?.languages[0] : customNavigator?.userLanguage || customNavigator?.language || customNavigator?.browserLanguage || "en";
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const $location = timezones[timezone] || $locale?.split("-")?.[1] || "undefined";
+  const params = new URLSearchParams(window.location.search);
+  const { $utmAdId, $utmAdSource } = resolveAdParams(params);
+  return {
+    $href: window.location.href,
+    $locale,
+    $location,
+    $pathname: window.location.pathname,
+    $referrer: document.referrer,
+    $referringDomain: getHostname(document.referrer),
+    $screenDPI: window.devicePixelRatio,
+    $screenHeight: screen.height,
+    $screenWidth: screen.width,
+    $title: document.title,
+    $userAgent: window.navigator.userAgent,
+    $utmAdId,
+    $utmAdSource,
+    $utmCampaign: params.get("utm_campaign"),
+    $utmCampaignId: params.get("utm_campaign_id"),
+    $utmContent: params.get("utm_content"),
+    $utmCreativeFormat: params.get("utm_creative_format"),
+    $utmId: params.get("utm_id"),
+    $utmMarketingTactic: params.get("utm_marketing_tactic"),
+    $utmMedium: params.get("utm_medium"),
+    $utmSource: params.get("utm_source"),
+    $utmSourcePlatform: params.get("utm_source_platform"),
+    $utmTerm: params.get("utm_term")
+  };
+}
+var AD_NETWORK_PARAMS = [
+  { param: "fbadid", source: "facebook" },
+  { param: "gadid", source: "google" },
+  { param: "xadid", source: "x" },
+  { param: "padid", source: "pinterest" },
+  { param: "ttadid", source: "tiktok" },
+  { param: "scadid", source: "snapchat" },
+  { param: "radid", source: "reddit" },
+  { param: "liadid", source: "linkedin" }
+];
+function resolveAdParams(params) {
+  let $utmAdSource = params.get("utm_ad_source");
+  let $utmAdId = params.get("utm_ad_id");
+  if ($utmAdId) {
+    return { $utmAdId, $utmAdSource };
+  }
+  for (const { param, source } of AD_NETWORK_PARAMS) {
+    const networkAdId = params.get(param);
+    if (!networkAdId) {
+      continue;
+    }
+    $utmAdId = networkAdId;
+    if (!$utmAdSource) {
+      $utmAdSource = source;
+    }
+  }
+  return { $utmAdId, $utmAdSource };
+}
+
+// src/lib/integrations/facebook-pixel.ts
+import { sha256 } from "js-sha256";
+var isBrowser2 = typeof window !== "undefined";
+var isServer2 = !isBrowser2;
+var standardFacebookEvents = [
+  "AddPaymentInfo",
+  "AddToCart",
+  "AddToWishlist",
+  "CompleteRegistration",
+  "Contact",
+  "CustomizeProduct",
+  "Donate",
+  "FindLocation",
+  "InitiateCheckout",
+  "Lead",
+  "Purchase",
+  "Schedule",
+  "Search",
+  "StartTrial",
+  "SubmitApplication",
+  "Subscribe",
+  "ViewContent",
+  "PageView"
+];
+function createFacebookPixelIntegration(config, debug) {
+  let isPixelReady = false;
+  const integrationLoggerLevel = getIntegrationLoggerLevel(
+    "facebook-pixel",
+    debug
+  );
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: "Saasco facebook-pixel"
+  });
+  return {
+    name: "facebook-pixel",
+    environments: ["client"],
+    init: async () => {
+      if (isServer2) {
+        logger.debug("Facebook Pixel init skipped on server");
+        return;
+      }
+      logger.info("Initializing Facebook Pixel", { pixelId: config.pixelId });
+      if (window.fbq || window._fbq) {
+        logger.warn("Facebook Pixel is already initialized");
+        isPixelReady = true;
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          (function init(f, b, e, v, n, t, s) {
+            if (f.fbq) {
+              return;
+            }
+            n = f.fbq = function fbq2() {
+              n.callMethod ? n.callMethod.apply(n, arguments) : n.queue.push(arguments);
+            };
+            if (!f._fbq) {
+              f._fbq = n;
+            }
+            n.push = n;
+            n.loaded = true;
+            n.version = "2.0";
+            n.queue = [];
+            t = b.createElement(e);
+            t.async = true;
+            t.src = v;
+            t.addEventListener("load", () => {
+              isPixelReady = true;
+              logger.info("Facebook Pixel script loaded successfully");
+              resolve();
+            });
+            t.addEventListener("error", () => {
+              logger.error("Failed to load Facebook Pixel script");
+              reject(new Error("Failed to load Facebook Pixel script"));
+            });
+            s = b.getElementsByTagName(e)[0];
+            s.parentNode.insertBefore(t, s);
+          })(
+            window,
+            document,
+            "script",
+            "https://connect.facebook.net/en_US/fbevents.js"
+          );
+          const { fbq } = window;
+          if (!fbq) {
+            reject(new Error("Facebook Pixel failed to initialize"));
+            return;
+          }
+          fbq.disablePushState = true;
+          fbq.allowDuplicatePageViews = true;
+          if (config.automaticConfiguration === false) {
+            logger.debug("Disabling automatic configuration");
+            fbq("set", "autoConfig", false, config.pixelId);
+          }
+          logger.debug("Initializing Facebook Pixel with ID", config.pixelId);
+          fbq("init", config.pixelId);
+          if (typeof fbq === "function") {
+            isPixelReady = true;
+            logger.info("Facebook Pixel initialized synchronously");
+            resolve();
+          }
+        } catch (error) {
+          logger.error("Error during Facebook Pixel initialization", error);
+          reject(error);
+        }
+      });
+    },
+    track: (eventName, properties, _context) => {
+      const { fbq } = window;
+      if (!isPixelReady || !fbq) {
+        logger.warn("Facebook Pixel not ready, skipping track event", {
+          eventName
+        });
+        return;
+      }
+      const fbEventName = getFacebookEventName(eventName, config.eventMapping);
+      const eventsWithParams = ["Purchase", "StartTrial", "Subscribe"];
+      const isStandardEvent = standardFacebookEvents.includes(
+        fbEventName
+      );
+      const trackType = isStandardEvent ? "track" : "trackCustom";
+      logger.debug("Tracking Facebook Pixel event", {
+        originalEvent: eventName,
+        fbEventName,
+        trackType,
+        isStandardEvent,
+        properties
+      });
+      if (eventsWithParams.includes(fbEventName) && properties) {
+        const fbParams = {};
+        if (properties["value"] !== void 0) {
+          fbParams["value"] = properties["value"];
+        }
+        if (properties["currency"] !== void 0) {
+          fbParams["currency"] = properties["currency"];
+        }
+        if (properties["predicted_ltv"] !== void 0) {
+          fbParams["predicted_ltv"] = properties["predicted_ltv"];
+        }
+        logger.info("Tracking Facebook Pixel event with parameters", {
+          event: fbEventName,
+          params: fbParams
+        });
+        fbq(trackType, fbEventName, fbParams);
+      } else {
+        logger.info("Tracking Facebook Pixel event", { event: fbEventName });
+        fbq(trackType, fbEventName);
+      }
+    },
+    identify: (userId, properties, _context) => {
+      try {
+        if (typeof window !== "undefined" && window.fbq) {
+          const amValues = coerceMetaConversionsAmValues({
+            ...properties,
+            ...userId ? { external_id: userId } : {}
+          });
+          const am = {};
+          if (amValues.external_id) {
+            am["external_id"] = amValues.external_id;
+          }
+          if (amValues.em) {
+            am["em"] = sha256(amValues.em);
+          }
+          if (amValues.fn) {
+            am["fn"] = amValues.fn;
+          }
+          if (amValues.ln) {
+            am["ln"] = amValues.ln;
+          }
+          if (amValues.ph) {
+            am["ph"] = amValues.ph;
+          }
+          if (amValues.ge) {
+            am["ge"] = amValues.ge;
+          }
+          if (amValues.db) {
+            am["db"] = amValues.db;
+          }
+          if (amValues.ct) {
+            am["ct"] = amValues.ct;
+          }
+          if (amValues.st) {
+            am["st"] = amValues.st;
+          }
+          if (amValues.zp) {
+            am["zp"] = amValues.zp;
+          }
+          if (amValues.country) {
+            am["country"] = amValues.country;
+          }
+          if (Object.keys(am).length > 0) {
+            window.fbq("init", config.pixelId, am);
+          }
+        }
+      } catch (error) {
+        console.error("Error identifying user in Meta Pixel:", error);
+      }
+    }
+  };
+}
+function getFacebookEventName(eventName, eventMapping) {
+  if (eventName === "Page View") {
+    return "PageView";
+  }
+  if (!eventMapping) {
+    return eventName;
+  }
+  return eventMapping[eventName] || eventName;
+}
+function coerceMetaConversionsAmValues(properties) {
+  const coerce = [
+    {
+      key: "em",
+      coerceFrom: [
+        "email",
+        "user_email",
+        "userEmail",
+        "email_address",
+        "emailAddress",
+        "e_mail",
+        "E_Mail",
+        "mail",
+        "Mail",
+        "contact_email",
+        "contactEmail",
+        "primary_email",
+        "primaryEmail"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        return normalized || void 0;
+      }
+    },
+    {
+      key: "fn",
+      coerceFrom: [
+        "first_name",
+        "firstName",
+        "firstname",
+        "given_name",
+        "givenName",
+        "user_first_name",
+        "userFirstName",
+        "name_first",
+        "nameFirst",
+        "f_name",
+        "fName"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        return normalized || void 0;
+      }
+    },
+    {
+      key: "ln",
+      coerceFrom: [
+        "last_name",
+        "lastName",
+        "lastname",
+        "surname",
+        "user_last_name",
+        "userLastName",
+        "name_last",
+        "nameLast",
+        "l_name",
+        "lName"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        return normalized || void 0;
+      }
+    },
+    {
+      key: "ph",
+      coerceFrom: [
+        "phone",
+        "phone_number",
+        "phoneNumber",
+        "mobile",
+        "mobile_number",
+        "mobileNumber",
+        "contact_number",
+        "contactNumber",
+        "tel",
+        "telephone"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string" && typeof value !== "number") {
+          return;
+        }
+        const phoneStr = String(value).replaceAll(/\D/gu, "");
+        return phoneStr || void 0;
+      }
+    },
+    {
+      key: "external_id",
+      coerceFrom: [
+        "external_id",
+        "externalId",
+        "user_id",
+        "userId",
+        "id",
+        "distinctId",
+        "distinct_id",
+        "customer_id",
+        "customerId",
+        "member_id",
+        "memberId",
+        "loyalty_id",
+        "loyaltyId"
+      ],
+      transform: (value) => {
+        if (value === null || value === void 0) {
+          return;
+        }
+        return String(value) || void 0;
+      }
+    },
+    {
+      key: "ge",
+      coerceFrom: [
+        "gender",
+        "user_gender",
+        "userGender",
+        "sex",
+        "user_sex",
+        "userSex"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "female" || normalized === "f") {
+          return "f";
+        }
+        if (normalized === "male" || normalized === "m") {
+          return "m";
+        }
+      }
+    },
+    {
+      key: "db",
+      coerceFrom: [
+        "birthday",
+        "birth_date",
+        "birthDate",
+        "date_of_birth",
+        "dateOfBirth",
+        "dob",
+        "Dob",
+        "birth_day",
+        "birthDay"
+      ],
+      transform: (value) => {
+        if (!value) {
+          return;
+        }
+        const dateStr = value instanceof Date ? value.toISOString().split("T")[0] : String(value);
+        const dateMatch = dateStr.match(/(\d{4})-(\d{2})-(\d{2})/u);
+        if (dateMatch) {
+          const [, year, month, day] = dateMatch;
+          return `${year}${month}${day}`;
+        }
+        const numericMatch = dateStr.replaceAll(/\D/gu, "");
+        if (numericMatch.length === 8) {
+          return numericMatch;
+        }
+      }
+    },
+    {
+      key: "ct",
+      coerceFrom: [
+        "city",
+        "user_city",
+        "userCity",
+        "location_city",
+        "locationCity",
+        "address_city",
+        "addressCity"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase().replaceAll(/\s+/gu, "");
+        return normalized || void 0;
+      }
+    },
+    {
+      key: "st",
+      coerceFrom: [
+        "state",
+        "user_state",
+        "userState",
+        "province",
+        "user_province",
+        "userProvince",
+        "region",
+        "user_region",
+        "userRegion",
+        "location_state",
+        "locationState",
+        "address_state",
+        "addressState"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (normalized.length === 2) {
+          return normalized;
+        }
+      }
+    },
+    {
+      key: "zp",
+      coerceFrom: [
+        "zip",
+        "zipcode",
+        "zip_code",
+        "postal_code",
+        "postalCode",
+        "postcode",
+        "user_zip",
+        "userZip",
+        "address_zip",
+        "addressZip"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string" && typeof value !== "number") {
+          return;
+        }
+        return String(value).trim() || void 0;
+      }
+    },
+    {
+      key: "country",
+      coerceFrom: [
+        "country",
+        "country_code",
+        "countryCode",
+        "user_country",
+        "userCountry",
+        "location_country",
+        "locationCountry",
+        "address_country",
+        "addressCountry"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (normalized.length === 2) {
+          return normalized;
+        }
+      }
+    }
+  ];
+  const result = {};
+  for (const { key, coerceFrom, transform } of coerce) {
+    const foundValue = findFirstProperty(properties, coerceFrom);
+    if (foundValue !== null && transform) {
+      const transformedValue = transform(foundValue);
+      if (transformedValue) {
+        result[key] = transformedValue;
+      }
+    } else if (foundValue !== null && typeof foundValue === "string") {
+      result[key] = foundValue;
+    }
+  }
+  return result;
+}
+function findFirstProperty(properties, keys) {
+  for (const key of keys) {
+    if (properties[key] !== void 0) {
+      return properties[key];
+    }
+  }
+  return null;
+}
+
+// src/lib/integrations/integration-manager.ts
+var IntegrationManager = class {
+  context = {};
+  integrations = /* @__PURE__ */ new Map();
+  globalQueue = [];
+  config;
+  logger;
+  initTime;
+  currentEnvironment;
+  flushTimer;
+  unloadHandler;
+  constructor(config = {}) {
+    this.config = {
+      flushInterval: config.flushInterval ?? 5e3,
+      loggerLevel: config.loggerLevel ?? 0 /* ERROR */,
+      maxIntegrationWaitTime: config.maxIntegrationWaitTime ?? 1e4,
+      maxQueueSize: config.maxQueueSize ?? 200
+    };
+    this.logger = new AnalyticsLogger({
+      label: "Saasco Integrations Debug",
+      level: this.config.loggerLevel
+    });
+    this.initTime = Date.now();
+    this.currentEnvironment = typeof window === "undefined" ? "server" : "client";
+    this.setupPeriodicFlushing();
+    this.setupUnloadHandler();
+  }
+  /**
+   * Shallow-merge context to keep it simple + predictable in v0
+   */
+  setContext(next) {
+    this.context = { ...this.context, ...next };
+    if (Object.keys(this.context).length > 0) {
+      this.logger.info("setContext", this.context);
+    }
+  }
+  /**
+   * Register and init an integration. When init resolves, we mark it ready and
+   * immediately flush any queued events in FIFO order to *all* ready integrations.
+   */
+  async registerIntegration(integration) {
+    this.logger.debug("Register integrations", this.integrations);
+    if (this.integrations.has(integration.name)) {
+      this.logger.warn(`Integration already registered: ${integration.name}`);
+      return;
+    }
+    const isCompatible = integration.environments.includes(
+      this.currentEnvironment
+    );
+    if (!isCompatible) {
+      this.logger.warn(
+        `Skipping ${integration.name}: requires ${integration.environments.join(
+          " or "
+        )} but running in ${this.currentEnvironment}`
+      );
+      return;
+    }
+    this.logger.debug(`Registering ${integration.name}`);
+    const state = {
+      integration,
+      status: "idle"
+    };
+    this.integrations.set(integration.name, state);
+    if (integration.init) {
+      try {
+        state.status = "loading";
+        const startTime = Date.now();
+        this.logger.debug(`Initializing ${integration.name}`);
+        await integration.init(this.context);
+        state.status = "ready";
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        this.logger.debug(
+          `Integration ${integration.name} ready in ${duration}ms`
+        );
+        this.flush();
+      } catch (error) {
+        state.status = "error";
+        this.logger.error(`Failed to init ${integration.name}`, error);
+      }
+    } else {
+      state.status = "ready";
+      this.logger.info(`Integration ${integration.name} ready (no init)`);
+      this.flush();
+    }
+  }
+  identify(userId, traits) {
+    this.setContext({ userId });
+    this.send({ name: void 0, properties: traits, type: "identify" });
+  }
+  track(name, properties) {
+    this.send({ name, properties, type: "track" });
+  }
+  /**
+   * Core send path: if at least one integration is ready -> deliver immediately
+   * Else enqueue (bounded FIFO)
+   */
+  send(partial) {
+    const envelope = {
+      context: { ...this.context },
+      id: uuid(),
+      name: partial.name,
+      properties: partial.properties,
+      timestamp: Date.now(),
+      type: partial.type
+    };
+    if (!this.isReady()) {
+      if (this.globalQueue.length >= this.config.maxQueueSize) {
+        this.globalQueue.shift();
+        this.logger.warn("Queue full \u2192 dropped oldest");
+      }
+      this.globalQueue.push(envelope);
+      this.logger.debug(`Queued (${this.globalQueue.length})`, envelope);
+      return;
+    }
+    this.deliver(envelope);
+  }
+  async deliver(evt) {
+    for (const { integration, status } of this.integrations.values()) {
+      if (status !== "ready") {
+        continue;
+      }
+      try {
+        if (evt.type === "track" && integration.track && evt.name) {
+          this.logger.debug(`Track (${integration.name}) ${evt.name}`, {
+            context: evt.context,
+            properties: evt.properties
+          });
+          await integration.track(evt.name, evt.properties, evt.context);
+        } else if (evt.type === "identify" && integration.identify) {
+          this.logger.debug(`Identify (${integration.name})`, {
+            context: evt.context,
+            properties: evt.properties,
+            userId: evt.context.distinctId
+          });
+          await integration.identify(
+            evt.context.distinctId,
+            evt.properties,
+            evt.context
+          );
+        }
+      } catch (error) {
+        this.logger.error(
+          `deliver error in ${integration.name} (${evt.type})`,
+          error
+        );
+      }
+    }
+  }
+  /**
+   * Flush queued events FIFO once at least one integration is ready.
+   */
+  flush() {
+    if (this.globalQueue.length === 0) {
+      return;
+    }
+    if (!this.isReady()) {
+      return;
+    }
+    this.logger.debug(`flushing ${this.globalQueue.length} queued events`);
+    const toSend = this.globalQueue;
+    this.globalQueue = [];
+    for (const evt of toSend) {
+      this.deliver(evt);
+    }
+  }
+  readyCount() {
+    let n = 0;
+    for (const s of this.integrations.values()) {
+      if (s.status === "ready") {
+        n += 1;
+      }
+    }
+    return n;
+  }
+  isReady() {
+    const timeElapsed = Date.now() - this.initTime;
+    if (this.readyCount() < this.integrations.size && timeElapsed < this.config.maxIntegrationWaitTime) {
+      return false;
+    }
+    if (this.readyCount() < this.integrations.size) {
+      this.logger.info(
+        `proceeding with ${this.readyCount()}/${this.integrations.size} integrations ready after ${timeElapsed}ms wait`
+      );
+    }
+    return true;
+  }
+  /**
+   * Setup periodic flushing if enabled
+   */
+  setupPeriodicFlushing() {
+    if (this.config.flushInterval <= 0) {
+      return;
+    }
+    this.flushTimer = setInterval(() => {
+      if (this.globalQueue.length > 0) {
+        this.flush();
+      }
+    }, this.config.flushInterval);
+  }
+  /**
+   * Setup page unload handler for client environment
+   */
+  setupUnloadHandler() {
+    if (this.currentEnvironment !== "client" || typeof window === "undefined") {
+      return;
+    }
+    this.unloadHandler = () => {
+      this.logger.info("page unloading, flushing remaining events");
+      this.flush();
+    };
+    window.addEventListener("beforeunload", this.unloadHandler);
+    window.addEventListener("pagehide", this.unloadHandler);
+  }
+  /** Debug helpers */
+  getStats() {
+    return {
+      context: this.context,
+      currentEnvironment: this.currentEnvironment,
+      flushInterval: this.config.flushInterval,
+      integrations: [...this.integrations.values()].map((s) => ({
+        environments: s.integration.environments,
+        name: s.integration.name,
+        status: s.status
+      })),
+      periodicFlushEnabled: this.config.flushInterval > 0,
+      queueLength: this.globalQueue.length,
+      readyCount: this.readyCount()
+    };
+  }
+};
+
+// src/lib/integrations/pinterest-tag.ts
+var isBrowser3 = typeof window !== "undefined";
+var isServer3 = !isBrowser3;
+var standardPinterestEvents = [
+  "checkout",
+  "addtocart",
+  "pagevisit",
+  "signup",
+  "watchvideo",
+  "lead",
+  "search",
+  "viewcategory",
+  "custom",
+  "addpaymentinfo",
+  "addtowishlist",
+  "initiatecheckout",
+  "subscribe",
+  "viewcontent"
+];
+function createPinterestTagIntegration(config, debug) {
+  let isTagReady = false;
+  const integrationLoggerLevel = getIntegrationLoggerLevel(
+    "pinterest-tag",
+    debug
+  );
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: "Saasco Pinterest Tag"
+  });
+  return {
+    name: "pinterest-tag",
+    environments: ["client"],
+    init: async (_context) => {
+      if (isServer3) {
+        logger.debug("Pinterest Tag init skipped on server");
+        return;
+      }
+      logger.info("Initializing Pinterest Tag", { tagId: config.tagId });
+      if (window.pintrk || window._pintrk) {
+        logger.warn("Pinterest Tag is already initialized");
+        isTagReady = true;
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          (function init(e) {
+            if (!window.pintrk) {
+              window.pintrk = function pintrk(...args) {
+                window.pintrk.queue.push(args);
+              };
+              const n = window.pintrk;
+              n.queue = [];
+              n.version = "3.0";
+              const t = document.createElement("script");
+              t.async = true;
+              t.src = e;
+              t.addEventListener("load", () => {
+                window.pintrk("load", config.tagId);
+                window.pintrk("page");
+                setTimeout(() => {
+                  logger.debug("Pinterest Tag initialized");
+                  isTagReady = true;
+                  resolve();
+                }, 500);
+              });
+              t.addEventListener("error", () => {
+                logger.error("Failed to load Pinterest Tag script");
+                reject(new Error("Failed to load Pinterest Tag script"));
+              });
+              const r = document.getElementsByTagName("script")[0];
+              r.parentNode.insertBefore(t, r);
+            }
+          })("https://s.pinimg.com/ct/core.js");
+        } catch (error) {
+          logger.error("Failed to initialize Pinterest Tag", error);
+          reject(error);
+        }
+      });
+    },
+    track: (eventName, properties) => {
+      if (!isTagReady || !window.pintrk) {
+        return;
+      }
+      const pinterestEventName = getPinterestEventName(
+        eventName,
+        config.eventMapping
+      );
+      const eventData = buildEventData(properties);
+      logger.debug("Tracking event", {
+        eventName,
+        pinterestEventName,
+        eventData
+      });
+      window.pintrk("track", pinterestEventName, eventData);
+    },
+    identify: (userId, properties, context) => {
+      const { pintrk } = window;
+      if (!pintrk) {
+        return;
+      }
+      logger.debug("Applying identify to Pinterest Tag", {
+        userId,
+        properties,
+        context
+      });
+      pintrk("set", { external_id: userId });
+      pintrk("set", { em: properties?.["email"] });
+    }
+  };
+}
+function getPinterestEventName(eventName, eventMapping) {
+  if (eventName === "Page View") {
+    return "pagevisit";
+  }
+  if (!eventMapping) {
+    return eventName.toLowerCase();
+  }
+  return eventMapping[eventName] || eventName.toLowerCase();
+}
+function buildEventData(properties) {
+  if (!properties) {
+    return {};
+  }
+  const eventData = {};
+  if (properties["event_id"]) {
+    eventData["event_id"] = properties["event_id"];
+  }
+  if (properties["value"]) {
+    eventData["value"] = properties["value"];
+  }
+  if (properties["currency"]) {
+    eventData["currency"] = properties["currency"];
+  }
+  if (properties["order_quantity"]) {
+    eventData["order_quantity"] = properties["order_quantity"];
+  }
+  if (properties["order_id"]) {
+    eventData["order_id"] = properties["order_id"];
+  }
+  if (properties["promo_code"]) {
+    eventData["promo_code"] = properties["promo_code"];
+  }
+  if (properties["property"]) {
+    eventData["property"] = properties["property"];
+  }
+  if (properties["search_query"]) {
+    eventData["search_query"] = properties["search_query"];
+  }
+  if (properties["video_title"]) {
+    eventData["video_title"] = properties["video_title"];
+  }
+  if (properties["lead_type"]) {
+    eventData["lead_type"] = properties["lead_type"];
+  }
+  if (properties["product_category"]) {
+    eventData["product_category"] = properties["product_category"];
+  }
+  if (properties["line_items"] && Array.isArray(properties["line_items"])) {
+    eventData["line_items"] = properties["line_items"];
+  }
+  if (!eventData["event_id"]) {
+    eventData["event_id"] = uuid();
+  }
+  return eventData;
+}
+
+// src/lib/integrations/tiktok-pixel.ts
+import { sha256 as sha2562 } from "js-sha256";
+var isBrowser4 = typeof window !== "undefined";
+var isServer4 = !isBrowser4;
+var standardTikTokEvents = [
+  "AddPaymentInfo",
+  "AddToCart",
+  "AddToWishlist",
+  "ApplicationApproval",
+  "CompleteRegistration",
+  "Contact",
+  "CustomizeProduct",
+  "Download",
+  "FindLocation",
+  "InitiateCheckout",
+  "Lead",
+  "Purchase",
+  "Schedule",
+  "Search",
+  "StartTrial",
+  "SubmitApplication",
+  "Subscribe",
+  "ViewContent",
+  "PageView"
+];
+function createTikTokPixelIntegration(config, debug) {
+  let isPixelReady = false;
+  const integrationLoggerLevel = getIntegrationLoggerLevel(
+    "tiktok-pixel",
+    debug
+  );
+  const logger = new AnalyticsLogger({
+    level: integrationLoggerLevel,
+    label: "Saasco tiktok-pixel"
+  });
+  return {
+    name: "tiktok-pixel",
+    environments: ["client"],
+    init: async () => {
+      if (isServer4) {
+        logger.debug("TikTok Pixel init skipped on server");
+        return;
+      }
+      logger.info("Initializing TikTok Pixel", { pixelId: config.pixelId });
+      if (window.ttq) {
+        logger.warn("TikTok Pixel is already initialized");
+        isPixelReady = true;
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          (function init(w, d, t) {
+            w.TiktokAnalyticsObject = t;
+            const ttq = w[t] ||= [];
+            ttq.methods = [
+              "page",
+              "track",
+              "identify",
+              "instances",
+              "debug",
+              "on",
+              "off",
+              "once",
+              "ready",
+              "alias",
+              "group",
+              "enableCookie",
+              "disableCookie",
+              "holdConsent",
+              "revokeConsent",
+              "grantConsent"
+            ];
+            ttq.setAndDefer = function setAndDefer(t2, e) {
+              t2[e] = function(...args) {
+                t2.push([e, ...args]);
+              };
+            };
+            for (const method of ttq.methods) {
+              ttq.setAndDefer(ttq, method);
+            }
+            ttq.instance = function instance(t2) {
+              const e = ttq._i[t2] || [];
+              for (const method of ttq.methods) {
+                ttq.setAndDefer(e, method);
+              }
+              return e;
+            };
+            ttq.load = function load(e, n) {
+              const r = "https://analytics.tiktok.com/i18n/pixel/events.js";
+              const _o = n && n.partner;
+              ttq._i ||= {};
+              ttq._i[e] = [];
+              ttq._i[e]._u = r;
+              ttq._t ||= {};
+              ttq._t[e] = Date.now();
+              ttq._o ||= {};
+              ttq._o[e] = n || {};
+              const script = document.createElement("script");
+              script.type = "text/javascript";
+              script.async = true;
+              script.src = `${r}?sdkid=${e}&lib=${t}`;
+              script.addEventListener("load", () => {
+                isPixelReady = true;
+                resolve();
+              });
+              script.addEventListener("error", () => {
+                reject(new Error("Failed to load TikTok Pixel script"));
+              });
+              const firstScript = document.getElementsByTagName("script")[0];
+              firstScript.parentNode.insertBefore(script, firstScript);
+            };
+            ttq.load(
+              config.pixelId,
+              config.testMode ? { test_mode: true } : void 0
+            );
+            if (window.ttq && typeof window.ttq === "function") {
+              isPixelReady = true;
+              resolve();
+            }
+          })(window, document, "ttq");
+        } catch (error) {
+          reject(error);
+        }
+      });
+    },
+    track: (eventName, properties, _context) => {
+      const { ttq } = window;
+      if (!isPixelReady || !ttq) {
+        return;
+      }
+      const ttEventName = getTikTokEventName(eventName, config.eventMapping);
+      if (ttEventName === "PageView") {
+        ttq.page?.();
+        return;
+      }
+      const ttParams = mapTikTokEventParameters(ttEventName, properties);
+      if (ttParams && Object.keys(ttParams).length > 0) {
+        ttq.track?.(ttEventName, ttParams);
+      } else {
+        ttq.track?.(ttEventName);
+      }
+    },
+    identify: (userId, properties, _context) => {
+      try {
+        const ttq = typeof window === "undefined" ? void 0 : window.ttq;
+        if (ttq) {
+          const identifyData = coerceTikTokIdentifyValues({
+            ...properties,
+            ...userId ? { external_id: userId } : {}
+          });
+          if (Object.keys(identifyData).length > 0) {
+            ttq.identify?.(identifyData);
+          }
+        }
+      } catch (error) {
+        console.error("Error identifying user in TikTok Pixel:", error);
+      }
+    }
+  };
+}
+function getTikTokEventName(eventName, eventMapping) {
+  if (eventName === "Page View") {
+    return "PageView";
+  }
+  if (!eventMapping) {
+    return eventName;
+  }
+  return eventMapping[eventName] || eventName;
+}
+function coerceTikTokIdentifyValues(properties) {
+  const coerce = [
+    {
+      key: "email",
+      coerceFrom: [
+        "email",
+        "user_email",
+        "userEmail",
+        "email_address",
+        "emailAddress",
+        "e_mail",
+        "E_Mail",
+        "mail",
+        "Mail",
+        "contact_email",
+        "contactEmail",
+        "primary_email",
+        "primaryEmail"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string") {
+          return;
+        }
+        const normalized = value.trim().toLowerCase();
+        return normalized ? sha2562(normalized) : void 0;
+      }
+    },
+    {
+      key: "phone_number",
+      coerceFrom: [
+        "phone",
+        "phone_number",
+        "phoneNumber",
+        "mobile",
+        "mobile_number",
+        "mobileNumber",
+        "contact_number",
+        "contactNumber",
+        "tel",
+        "telephone"
+      ],
+      transform: (value) => {
+        if (typeof value !== "string" && typeof value !== "number") {
+          return;
+        }
+        const phoneStr = String(value).replaceAll(/\D/gu, "");
+        return phoneStr ? sha2562(phoneStr) : void 0;
+      }
+    },
+    {
+      key: "external_id",
+      coerceFrom: [
+        "external_id",
+        "externalId",
+        "user_id",
+        "userId",
+        "id",
+        "distinctId",
+        "distinct_id",
+        "customer_id",
+        "customerId",
+        "member_id",
+        "memberId"
+      ],
+      transform: (value) => {
+        if (value === null || value === void 0) {
+          return;
+        }
+        const stringValue = String(value);
+        return stringValue ? sha2562(stringValue) : void 0;
+      }
+    }
+  ];
+  const result = {};
+  for (const { key, coerceFrom, transform } of coerce) {
+    const foundValue = findFirstProperty2(properties, coerceFrom);
+    if (foundValue !== null && transform) {
+      const transformedValue = transform(foundValue);
+      if (transformedValue) {
+        result[key] = transformedValue;
+      }
+    } else if (foundValue !== null && typeof foundValue === "string") {
+      result[key] = foundValue;
+    }
+  }
+  return result;
+}
+function findFirstProperty2(properties, keys) {
+  for (const key of keys) {
+    if (properties[key] !== void 0) {
+      return properties[key];
+    }
+  }
+  return null;
+}
+function mapTikTokEventParameters(eventName, properties) {
+  if (!properties) {
+    return null;
+  }
+  const params = {};
+  const addParam = (key, value) => {
+    if (value !== null && value !== void 0 && typeof value !== "object") {
+      params[key] = value;
+    }
+  };
+  switch (eventName) {
+    case "AddToCart":
+    case "Purchase":
+    case "ViewContent": {
+      addParam("content_type", properties["content_type"]);
+      addParam("content_ids", properties["content_ids"]);
+      addParam("quantity", properties["quantity"]);
+      addParam("description", properties["description"]);
+      addParam("currency", properties["currency"]);
+      addParam("value", properties["value"]);
+      addParam("content_name", properties["content_name"]);
+      addParam("content_category", properties["content_category"]);
+      break;
+    }
+    case "StartTrial": {
+      addParam("content_ids", properties["content_ids"]);
+      addParam("currency", properties["currency"]);
+      addParam("value", properties["value"]);
+      break;
+    }
+    case "Search": {
+      const searchString = properties["search_string"] || properties["query"] || properties["search_query"];
+      addParam("search_string", searchString);
+      break;
+    }
+    case "InitiateCheckout":
+    case "AddPaymentInfo": {
+      addParam("value", properties["value"]);
+      addParam("currency", properties["currency"]);
+      addParam("content_ids", properties["content_ids"]);
+      addParam("quantity", properties["quantity"]);
+      break;
+    }
+    case "CompleteRegistration":
+    case "Subscribe": {
+      addParam("value", properties["value"]);
+      addParam("currency", properties["currency"]);
+      break;
+    }
+    default: {
+      addParam("value", properties["value"]);
+      addParam("currency", properties["currency"]);
+      break;
+    }
+  }
+  return Object.keys(params).length > 0 ? params : null;
+}
+
+// src/lib/saascoOrigin.ts
+var SAASCO_ORIGIN = "https://www.saasco.com";
+var APEX_ORIGIN = "https://saasco.com";
+var CANONICAL_HOST = "www.saasco.com";
+var TRAILING_SLASHES_RE = /\/+$/u;
+function normalizeSaascoBaseUrl(baseUrl) {
+  return baseUrl.replace(TRAILING_SLASHES_RE, "") === APEX_ORIGIN ? SAASCO_ORIGIN : baseUrl;
+}
+function normalizeSaascoUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return url;
+  }
+  if (parsed.origin !== APEX_ORIGIN) {
+    return url;
+  }
+  parsed.host = CANONICAL_HOST;
+  return parsed.toString();
+}
+
+// src/lib/social-proof/storage.ts
+var WIDGET_PAYLOAD_PATH = "/api/social-proof/widget";
+var SOCIAL_PROOF_LOADER_FILE = "saasco-social-proof-loader.js";
+var SOCIAL_PROOF_QA_PARAM = "saasco_notifications";
+var WIDGET_PAYLOAD_CACHE_KEY_PREFIX = "saasco-notif-widget:";
+var WIDGET_PAYLOAD_CACHE_TTL_MS = 20 * 60 * 1e3;
+var DISMISSED_AT_KEY = "saasco-notif-dismissed-at";
+var DISMISS_SUPPRESSION_MS = 24 * 36e5;
+function readSession(key) {
+  try {
+    return window.sessionStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeSession(key, value) {
+  try {
+    window.sessionStorage.setItem(key, value);
+  } catch {
+  }
+}
+function readFreshWidgetPayloadCache(cacheKey) {
+  const raw = readSession(cacheKey);
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const cached = JSON.parse(raw);
+    if (typeof cached.fetchedAt === "number" && Date.now() - cached.fetchedAt < WIDGET_PAYLOAD_CACHE_TTL_MS && typeof cached.data?.enabled === "boolean") {
+      return cached.data;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readLocal(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function isDismissSuppressed() {
+  const raw = readLocal(DISMISSED_AT_KEY);
+  if (raw === null) {
+    return false;
+  }
+  const dismissedAt = Number(raw);
+  return Number.isFinite(dismissedAt) && Date.now() - dismissedAt < DISMISS_SUPPRESSION_MS;
+}
+
+// src/lib/social-proof/widgetPayloadCheck.ts
+async function injectSocialProofLoader({
+  baseUrl: baseUrlOverride,
+  projectId,
+  scriptUrl
+}) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return;
+  }
+  if (isSocialProofLoaderPresent()) {
+    return;
+  }
+  if (!isSocialProofQaMode()) {
+    const baseUrl = normalizeSaascoBaseUrl(
+      baseUrlOverride ?? getUrlOrigin(scriptUrl) ?? SAASCO_ORIGIN
+    );
+    const enabled = await shouldInjectSocialProof({
+      baseUrl,
+      projectId
+    });
+    if (!enabled) {
+      return;
+    }
+  }
+  if (isSocialProofLoaderPresent()) {
+    return;
+  }
+  window.__saascoSocialProofInjected = true;
+  const script = document.createElement("script");
+  script.async = true;
+  script.src = normalizeSaascoUrl(scriptUrl);
+  script.setAttribute("data-projectId", projectId);
+  if (baseUrlOverride !== void 0) {
+    script.setAttribute(
+      "data-base-url",
+      normalizeSaascoBaseUrl(baseUrlOverride)
+    );
+  }
+  (document.body ?? document.head ?? document.documentElement).append(script);
+}
+async function shouldInjectSocialProof({
+  baseUrl,
+  projectId
+}) {
+  if (isDismissSuppressed()) {
+    return false;
+  }
+  const cacheKey = `${WIDGET_PAYLOAD_CACHE_KEY_PREFIX}${projectId}`;
+  const cached = readFreshWidgetPayloadCache(cacheKey);
+  if (cached !== void 0) {
+    return isEnabledPayload(cached);
+  }
+  let data2;
+  try {
+    const response = await fetch(
+      `${baseUrl}${WIDGET_PAYLOAD_PATH}?projectId=${encodeURIComponent(projectId)}`
+    );
+    if (!response.ok) {
+      return false;
+    }
+    data2 = await response.json();
+  } catch {
+    return false;
+  }
+  writeSession(cacheKey, JSON.stringify({ data: data2, fetchedAt: Date.now() }));
+  return isEnabledPayload(data2);
+}
+function isEnabledPayload(data2) {
+  return typeof data2 === "object" && data2 !== null && data2.enabled === true;
+}
+function isSocialProofLoaderPresent() {
+  return Boolean(
+    window.__saascoSocialProofInjected || document.querySelector(`script[src*="${SOCIAL_PROOF_LOADER_FILE}"]`)
+  );
+}
+function getUrlOrigin(url) {
+  try {
+    return new URL(
+      url,
+      typeof window === "undefined" ? void 0 : window.location.href
+    ).origin;
+  } catch {
+  }
+}
+function isSocialProofQaMode() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    const mode = new URLSearchParams(window.location.search).get(
+      SOCIAL_PROOF_QA_PARAM
+    );
+    return mode === "test" || mode === "reset";
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/analytics.ts
+function getSupportGlobal() {
+  return window.SaascoSupport;
+}
+var isBrowser5 = typeof window !== "undefined";
+var isServer5 = !isBrowser5;
+var PREF = "saasco-sdk";
+var SESSION_DURATION = 1e3 * 60 * 30;
+var USER_DURATION = 1e3 * 60 * 60 * 24 * 365;
+var SUPPORT_ATTR_MAP = {
+  baseUrl: "data-base-url",
+  placeholder: "data-placeholder"
+};
+var data = {};
+function getRootDomain(url) {
+  if (isServer5) {
+    return;
+  }
+  if (!url) {
+    return;
+  }
+  try {
+    const { hostname } = new URL(url);
+    if (!isValid(hostname)) {
+      return;
+    }
+    const parsed = parse(hostname);
+    if ("domain" in parsed && parsed.domain) {
+      return parsed.domain;
+    }
+  } catch {
+  }
+}
+function isSameRootDomain(url1, url2) {
+  const root1 = getRootDomain(url1);
+  const root2 = getRootDomain(url2);
+  return !!root1 && !!root2 && root1 === root2;
+}
+function setCookie(name, value, ttl) {
+  if (isServer5) {
+    return;
+  }
+  const expires = new Date(Date.now() + ttl).toUTCString();
+  const domain = getRootDomain(window.location.href);
+  const cookieString = `${name}=${encodeURIComponent(
+    value
+  )}; expires=${expires}; path=/${domain ? `; domain=.${domain}` : ""}`;
+  document.cookie = cookieString;
+}
+function getCookie(name) {
+  if (isServer5) {
+    return null;
+  }
+  const nameEQ = `${name}=`;
+  const ca = document.cookie.split(";");
+  for (const part of ca) {
+    let c = part;
+    while (c.charAt(0) === " ") {
+      c = c.slice(1);
+    }
+    if (c.indexOf(nameEQ) === 0) {
+      return decodeURIComponent(c.slice(nameEQ.length));
+    }
+  }
+  return null;
+}
+function deleteCookie(name) {
+  if (isServer5) {
+    return;
+  }
+  const domain = getRootDomain(window.location.href);
+  const cookieString = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/${domain ? `; domain=.${domain}` : ""}`;
+  document.cookie = cookieString;
+}
+function migrateFromLocalStorage() {
+  if (isServer5) {
+    return;
+  }
+  const keysToMigrate = [
+    `${PREF}-session-id`,
+    `${PREF}-anonymous-id`,
+    `${PREF}-user-id`,
+    `${PREF}-session-utm-context`,
+    `${PREF}-super-context`
+  ];
+  for (const key of keysToMigrate) {
+    try {
+      const value = localStorage.getItem(key);
+      if (value) {
+        const item = JSON.parse(value);
+        const now = Date.now();
+        if (item.expiry > now) {
+          const remainingTtl = item.expiry - now;
+          setCookie(key, JSON.stringify(item.value), remainingTtl);
+          localStorage.removeItem(key);
+        } else {
+          localStorage.removeItem(key);
+        }
+      }
+    } catch {
+      localStorage.removeItem(key);
+    }
+  }
+}
+function storeData(key, value, ttl) {
+  if (isServer5) {
+    const item = {
+      value,
+      expiry: Date.now() + ttl
+    };
+    if (value === void 0) {
+      delete data[key];
+      return;
+    }
+    data[key] = item;
+    return;
+  }
+  const fullKey = `${PREF}-${key}`;
+  if (value === void 0) {
+    deleteCookie(fullKey);
+    return;
+  }
+  setCookie(fullKey, JSON.stringify(value), ttl);
+}
+function retrieveData(key) {
+  if (isServer5) {
+    const item = data[key];
+    if (!item) {
+      return null;
+    }
+    if (Date.now() > item.expiry) {
+      delete data[key];
+      return null;
+    }
+    return item.value;
+  }
+  const fullKey = `${PREF}-${key}`;
+  const itemStr = getCookie(fullKey);
+  if (!itemStr) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(itemStr);
+    if (parsed !== null && typeof parsed === "object" && "value" in parsed && "expiry" in parsed) {
+      return parsed.value;
+    }
+    return parsed;
+  } catch {
+    deleteCookie(fullKey);
+    return null;
+  }
+}
+function getSessionId() {
+  return retrieveData(`session-id`);
+}
+function setSessionId({ reset } = { reset: false }) {
+  const sessionId = reset ? uuid() : getSessionId() || uuid();
+  storeData(`session-id`, sessionId, SESSION_DURATION);
+  return sessionId;
+}
+function getAnonymousId() {
+  return retrieveData(`anonymous-id`);
+}
+function setAnonymousId({ reset } = { reset: false }) {
+  const anonymousId = reset ? uuid() : getAnonymousId() || uuid();
+  storeData(`anonymous-id`, anonymousId, USER_DURATION);
+  return anonymousId;
+}
+function getServerSideAnonymousId(userId) {
+  return `server-${userId}`;
+}
+function isSoftDistinctId(distinctId) {
+  return distinctId.startsWith("soft_");
+}
+function getUserId() {
+  return retrieveData(`user-id`);
+}
+function setUserId(userId) {
+  storeData(`user-id`, userId ?? void 0, USER_DURATION);
+}
+function buildSupportTraits(properties, envelope) {
+  const traits = {};
+  const add = (key, value) => {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      traits[key] = value;
+    }
+  };
+  if (isBrowser5) {
+    for (const [key, value] of Object.entries(getBrowserContext())) {
+      add(key, value);
+    }
+  }
+  for (const [key, value] of Object.entries(properties ?? {})) {
+    add(key, value);
+  }
+  add("anonymousId", envelope.anonymousId);
+  add("sessionId", envelope.sessionId);
+  return traits;
+}
+function getSuperContext() {
+  return retrieveData("super-context") || {};
+}
+function setSuperContext(superContext) {
+  storeData("super-context", superContext, SESSION_DURATION);
+}
+function updateSuperContext(browserContext) {
+  const existingSuperContext = getSuperContext();
+  const sessionScopedKeys = [
+    "$utmSource",
+    "$utmMedium",
+    "$utmCampaign",
+    "$utmTerm",
+    "$utmContent",
+    "$utmId",
+    "$utmSourcePlatform",
+    "$utmCampaignId",
+    "$utmCreativeFormat",
+    "$utmMarketingTactic",
+    "$utmAdSource",
+    "$utmAdId"
+  ];
+  const superContext = existingSuperContext;
+  for (const key of sessionScopedKeys) {
+    if (!superContext[key]) {
+      const value = { ...browserContext }[key];
+      if (value) {
+        superContext[key] = value;
+      }
+    }
+  }
+  if (browserContext.$referrer && !isSameRootDomain(browserContext.$referrer, browserContext.$href)) {
+    superContext["$referrer"] = browserContext.$referrer;
+    if (browserContext.$referringDomain) {
+      superContext["$referringDomain"] = browserContext.$referringDomain;
+    }
+  }
+  setSuperContext(superContext);
+  return superContext;
+}
+var IDENTIFY_DEDUP_OMIT_PROPERTY_KEYS = /* @__PURE__ */ new Set([
+  "exp",
+  "iat",
+  "jti",
+  "nbf",
+  "sub",
+  "updatedAt"
+]);
+var IDENTIFY_DEDUP_OMIT_META_KEYS = /* @__PURE__ */ new Set(["recentProjects"]);
+function getPropertiesForIdentifyDedup(properties) {
+  const dedupProperties = {};
+  for (const key of Object.keys(properties).sort()) {
+    if (key.startsWith("$") || IDENTIFY_DEDUP_OMIT_PROPERTY_KEYS.has(key)) {
+      continue;
+    }
+    if (key === "picture" && properties.image) {
+      continue;
+    }
+    const value = properties[key];
+    if (key === "meta" && value && typeof value === "object") {
+      const meta = value;
+      const dedupMeta = {};
+      for (const metaKey of Object.keys(meta).sort()) {
+        if (IDENTIFY_DEDUP_OMIT_META_KEYS.has(metaKey)) {
+          continue;
+        }
+        dedupMeta[metaKey] = meta[metaKey];
+      }
+      if (Object.keys(dedupMeta).length > 0) {
+        dedupProperties.meta = dedupMeta;
+      }
+      continue;
+    }
+    if (key === "projectIds" && Array.isArray(value)) {
+      dedupProperties.projectIds = [...value].sort();
+      continue;
+    }
+    dedupProperties[key] = value;
+  }
+  return dedupProperties;
+}
+function getIdentifyDedupKey(distinctId, properties, context) {
+  const dedupProperties = getPropertiesForIdentifyDedup(properties ?? {});
+  return `${distinctId}:${JSON.stringify(dedupProperties)}:${JSON.stringify(context ?? {})}`;
+}
+function readLastIdentifyKey() {
+  if (isBrowser5) {
+    return window.saascoLastIdentifyKey ?? "";
+  }
+  return "";
+}
+function writeLastIdentifyKey(key) {
+  if (isBrowser5) {
+    window.saascoLastIdentifyKey = key;
+  }
+}
+var Saasco = class {
+  /**
+   * Creates an instance of the Saasco SDK.
+   * @param config Configuration options.
+   * @param config.projectId The unique identifier for the project.
+   * @param config.proxy The URL of the proxy server to use, if any.
+   * @param config.autoPageTracking Whether to automatically track page views. Default is false.
+   * @param config.enabled Whether analytics is enabled. Default is true. Set to false for development and staging envioronments. Will still allow debug mode to be true, just no events will be sent
+   * @param config.debug Whether to log debug information. Default is false.
+   * @param config.trackUrlParams Whether to track URL parameters. Default is true.
+   * @param config.trackHashChanges Whether to track hash changes. Default is true.
+   * @param config.integrations Configuration for third-party integrations like Facebook Pixel.
+   */
+  constructor(config) {
+    this.config = config;
+    const loggerLevel = getLoggerLevel(this.config);
+    this.logger = new AnalyticsLogger({
+      level: loggerLevel,
+      label: "Saasco Debug"
+    });
+    this.logger.info("Saasco started");
+    if (!config.projectId) {
+      this.logger.error(
+        "Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly."
+      );
+      return;
+    }
+    this.config.enabled = this.config.enabled === void 0 ? true : this.config.enabled;
+    this.config.autoPageTracking = {
+      enabled: true,
+      trackQueryParams: true,
+      trackHash: true,
+      ...this.config.autoPageTracking
+    };
+    this.integrationManager = new IntegrationManager({
+      loggerLevel,
+      maxQueueSize: 1e3
+    });
+    this.integrationManager.setContext({});
+    void (async () => {
+      try {
+        await this.initIntegrations();
+      } catch (error) {
+        this.logger.info("Error initializing integrations:", error);
+      }
+    })();
+  }
+  // Dedup state lives on window in the browser so it survives duplicate module
+  // instances from bundlers/HMR. The dedup key keeps all caller-supplied traits
+  // except known volatile fields (JWT claims, updatedAt, $-prefixed keys, etc.).
+  lastPageViewPath = "";
+  isInitialized = false;
+  integrationManager;
+  logger;
+  // Last identity handed to `identify()`, mirrored into the lazily-loaded
+  // support widget so chat conversations attach to a CRM contact. Held
+  // here so an `identify()` that fires before the widget bundle finishes
+  // loading is replayed once it does.
+  lastSupportIdentity = null;
+  init() {
+    if (this.isInitialized) {
+      this.logger.info(
+        "Saasco is already initialized. Please check your code to ensure that init() is not being called multiple times."
+      );
+      return;
+    }
+    if (isBrowser5) {
+      window.saasco = this;
+    }
+    migrateFromLocalStorage();
+    this.logger.info("Saasco initialized", this.config);
+    if (this.config.debug) {
+      this.logger.info(
+        "Debug mode active. This will log all events to the console."
+      );
+    }
+    if (!this.config.enabled) {
+      this.logger.info(
+        `Analytics is disabled. No requests will be sent to the server and no integrations will be initialized. ${this.config.debug ? "Debug mode is active and will still log information." : ""}`
+      );
+    }
+    this.initAutoPageTracking();
+    if (this.config.support && this.config.support.enabled !== false) {
+      this.injectSupport();
+    }
+    if (this.config.socialProof?.enabled !== false) {
+      void this.injectSocialProof();
+    }
+    this.isInitialized = true;
+  }
+  disableDebug() {
+    this.logger.info("Debug mode deactivated.");
+    this.config.debug = false;
+  }
+  enableDebug() {
+    this.config.debug = true;
+    this.logger.info("Debug mode activated.");
+  }
+  /**
+   * Enables and injects the support widget when it was constructed with
+   * `support: { enabled: false }`. Safe to call multiple times.
+   */
+  enableSupport() {
+    if (!this.config.support) {
+      this.logger.warn(
+        "Support is not configured; enableSupport() was ignored."
+      );
+      return;
+    }
+    this.config.support.enabled = true;
+    this.injectSupport();
+    this.pushSupportIdentity();
+  }
+  /**
+   * Enables and injects the social-proof widget (e.g. after constructing with
+   * `socialProof: { enabled: false }`, or when no `socialProof` block was
+   * passed). Injection still runs the server check, so the loader only
+   * downloads when the project has the app enabled in the dashboard.
+   * Safe to call multiple times — the loader injection is guarded against
+   * double-injection.
+   */
+  enableSocialProof() {
+    this.config.socialProof = {
+      ...this.config.socialProof,
+      enabled: true
+    };
+    void this.injectSocialProof();
+  }
+  /**
+   * Initialize third-party integrations
+   */
+  async initIntegrations() {
+    this.logger.info("Initialize integrations");
+    if (!this.config.integrations || this.config.integrations.length === 0) {
+      return;
+    }
+    if (!this.config.enabled) {
+      this.logger.info(
+        "Analytics is disabled. Skipping integration initialization."
+      );
+      return;
+    }
+    for (const integrationConfig of this.config.integrations) {
+      try {
+        if (integrationConfig.type === "facebook-pixel") {
+          this.logger.info(
+            "Registering Facebook Pixel integration with ID:",
+            integrationConfig.config.pixelId
+          );
+          const fbIntegration = createFacebookPixelIntegration(
+            integrationConfig.config,
+            integrationConfig.debug
+          );
+          await this.integrationManager.registerIntegration(fbIntegration);
+        } else if (integrationConfig.type === "pinterest-tag") {
+          this.logger.info(
+            "Registering Pinterest Tag integration with ID:",
+            integrationConfig.config.tagId
+          );
+          const pinterestIntegration = createPinterestTagIntegration(
+            integrationConfig.config,
+            integrationConfig.debug
+          );
+          await this.integrationManager.registerIntegration(
+            pinterestIntegration
+          );
+        } else if (integrationConfig.type === "tiktok-pixel") {
+          this.logger.info(
+            "Registering TikTok Pixel integration with ID:",
+            integrationConfig.config.pixelId
+          );
+          const tiktokIntegration = createTikTokPixelIntegration(
+            integrationConfig.config,
+            integrationConfig.debug
+          );
+          await this.integrationManager.registerIntegration(tiktokIntegration);
+        }
+      } catch (error) {
+        this.logger.info(
+          `Failed to register ${integrationConfig.type} integration:`,
+          error
+        );
+      }
+    }
+  }
+  track(actionOrPayload, propertiesOrNothing, contextOrNothing) {
+    if (!this.config.projectId) {
+      return Promise.resolve(
+        this.logger.error(
+          "Unable to track event. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly."
+        )
+      );
+    }
+    const validationError = validateTrackCall(actionOrPayload, this.logger);
+    if (validationError) {
+      return Promise.resolve(validationError);
+    }
+    const hasAction = typeof actionOrPayload === "string";
+    const action = hasAction ? actionOrPayload : actionOrPayload.event;
+    const properties = hasAction ? propertiesOrNothing : actionOrPayload.properties;
+    const context = hasAction ? contextOrNothing : actionOrPayload.context;
+    const { anonymousId, distinctId, sessionId } = resolveTrackIdentity(actionOrPayload);
+    let browserContext;
+    let superContext;
+    if (isBrowser5) {
+      browserContext = getBrowserContext();
+      superContext = updateSuperContext(browserContext);
+    }
+    const requestData = {
+      id: uuid(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      version,
+      sessionId,
+      anonymousId,
+      // Send an explicit null when anonymous. The ingest schema requires the
+      // `distinctId` key to be present (`z.string().nullish()`), and a bare
+      // `undefined` is dropped by JSON.stringify, which 400s the event.
+      distinctId: distinctId ?? null,
+      projectId: this.config.projectId,
+      payload: JSON.stringify({
+        ...browserContext,
+        ...superContext,
+        properties: properties || {}
+      }),
+      source: isBrowser5 ? "client" : "server",
+      context: JSON.stringify(context || {})
+    };
+    if (requestData.action === "Page View") {
+      this.logger.info("Page View", window.location.href, requestData);
+    } else {
+      this.logger.info("track", requestData);
+    }
+    if (!this.config.enabled) {
+      return Promise.resolve({
+        success: true,
+        message: "Analytics is disabled"
+      });
+    }
+    this.integrationManager.track(action, properties);
+    return this.doRequest("events", requestData);
+  }
+  /**
+   * The page method lets you record page views on your website
+   * This records the page title and path and names the event useing the reserved property "Page Viewed"
+   *
+   * Before implementing this make sure you have disabled the autoPageTracking in the config or you will get duplicate page views
+   */
+  page() {
+    if (isServer5) {
+      console.warn("Saasco page tracking is only available in the browser");
+      return;
+    }
+    const url = new URL(window.location.href);
+    let pathToCompare = url.pathname;
+    if (this.config.autoPageTracking?.trackQueryParams) {
+      pathToCompare += url.search;
+    }
+    if (this.config.autoPageTracking?.trackHash) {
+      pathToCompare += url.hash;
+    }
+    if (pathToCompare === this.lastPageViewPath) {
+      return;
+    }
+    this.lastPageViewPath = pathToCompare;
+    return this.track("Page View");
+  }
+  identify(distinctIdOrProperties, propertiesOrContext, contextOrNothing) {
+    if (!this.config.projectId) {
+      return Promise.resolve(
+        this.logger.error(
+          "Unable to identify user. Project ID is required but has not been provided. If you are using an env variable make sure it's set correctly."
+        )
+      );
+    }
+    const { context, distinctId, hasId, properties } = resolveIdentifyArgs(
+      distinctIdOrProperties,
+      propertiesOrContext,
+      contextOrNothing
+    );
+    const userIdChangedToNull = distinctId === null && !!getUserId();
+    if (userIdChangedToNull) {
+      this.logger.info("User logged out");
+    }
+    const hasRealDistinctId = distinctId !== null && !isSoftDistinctId(distinctId);
+    const { anonymousId, sessionId } = resolveIdentifySessionIds({
+      distinctId: hasRealDistinctId ? distinctId : null,
+      reset: userIdChangedToNull
+    });
+    setUserId(distinctId);
+    this.updateSupportIdentity({
+      distinctId: hasId && distinctId !== null ? distinctId : void 0,
+      email: typeof properties?.["email"] === "string" ? properties["email"] : void 0,
+      // Forward the full scalar payload (browser/track context + identify traits
+      // + session envelope) so the widget can bind them via live context without
+      // the host mirroring traits into `setStateSnapshot`.
+      traits: buildSupportTraits(properties, { anonymousId, sessionId })
+    });
+    this.integrationManager.setContext({
+      distinctId,
+      anonymousId,
+      sessionId,
+      ...properties
+    });
+    if (!distinctId) {
+      writeLastIdentifyKey("");
+      return Promise.resolve({
+        success: true,
+        message: "No distinctId provided"
+      });
+    }
+    const identifyKey = getIdentifyDedupKey(distinctId, properties, context);
+    if (identifyKey === readLastIdentifyKey()) {
+      this.logger.info("Skipping duplicate identify");
+      return Promise.resolve({
+        success: true,
+        message: "Duplicate identify skipped"
+      });
+    }
+    writeLastIdentifyKey(identifyKey);
+    let browserContext;
+    let superContext;
+    if (isBrowser5) {
+      browserContext = getBrowserContext();
+      superContext = updateSuperContext(browserContext);
+    }
+    const requestData = {
+      id: uuid(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectId: this.config.projectId,
+      distinctId,
+      anonymousId,
+      version,
+      payload: {
+        ...browserContext,
+        ...properties,
+        ...superContext
+      },
+      context: context || {}
+    };
+    this.logger.info("identify", requestData);
+    if (!this.config.enabled) {
+      return Promise.resolve({
+        success: true,
+        message: "Analytics is disabled"
+      });
+    }
+    this.integrationManager.identify(distinctId, properties);
+    return this.doRequest("identify", requestData);
+  }
+  /**
+   * This should only be called when the user logs out
+   * It will reset the session, anonymous id, and user id
+   *
+   * All events after calling reset will be tracked as a new user
+   *
+   */
+  logout() {
+    setSuperContext(null);
+    this.identify(null);
+  }
+  /**
+   * Handles sending data to the Analytics API
+   * If you have a proxy set up, it will send the data to the proxy and you can handle forwarding the data to the Analytics events API
+   * @param path - API path relative to the analytics base URL
+   * @param data - Request payload to send
+   */
+  async doRequest(path, requestData) {
+    const base = this.config.proxy || "https://t.saasco.com/";
+    const url = `${base}${path}`;
+    if (this.config.enabled === false) {
+      return {
+        success: false,
+        message: "Analytics is disabled"
+      };
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestData)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(
+        `Network request failed`,
+        `
+Error Message: "${message}"`,
+        `
+Url: "${url}"`
+      );
+      return {
+        success: false,
+        message
+      };
+    }
+    try {
+      const responseBody = await response.json();
+      if (!response.ok) {
+        throw new Error(
+          `${responseBody.message}: ${responseBody.errors ? `[${responseBody.errors.join(", ")}]` : ""}` || JSON.stringify(responseBody)
+        );
+      }
+      return {
+        success: true,
+        message: responseBody.message ?? ""
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(
+        `
+Error Message: "${message}"`,
+        `
+Path: "/${path}"`,
+        `
+Request Data: ${JSON.stringify(requestData, null, 2)}`
+      );
+      return {
+        success: false,
+        message
+      };
+    }
+  }
+  /**
+   * If autoPageTracking is enabled, this will automatically track page views
+   * It listens to url changes to track new pages every time the url changes
+   * @returns void
+   */
+  initAutoPageTracking() {
+    if (!this.config.autoPageTracking?.enabled) {
+      return;
+    }
+    if (isServer5) {
+      return console.warn(
+        "Auto page tracking is only available in the browser"
+      );
+    }
+    if (window.saascoAutoPageTrackingActive) {
+      this.logger.info("Auto Page Tracking already enabled");
+      return;
+    }
+    window.saascoAutoPageTrackingActive = true;
+    this.logger.info("Auto Page Tracking enabled");
+    this.page();
+    if (this.config.autoPageTracking?.trackHash) {
+      window.addEventListener("hashchange", () => this.page());
+    }
+    window.addEventListener("popstate", () => this.page());
+    const historyPushState = history.pushState;
+    history.pushState = (...args) => {
+      const returnValue = historyPushState.apply(history, args);
+      this.page();
+      return returnValue;
+    };
+    const historyReplaceState = history.replaceState;
+    history.replaceState = (...args) => {
+      const returnValue = historyReplaceState.apply(history, args);
+      this.page();
+      return returnValue;
+    };
+  }
+  getIntegrationsStats() {
+    return this.integrationManager.getStats();
+  }
+  /**
+   * Lazily injects the support **loader** from the same `/sdk/` origin as
+   * the analytics bundle, forwarding the shared `projectId` and the widget
+   * config as `data-*` attributes. The loader (no React) injects the
+   * cross-origin embed iframe. Deferred (`async`) and guarded against
+   * double-injection so re-running `init()` is a no-op.
+   */
+  injectSupport() {
+    if (!isBrowser5 || typeof document === "undefined") {
+      return;
+    }
+    const chat = this.config.support;
+    if (!chat) {
+      return;
+    }
+    if (window.__saascoSupportInjected || document.querySelector('script[src*="saasco-support-loader.js"]')) {
+      return;
+    }
+    const scriptUrl = resolveLoaderScriptUrl(
+      "saasco-support-loader.js",
+      chat.scriptUrl
+    );
+    if (!scriptUrl) {
+      this.logger.warn(
+        "Support is enabled but the loader URL could not be resolved. Pass `support.scriptUrl` pointing at your hosted saasco-support-loader.js (or load the analytics SDK from the CDN)."
+      );
+      return;
+    }
+    window.__saascoSupportInjected = true;
+    const script = document.createElement("script");
+    script.async = true;
+    script.src = normalizeSaascoUrl(scriptUrl);
+    script.setAttribute("data-projectId", this.config.projectId);
+    for (const [key, attr] of Object.entries(SUPPORT_ATTR_MAP)) {
+      const value = chat[key];
+      if (value !== void 0) {
+        script.setAttribute(
+          attr,
+          attr === "data-base-url" ? normalizeSaascoBaseUrl(value) : value
+        );
+      }
+    }
+    script.addEventListener("load", () => {
+      this.pushSupportIdentity();
+    });
+    (document.body ?? document.head ?? document.documentElement).append(script);
+  }
+  /**
+   * Lazily injects the social-proof loader (server-gated). See
+   * {@link injectSocialProofLoader}.
+   */
+  async injectSocialProof() {
+    if (!isBrowser5) {
+      return;
+    }
+    const { socialProof } = this.config;
+    const scriptUrl = resolveLoaderScriptUrl(
+      "saasco-social-proof-loader.js",
+      socialProof?.scriptUrl
+    ) ?? `${SAASCO_ORIGIN}/sdk/saasco-social-proof-loader.js`;
+    await injectSocialProofLoader({
+      baseUrl: socialProof?.baseUrl,
+      projectId: this.config.projectId,
+      scriptUrl
+    });
+  }
+  /**
+   * Records the latest CRM identity and forwards it to the support widget.
+   * No-op when support isn't enabled.
+   */
+  updateSupportIdentity(identity) {
+    if (!isBrowser5 || !this.config.support) {
+      return;
+    }
+    const hasTraits = identity.traits && Object.keys(identity.traits).length > 0;
+    this.lastSupportIdentity = identity.distinctId || identity.email || hasTraits ? identity : null;
+    if (this.config.support.enabled === false) {
+      return;
+    }
+    this.pushSupportIdentity();
+  }
+  /**
+   * Pushes the current identity onto `window.SaascoSupport.identify`. The
+   * widget bundle publishes that global asynchronously, so this short-polls for
+   * it (same approach as tool registration); the load handler also calls this,
+   * so a fresh page load with a stored distinctId still identifies the chat.
+   */
+  pushSupportIdentity() {
+    if (!isBrowser5 || !this.config.support || this.config.support.enabled === false) {
+      return;
+    }
+    const identity = this.lastSupportIdentity ?? {
+      distinctId: getUserId() ?? void 0,
+      // Anonymous (pre-identify) page load: still forward browser/track context
+      // and the session envelope so live context has them from the first turn.
+      traits: buildSupportTraits(void 0, {
+        anonymousId: getAnonymousId() ?? void 0,
+        sessionId: getSessionId() ?? void 0
+      })
+    };
+    let attempts = 0;
+    const tryPush = () => {
+      const api = getSupportGlobal();
+      if (!api) {
+        attempts += 1;
+        if (attempts > 40) {
+          return;
+        }
+        setTimeout(tryPush, 25);
+        return;
+      }
+      try {
+        api.identify(identity);
+      } catch (error) {
+        this.logger.warn(
+          "Failed to forward identity to the support widget:",
+          error
+        );
+      }
+    };
+    tryPush();
+  }
+};
+function resolveLoaderScriptUrl(loaderFile, override) {
+  if (override) {
+    return override.includes("saasco-sdk.js") ? override.replace("saasco-sdk.js", loaderFile) : override;
+  }
+  if (typeof document === "undefined") {
+    return;
+  }
+  const scriptTags = document.querySelectorAll("script");
+  for (const script of scriptTags) {
+    const src = script.getAttribute("src");
+    if (src?.includes("saasco-sdk.js")) {
+      return src.replace("saasco-sdk.js", loaderFile);
+    }
+  }
+}
+function validateTrackCall(actionOrPayload, logger) {
+  const hasAction = typeof actionOrPayload === "string";
+  const hasPayload = typeof actionOrPayload === "object";
+  if (isServer5 && hasAction) {
+    return logger.error(
+      'When calling track from the server you must pass a payload object with a userId in order to track events. For example: track({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } })'
+    );
+  }
+  if (isServer5 && hasPayload && !actionOrPayload.userId && !actionOrPayload.anonymousId) {
+    return logger.error(
+      'When calling track from the server you must pass a payload object with either a userId or an anonymousId in order to track events. For example:\n\ntrack({ event: "Song Played", userId: "user_123", properties: { song: "Song Name" } }). \n\nIf providing an anonymousId this must be provided from the client side otherwise we will not have a user to connect the event to.'
+    );
+  }
+  return null;
+}
+function resolveTrackIdentity(actionOrPayload) {
+  if (isServer5 && typeof actionOrPayload === "object") {
+    const distinctId = actionOrPayload.userId?.toString();
+    return {
+      anonymousId: actionOrPayload.anonymousId?.toString() ?? (distinctId ? getServerSideAnonymousId(distinctId) : uuid()),
+      distinctId,
+      sessionId: actionOrPayload.sessionId ?? uuid()
+    };
+  }
+  setSessionId();
+  setAnonymousId();
+  const payload = typeof actionOrPayload === "object" ? actionOrPayload : void 0;
+  return {
+    anonymousId: payload?.anonymousId?.toString() ?? getAnonymousId() ?? uuid(),
+    distinctId: payload?.userId?.toString() ?? getUserId() ?? void 0,
+    sessionId: payload?.sessionId ?? getSessionId() ?? uuid()
+  };
+}
+function resolveIdentifyArgs(distinctIdOrProperties, propertiesOrContext, contextOrNothing) {
+  const hasId = typeof distinctIdOrProperties === "string" || typeof distinctIdOrProperties === "number" || distinctIdOrProperties === null;
+  return {
+    context: hasId ? contextOrNothing : propertiesOrContext,
+    // `null` is the logout signal callers depend on, so it has to survive the
+    // conversion — optional chaining alone would hand back `undefined` and no
+    // downstream `=== null` check would ever match.
+    distinctId: hasId ? distinctIdOrProperties?.toString() ?? null : `soft_${uuid()}`,
+    hasId,
+    properties: hasId ? propertiesOrContext : distinctIdOrProperties
+  };
+}
+function resolveIdentifySessionIds({
+  distinctId,
+  reset
+}) {
+  if (isServer5 && distinctId !== null) {
+    return {
+      anonymousId: getServerSideAnonymousId(distinctId),
+      sessionId: uuid()
+    };
+  }
+  return {
+    anonymousId: setAnonymousId({ reset }),
+    sessionId: setSessionId({ reset })
+  };
+}
+function getLoggerLevel(config) {
+  let urlDebug = false;
+  let urlDebugVerbose = false;
+  if (!isServer5) {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      urlDebug = urlParams.get("saasco-debug") === "true";
+      urlDebugVerbose = urlParams.get("saasco-debug-verbose") === "true";
+    } catch {
+    }
+  }
+  const effectiveDebug = urlDebug || config.debug;
+  const effectiveDebugVerbose = urlDebugVerbose || config.debugVerbose;
+  return effectiveDebugVerbose ? 3 /* DEBUG */ : effectiveDebug ? 2 /* INFO */ : 0 /* ERROR */;
+}
+
+// ../shared/src/lib/types/browserContext.ts
+import { z } from "zod";
+var BrowserContextSchema = z.object({
+  $href: z.string(),
+  $locale: z.string(),
+  $location: z.string(),
+  $pathname: z.string(),
+  $referrer: z.string(),
+  $referringDomain: z.string(),
+  $screenDPI: z.number(),
+  $screenHeight: z.number(),
+  $screenWidth: z.number(),
+  $title: z.string(),
+  $userAgent: z.string(),
+  $utmAdId: z.string().nullable(),
+  $utmAdSource: z.string().nullable(),
+  $utmCampaign: z.string().nullable(),
+  $utmCampaignId: z.string().nullable(),
+  $utmContent: z.string().nullable(),
+  $utmCreativeFormat: z.string().nullable(),
+  $utmId: z.string().nullable(),
+  $utmMarketingTactic: z.string().nullable(),
+  $utmMedium: z.string().nullable(),
+  $utmSource: z.string().nullable(),
+  $utmSourcePlatform: z.string().nullable(),
+  $utmTerm: z.string().nullable()
+});
+export {
+  BrowserContextSchema,
+  IntegrationManager,
+  Saasco,
+  createFacebookPixelIntegration,
+  createPinterestTagIntegration,
+  createTikTokPixelIntegration,
+  getBrowserContext,
+  standardFacebookEvents,
+  standardPinterestEvents,
+  standardTikTokEvents,
+  timezones
+};