@treasuredata/web-sdk 1.0.0

package/dist/td-sdk.js

@@ -0,0 +1,3176 @@
+var Treasure = function() {
+  "use strict";
+  function createSDK(config) {
+    if (!config || typeof config.writeKey !== "string" || !config.writeKey) {
+      throw new Error("TreasureSDK: writeKey is required");
+    }
+    if (!config.database) {
+      throw new Error("TreasureSDK: database is required");
+    }
+    const logger = {
+      debug: (...args) => {
+        if (config.development) console.debug("[TreasureSDK]", ...args);
+      },
+      warn: (...args) => console.warn("[TreasureSDK]", ...args),
+      error: (...args) => console.error("[TreasureSDK]", ...args)
+    };
+    const core = {
+      config: { ...config },
+      log: logger
+    };
+    const sdk = {
+      ...core,
+      use(plugin) {
+        core.log.debug(`Loading plugin: ${plugin.name}`);
+        const methods = plugin.setup(core, sdk);
+        for (const key of Object.keys(methods)) {
+          if (key in sdk) {
+            throw new Error(
+              `TreasureSDK: plugin "${plugin.name}" conflicts on "${key}"`
+            );
+          }
+        }
+        Object.assign(sdk, methods);
+        return sdk;
+      },
+      getWriteKey() {
+        return core.config.writeKey;
+      },
+      setWriteKey(writeKey) {
+        if (!writeKey || typeof writeKey !== "string") {
+          throw new Error("TreasureSDK: writeKey must be a non-empty string");
+        }
+        core.config.writeKey = writeKey;
+      }
+    };
+    return sdk;
+  }
+  function isObject$1(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function isString(value) {
+    return typeof value === "string";
+  }
+  function isArray(value) {
+    return Array.isArray(value);
+  }
+  function isEmpty(value) {
+    if (value == null) return true;
+    if (isArray(value) || isString(value)) return value.length === 0;
+    if (isObject$1(value)) return Object.keys(value).length === 0;
+    return false;
+  }
+  function assign(target, ...sources) {
+    return Object.assign(target, ...sources);
+  }
+  function omit(obj, ...keysToOmit) {
+    const result = { ...obj };
+    keysToOmit.forEach((key) => delete result[key]);
+    return result;
+  }
+  function disposable(action) {
+    let disposed = false;
+    return function dispose() {
+      if (!disposed) {
+        disposed = true;
+        action();
+      }
+    };
+  }
+  function invariant$1(condition, text) {
+    if (!condition) {
+      throw new Error(text);
+    }
+  }
+  function isLocalStorageAccessible() {
+    const test = "__td__";
+    try {
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const adlHeaders = {
+    "Content-Type": "application/vnd.treasuredata.v1+json",
+    Accept: "application/vnd.treasuredata.v1+json"
+  };
+  const globalIdAdlHeaders = {
+    "Content-Type": "application/vnd.treasuredata.v1.js+json",
+    Accept: "application/vnd.treasuredata.v1.js+json"
+  };
+  const CONFIG = {
+    VERSION: "1.0.0",
+    HOST: "us01.records.in.treasuredata.com",
+    DATABASE: "",
+    PATHNAME: "/"
+  };
+  function encode(val) {
+    try {
+      return encodeURIComponent(val);
+    } catch (e) {
+      console.error("error encode %o", e);
+      return null;
+    }
+  }
+  function decode(val) {
+    try {
+      return decodeURIComponent(val);
+    } catch (err) {
+      console.error("error decode %o", err);
+      return null;
+    }
+  }
+  function handleSkey(sKey) {
+    const encoded = encode(sKey);
+    return encoded ? encoded.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&") : "";
+  }
+  const cookie = {
+    getItem(sKey) {
+      if (!sKey) {
+        return null;
+      }
+      const regex = new RegExp(
+        "(?:(?:^|.*;)\\s*" + handleSkey(sKey) + "\\s*\\=\\s*([^;]*).*$)|^.*$"
+      );
+      const match = document.cookie.replace(regex, "$1");
+      return decode(match) || null;
+    },
+    setItem(sKey, sValue, vEnd, sPath, sDomain, bSecure, sameSite) {
+      if (!sKey || /^(?:expires|max\-age|path|domain|secure)$/i.test(sKey)) {
+        return false;
+      }
+      let sExpires = "";
+      if (vEnd) {
+        if (typeof vEnd === "number") {
+          if (vEnd === Infinity) {
+            sExpires = "; expires=Fri, 31 Dec 9999 23:59:59 GMT";
+          } else {
+            sExpires = "; max-age=" + vEnd;
+          }
+        } else if (typeof vEnd === "string") {
+          sExpires = "; expires=" + vEnd;
+        } else if (vEnd instanceof Date) {
+          sExpires = "; expires=" + vEnd.toUTCString();
+        }
+      }
+      let secureAndSameSite = "";
+      if (sameSite && sameSite.toUpperCase() === "NONE") {
+        secureAndSameSite = "; Secure; SameSite=" + sameSite;
+      } else {
+        if (bSecure) {
+          secureAndSameSite += "; Secure";
+        }
+        if (sameSite) {
+          secureAndSameSite += "; SameSite=" + sameSite;
+        }
+      }
+      const encodedKey = encode(sKey);
+      const encodedValue = encode(sValue);
+      if (!encodedKey || !encodedValue) {
+        return false;
+      }
+      document.cookie = [
+        encodedKey,
+        "=",
+        encodedValue,
+        sExpires,
+        sDomain ? "; domain=" + sDomain : "",
+        sPath ? "; path=" + sPath : "",
+        secureAndSameSite
+      ].join("");
+      return true;
+    },
+    removeItem(sKey, sPath, sDomain) {
+      if (!this.hasItem(sKey)) {
+        return false;
+      }
+      const encodedKey = encode(sKey);
+      if (!encodedKey) {
+        return false;
+      }
+      document.cookie = [
+        encodedKey,
+        "=; expires=Thu, 01 Jan 1970 00:00:00 GMT",
+        sDomain ? "; domain=" + sDomain : "",
+        sPath ? "; path=" + sPath : ""
+      ].join("");
+      return true;
+    },
+    hasItem(sKey) {
+      if (!sKey) {
+        return false;
+      }
+      const encodedKey = encode(sKey);
+      if (!encodedKey) {
+        return false;
+      }
+      return new RegExp(
+        "(?:^|;\\s*)" + encodedKey.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&") + "\\s*\\="
+      ).test(document.cookie);
+    },
+    keys() {
+      const aKeys = document.cookie.replace(/((?:^|\s*;)[^=]+)(?=;|$)|^\s*|\s*(?:=[^;]*)?(?:\1|$)/g, "").split(/\s*(?:=[^;]*)?;\s*/);
+      return aKeys.map((key) => decode(key)).filter((key) => key !== null);
+    }
+  };
+  function validateOptions(options) {
+    invariant$1(
+      isObject$1(options),
+      "Check out our JavaScript SDK Usage Guide: https://github.com/treasure-data/td-js-sdk#api"
+    );
+    invariant$1(isString(options.writeKey), "Must provide a writeKey");
+    invariant$1(isString(options.database), "Must provide a database");
+    invariant$1(
+      options.database && /^[a-z0-9_]{3,255}$/.test(options.database),
+      "Database must be between 3 and 255 characters and must consist only of lower case letters, numbers, and _"
+    );
+  }
+  function defaultSSCCookieDomain() {
+    if (typeof document === "undefined") {
+      return "localhost";
+    }
+    const domainChunks = document.location.hostname.split(".");
+    for (let i = domainChunks.length - 2; i >= 1; i--) {
+      const domain = domainChunks.slice(i).join(".");
+      const name = "_td_domain_" + domain;
+      cookie.setItem(name, domain, 3600, "/", domain);
+      if (cookie.getItem(name) === domain) {
+        return domain;
+      }
+    }
+    return document.location.hostname;
+  }
+  const DEFAULT_CONFIG = {
+    database: CONFIG.DATABASE,
+    development: false,
+    globalIdCookie: "_td_global",
+    host: CONFIG.HOST,
+    logging: true,
+    pathname: CONFIG.PATHNAME,
+    requestType: "fetch",
+    jsonpTimeout: 1e4,
+    startInSignedMode: false,
+    useServerSideCookie: false,
+    sscDomain: defaultSSCCookieDomain,
+    sscServer: function(cookieDomain) {
+      return ["ssc", cookieDomain].join(".");
+    },
+    storeConsentByLocalStorage: false
+  };
+  function configure(options) {
+    const client = assign(
+      {},
+      {
+        globals: {}
+      },
+      DEFAULT_CONFIG,
+      options,
+      {
+        requestType: "fetch"
+      }
+    );
+    validateOptions(client);
+    if (!client.endpoint) {
+      client.endpoint = "https://" + client.host + client.pathname;
+    }
+    if (!client.storage) {
+      client.storage = {
+        name: "_td",
+        domain: typeof window !== "undefined" && typeof document !== "undefined" ? document.location.hostname : "localhost",
+        expires: 63072e3,
+        // 2 years in seconds
+        path: "/"
+      };
+    }
+    return client;
+  }
+  function findDomains(domain) {
+    const domainChunks = domain.split(".");
+    const domains = [];
+    for (let i = domainChunks.length - 1; i >= 0; i--) {
+      domains.push(domainChunks.slice(i).join("."));
+    }
+    return domains;
+  }
+  function setCookie(storage, name, value) {
+    const clone = { ...storage };
+    const is = {
+      ip: storage.domain.match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/),
+      local: storage.domain === "localhost",
+      custom: storage.customDomain
+    };
+    const expires = /* @__PURE__ */ new Date();
+    expires.setSeconds(expires.getSeconds() + clone.expires);
+    if (is.local) {
+      if (!value) {
+        cookie.removeItem(name, clone.path, clone.domain);
+      } else {
+        cookie.setItem(name, value, expires, clone.path);
+      }
+    } else if (is.ip || is.custom) {
+      if (!value) {
+        cookie.removeItem(name, clone.path, clone.domain);
+      } else {
+        cookie.setItem(
+          name,
+          value,
+          expires,
+          clone.path,
+          clone.domain,
+          true,
+          "None"
+        );
+      }
+    } else {
+      const domains = findDomains(storage.domain);
+      const ll = domains.length;
+      let i = 0;
+      if (!value) {
+        for (; i < ll; i++) {
+          cookie.removeItem(name, storage.path, domains[i]);
+        }
+      } else {
+        if (cookie.getItem(name) === value) return;
+        for (; i < ll; i++) {
+          clone.domain = domains[i];
+          cookie.setItem(
+            name,
+            value,
+            expires,
+            clone.path,
+            clone.domain,
+            true,
+            "None"
+          );
+          if (cookie.getItem(name) === value) {
+            storage.domain = clone.domain;
+            break;
+          }
+        }
+      }
+    }
+  }
+  function generateUUID$1() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      const bytes = new Uint8Array(16);
+      crypto.getRandomValues(bytes);
+      bytes[6] = bytes[6] & 15 | 64;
+      bytes[8] = bytes[8] & 63 | 128;
+      const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    throw new Error(
+      "Secure random number generation is not available in this environment"
+    );
+  }
+  const FETCH_CREDENTIALS = {
+    "same-origin": "same-origin",
+    include: "include",
+    omit: "omit"
+  };
+  function toJSON(text) {
+    let result;
+    try {
+      result = JSON.parse(text);
+    } catch {
+      result = {};
+    }
+    return result;
+  }
+  function getCredentials(options = {}) {
+    return FETCH_CREDENTIALS[options.credentials || "include"] || "include";
+  }
+  function post(url, body, options = {}) {
+    const headers = options.headers || {};
+    const credentials = getCredentials(options);
+    const fetchOptions = {
+      method: "POST",
+      headers,
+      keepalive: true,
+      body: JSON.stringify(body)
+    };
+    {
+      fetchOptions.credentials = credentials;
+    }
+    if (options.signal) {
+      fetchOptions.signal = options.signal;
+    }
+    return fetch(url, fetchOptions).then(function(response) {
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.text();
+    }).then(function(text) {
+      return toJSON(text);
+    });
+  }
+  function get(url, options = {}) {
+    const headers = options.headers || {};
+    const credentials = getCredentials(options);
+    const fetchOptions = {
+      method: "GET",
+      headers
+    };
+    {
+      fetchOptions.credentials = credentials;
+    }
+    if (options.signal) {
+      fetchOptions.signal = options.signal;
+    }
+    return fetch(url, fetchOptions).then(function(response) {
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.text();
+    }).then(function(text) {
+      return toJSON(text);
+    });
+  }
+  function withTimeout(promiseFactory, milliseconds, timeoutMessage) {
+    const controller = new AbortController();
+    let timeoutId;
+    const timeoutPromise2 = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        controller.abort();
+        reject(new Error(timeoutMessage || "Operation Timeout"));
+      }, milliseconds);
+    });
+    const promise = promiseFactory(controller.signal).finally(() => {
+      clearTimeout(timeoutId);
+    });
+    return Promise.race([promise, timeoutPromise2]).catch((error) => {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(timeoutMessage || "Operation Timeout");
+      }
+      throw error;
+    });
+  }
+  function postWithTimeout(url, body, milliseconds, options = {}) {
+    return withTimeout(
+      (signal) => post(url, body, { ...options, signal }),
+      milliseconds,
+      "Request Timeout"
+    );
+  }
+  function getWithTimeout(url, milliseconds, options = {}) {
+    return withTimeout(
+      (signal) => get(url, { ...options, signal }),
+      milliseconds,
+      "Request Timeout"
+    );
+  }
+  function timeoutPromise(promiseFactory, milliseconds, timeoutMessage) {
+    return withTimeout((_signal) => promiseFactory(), milliseconds, timeoutMessage);
+  }
+  const api = {
+    post,
+    get,
+    postWithTimeout,
+    getWithTimeout,
+    withTimeout,
+    timeoutPromise
+  };
+  const SERVER_COOKIE_NAME = "_td_ssc_id";
+  const COOKIE_NAME = SERVER_COOKIE_NAME;
+  function serverCookie() {
+    return {
+      name: "serverCookie",
+      setup(core, sdk) {
+        const config = core.config;
+        let serverCookieDomain;
+        let serverCookieDomainHost;
+        const noop = () => {
+        };
+        function initializeServerCookieConfig() {
+          if (!serverCookieDomainHost) {
+            if (typeof config.sscDomain === "function") {
+              serverCookieDomain = config.sscDomain();
+            } else {
+              serverCookieDomain = config.sscDomain || (typeof window !== "undefined" ? window.location.hostname : "localhost");
+            }
+            if (typeof config.sscServer === "function") {
+              serverCookieDomainHost = config.sscServer(serverCookieDomain);
+            } else {
+              serverCookieDomainHost = config.sscServer || `ssc.${serverCookieDomain}`;
+            }
+          }
+        }
+        function fetchServerCookie(success, error, forceFetch = false) {
+          const successCallback = success || noop;
+          const errorCallback = error || noop;
+          if (typeof sdk.inSignedMode === "function" && !sdk.inSignedMode()) {
+            return errorCallback("not in signed in mode");
+          }
+          if (!config.useServerSideCookie) {
+            return errorCallback("server side cookie not enabled");
+          }
+          initializeServerCookieConfig();
+          if (!serverCookieDomain || !serverCookieDomainHost) {
+            return errorCallback(
+              "server cookie configuration not properly initialized"
+            );
+          }
+          const url = `https://${serverCookieDomainHost}/get_cookie_id?cookie_domain=${encodeURIComponent(serverCookieDomain)}&r=${Date.now()}`;
+          const cachedSSCId = cookie.getItem(COOKIE_NAME);
+          if (cachedSSCId && !forceFetch) {
+            setTimeout(() => {
+              successCallback(cachedSSCId);
+            }, 0);
+            return;
+          }
+          api.getWithTimeout(url, 1e4).then((response) => {
+            successCallback(response.td_ssc_id);
+          }).catch((err) => {
+            errorCallback(err);
+          });
+        }
+        return {
+          fetchServerCookie
+        };
+      }
+    };
+  }
+  const BLOCKEVENTSCOOKIE = "__td_blockEvents";
+  const SIGNEDMODECOOKIE = "__td_signed";
+  function configureStorage(storage) {
+    if (storage === "none") return null;
+    const s = typeof storage === "object" && storage !== null ? storage : {};
+    return {
+      name: s.name || "_td",
+      expires: s.expires ?? 63072e3,
+      domain: s.domain || document.location.hostname,
+      customDomain: !!s.domain,
+      path: s.path || "/"
+    };
+  }
+  function setStorageCookie(storage, name, value) {
+    try {
+      setCookie(storage, name, value || "");
+    } catch {
+    }
+  }
+  function session() {
+    return {
+      name: "session",
+      setup(core, sdk) {
+        const config = core.config;
+        const startInSignedMode = config.startInSignedMode ?? false;
+        const storeConsentByLocalStorage = config.storeConsentByLocalStorage ?? false;
+        const globals = {};
+        function set(table, property, value) {
+          let tableName;
+          let prop = property;
+          if (typeof table === "object" && table !== null) {
+            prop = table;
+            tableName = "$global";
+          } else {
+            tableName = table;
+          }
+          const bucket = globals[tableName] || {};
+          globals[tableName] = bucket;
+          if (typeof prop === "object" && prop !== null) {
+            Object.assign(bucket, prop);
+          } else if (typeof prop === "string" && value !== void 0) {
+            bucket[prop] = value;
+          }
+        }
+        function get2(table, key) {
+          const t = table || "$global";
+          globals[t] = globals[t] || {};
+          return key ? globals[t]?.[key] ?? null : globals[t];
+        }
+        const storage = configureStorage(config.storage);
+        let clientId;
+        if (config.clientId != null) {
+          clientId = typeof config.clientId === "number" ? config.clientId.toString() : config.clientId;
+        }
+        if (!clientId || typeof clientId !== "string") {
+          if (storage?.name && typeof document !== "undefined") {
+            clientId = cookie.getItem(storage.name) ?? void 0;
+          }
+          if (!clientId || clientId === "undefined") {
+            clientId = generateUUID$1();
+          }
+        }
+        let uuid = clientId.replace(/\0/g, "");
+        function getUUID() {
+          return uuid;
+        }
+        function persistUUID(storageOption, id) {
+          if (cookie.getItem(storageOption.name) === id) return;
+          try {
+            setCookie(storageOption, storageOption.name, id);
+          } catch {
+          }
+        }
+        function resetUUID(suggestedStorage, suggestedClientId) {
+          uuid = (suggestedClientId || generateUUID$1()).replace(/\0/g, "");
+          const storageToUse = suggestedStorage || config.storage;
+          if (storageToUse && typeof storageToUse === "object") {
+            const storageOption = configureStorage(storageToUse);
+            if (storageOption?.expires && inSignedMode()) {
+              persistUUID(storageOption, uuid);
+            }
+          }
+        }
+        if (storage?.expires && inSignedMode()) {
+          persistUUID(storage, uuid);
+        }
+        function inSignedMode() {
+          if (storeConsentByLocalStorage) {
+            if (!isLocalStorageAccessible()) return startInSignedMode;
+            const val2 = localStorage.getItem(SIGNEDMODECOOKIE);
+            return val2 !== "false" && (val2 === "true" || startInSignedMode);
+          }
+          if (typeof document === "undefined") return startInSignedMode;
+          const val = cookie.getItem(SIGNEDMODECOOKIE);
+          return val !== "false" && (val === "true" || startInSignedMode);
+        }
+        function setSignedMode() {
+          if (storeConsentByLocalStorage) {
+            if (isLocalStorageAccessible()) {
+              localStorage.setItem(SIGNEDMODECOOKIE, "true");
+            }
+          } else if (config.storage && typeof config.storage === "object") {
+            setStorageCookie(config.storage, SIGNEDMODECOOKIE, "true");
+          }
+          const currentUUID = getUUID();
+          resetUUID(config.storage, currentUUID);
+        }
+        function setAnonymousMode(keepIdentifier) {
+          if (storeConsentByLocalStorage) {
+            if (isLocalStorageAccessible()) {
+              localStorage.setItem(SIGNEDMODECOOKIE, "false");
+            }
+          } else if (config.storage && typeof config.storage === "object") {
+            setStorageCookie(config.storage, SIGNEDMODECOOKIE, "false");
+          }
+          if (!keepIdentifier) {
+            if (config.storage && typeof config.storage === "object") {
+              setStorageCookie(config.storage, config.storage.name);
+            }
+            removeCachedGlobalID();
+            sdk.removeServerCookie();
+          }
+        }
+        function areEventsBlocked() {
+          return cookie.getItem(BLOCKEVENTSCOOKIE) === "true";
+        }
+        function blockEvents() {
+          if (config.storage && typeof config.storage === "object") {
+            setStorageCookie(config.storage, BLOCKEVENTSCOOKIE, "true");
+          }
+        }
+        function unblockEvents() {
+          if (config.storage && typeof config.storage === "object") {
+            setStorageCookie(config.storage, BLOCKEVENTSCOOKIE, "false");
+          }
+        }
+        function removeCachedGlobalID() {
+          if (globals["$global"]) {
+            delete globals["$global"]["td_global_id"];
+          }
+          if (config.storage && typeof config.storage === "object") {
+            const globalIdCookie = config.globalIdCookie || "_td_global";
+            setStorageCookie(config.storage, globalIdCookie, "");
+          }
+          if (isLocalStorageAccessible()) {
+            const globalIdCookie = config.globalIdCookie || "_td_global";
+            try {
+              localStorage.removeItem(globalIdCookie);
+            } catch {
+            }
+          }
+        }
+        function removeServerCookie() {
+          if (config.storage && typeof config.storage === "object") {
+            setStorageCookie(config.storage, SERVER_COOKIE_NAME, "");
+            const otherCookieNames = ["__td_ssc", "_td_ssc"];
+            otherCookieNames.forEach((cookieName) => {
+              setStorageCookie(config.storage, cookieName, "");
+            });
+            if (config.useServerSideCookie && config.globalIdCookie) {
+              setStorageCookie(config.storage, config.globalIdCookie, "");
+            }
+          }
+          if (isLocalStorageAccessible()) {
+            [SERVER_COOKIE_NAME, "__td_ssc", "_td_ssc"].forEach((key) => {
+              try {
+                localStorage.removeItem(key);
+              } catch {
+              }
+            });
+          }
+        }
+        function isGlobalIdEnabled() {
+          return get2(void 0, "td_global_id") === "td_global_id";
+        }
+        return {
+          inSignedMode,
+          setSignedMode,
+          setAnonymousMode,
+          blockEvents,
+          unblockEvents,
+          areEventsBlocked,
+          getUUID,
+          resetUUID,
+          set,
+          get: get2,
+          removeCachedGlobalID,
+          removeServerCookie,
+          isGlobalIdEnabled
+        };
+      }
+    };
+  }
+  const DEFAULT_HOST = "us01.records.in.treasuredata.com";
+  const DEFAULT_PATHNAME = "/";
+  function validateRecord(table, record2) {
+    invariant$1(isString(table), "Must provide a table");
+    invariant$1(
+      /^[a-z0-9_]{3,255}$/.test(table),
+      "Table must be between 3 and 255 characters and must consist only of lower case letters, numbers, and _"
+    );
+    invariant$1(isObject$1(record2), "Must provide a record");
+  }
+  function record() {
+    return {
+      name: "record",
+      setup(core, sdk) {
+        const config = core.config;
+        const host = config.host || DEFAULT_HOST;
+        const pathname = config.pathname || DEFAULT_PATHNAME;
+        const endpoint = config.endpoint || `https://${host}${pathname}`;
+        let windowBeingUnloaded = false;
+        if (typeof window !== "undefined" && window.addEventListener) {
+          const handleUnload = () => {
+            windowBeingUnloaded = true;
+          };
+          window.addEventListener("beforeunload", handleUnload);
+          window.addEventListener("unload", handleUnload);
+          core._unloadHandlers = [
+            () => window.removeEventListener("beforeunload", handleUnload),
+            () => window.removeEventListener("unload", handleUnload)
+          ];
+        }
+        core._windowBeingUnloaded = () => windowBeingUnloaded;
+        function applyProperties(table, payload) {
+          return Object.assign(
+            {},
+            sdk.get("$global"),
+            sdk.get(table),
+            payload
+          );
+        }
+        const api2 = {
+          addRecord(table, record2, success, error, options) {
+            validateRecord(table, record2);
+            const propertiesRecord = applyProperties(table, record2);
+            const finalRecord = sdk.inSignedMode() ? propertiesRecord : omitKeys(propertiesRecord, [
+              "td_ip",
+              "td_client_id",
+              "td_global_id"
+            ]);
+            const request = {
+              apikey: config.writeKey,
+              record: finalRecord,
+              time: null,
+              url: `${endpoint}${options?.database ?? config.database}/${table}`
+            };
+            if (request.record.time != null) {
+              request.time = request.record.time;
+            }
+            if (config.development) {
+              core.log.debug("addRecord", request);
+              success?.({
+                success: true,
+                message: "Development mode - record not sent"
+              });
+            } else if (!sdk.areEventsBlocked()) {
+              submitRecord(
+                {
+                  ...request,
+                  inSignedMode: sdk.inSignedMode(),
+                  isGlobalIdEnabled: sdk.isGlobalIdEnabled(),
+                  windowBeingUnloaded: core._windowBeingUnloaded?.() ?? false,
+                  timeoutMs: config.jsonpTimeout ?? 6e4
+                },
+                success,
+                error
+              );
+            }
+          }
+        };
+        return api2;
+      }
+    };
+  }
+  function omitKeys(obj, keys) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      if (!keys.includes(key)) {
+        const value = obj[key];
+        if (value !== void 0) {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  async function submitRecord(request, success, error) {
+    const noop = () => {
+    };
+    const successCallback = success || noop;
+    const errorCallback = error || noop;
+    const params = ["modified=" + encodeURIComponent((/* @__PURE__ */ new Date()).getTime())];
+    if (request.time) {
+      params.push("time=" + encodeURIComponent(request.time));
+    }
+    const url = request.url + "?" + params.join("&");
+    const isClickedLink = request.record.tag === "a" && !!request.record.href;
+    const requestHeaders = {};
+    requestHeaders["Authorization"] = "TD1 " + request.apikey;
+    if (typeof navigator !== "undefined") {
+      requestHeaders["User-Agent"] = navigator.userAgent;
+    }
+    if (request.inSignedMode && request.isGlobalIdEnabled) {
+      Object.assign(requestHeaders, globalIdAdlHeaders);
+    } else {
+      Object.assign(requestHeaders, adlHeaders);
+    }
+    const payload = { events: [request.record] };
+    try {
+      if (typeof window !== "undefined" && (request.windowBeingUnloaded || isClickedLink)) {
+        const response = await api.postWithTimeout(
+          url,
+          payload,
+          request.timeoutMs,
+          { headers: requestHeaders, credentials: "include" }
+        );
+        successCallback(response);
+      } else {
+        const response = await api.post(url, payload, {
+          headers: requestHeaders,
+          credentials: "include"
+        });
+        successCallback(response);
+      }
+    } catch (err) {
+      const tdError = err instanceof Error ? { ...err, name: err.name, message: err.message } : new Error("Unknown error occurred");
+      errorCallback(tdError);
+    }
+  }
+  const POPUP_CONTAINER_ID = "td-engage-popup-container";
+  let inlineObserver = null;
+  let navigationCleanupInstalled = false;
+  let accumulatedInline = [];
+  function parseAppearance(raw) {
+    if (typeof raw === "object" && raw !== null) return raw;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  function parseMessages(tdApp) {
+    try {
+      const messagesRaw = tdApp["td_in_browser.messages"];
+      if (!messagesRaw) return [];
+      return JSON.parse(messagesRaw);
+    } catch {
+      return [];
+    }
+  }
+  function removeExistingPopup() {
+    document.getElementById(POPUP_CONTAINER_ID)?.remove();
+  }
+  function isPopupDisplayed() {
+    return document.getElementById(POPUP_CONTAINER_ID) !== null;
+  }
+  function resetForNavigation() {
+    removeExistingPopup();
+    if (inlineObserver) {
+      inlineObserver.disconnect();
+      inlineObserver = null;
+    }
+    accumulatedInline = [];
+  }
+  function ensureNavigationCleanup() {
+    if (navigationCleanupInstalled) return;
+    if (typeof window === "undefined" || !window.history) return;
+    window.addEventListener("popstate", resetForNavigation);
+    window.addEventListener("hashchange", resetForNavigation);
+    try {
+      const wrap2 = (method) => {
+        const original = window.history[method];
+        window.history[method] = function(...args) {
+          const result = original.apply(this, args);
+          resetForNavigation();
+          return result;
+        };
+      };
+      wrap2("pushState");
+      wrap2("replaceState");
+    } catch {
+    }
+    navigationCleanupInstalled = true;
+  }
+  function renderPopup(message) {
+    try {
+      const a = parseAppearance(message.appearance_setting);
+      const isDesktop = window.innerWidth > 620;
+      removeExistingPopup();
+      const placement = a.position?.placement ?? "center";
+      const isTop = placement.startsWith("top");
+      const isBottom = placement.startsWith("bottom");
+      const isLeft = placement.endsWith("left");
+      const isRight = placement.endsWith("right");
+      const inset = isDesktop ? a.inset?.desktop ?? 40 : a.inset?.mobile ?? 16;
+      const maxWidth = isDesktop ? a.width?.desktop_max_width ?? 600 : a.width?.mobile_max_width ?? 300;
+      const container = document.createElement("div");
+      container.id = POPUP_CONTAINER_ID;
+      const alignItems = isBottom ? "end" : isTop ? "start" : "center";
+      const justifyItems = isLeft ? "start" : isRight ? "end" : "center";
+      Object.assign(container.style, {
+        position: a.position?.fixed_on_scroll === false ? "absolute" : "fixed",
+        inset: "0",
+        display: "grid",
+        placeItems: `${alignItems} ${justifyItems}`,
+        padding: `${inset}px`,
+        pointerEvents: "none",
+        boxSizing: "border-box"
+      });
+      container.style.setProperty(
+        "z-index",
+        "var(--td-popup-z-index, 2147483647)"
+      );
+      const shadow = container.attachShadow({ mode: "open" });
+      const style = document.createElement("style");
+      style.textContent = `
+      :host { --td-popup-z-index: 2147483647; --td-popup-frame-z-index: 1; --td-close-btn-cursor: pointer; --td-close-btn-line-height: 1; }
+      .td-overlay { position: fixed; inset: 0; pointer-events: auto; }
+      .td-frame { position: relative; width: 100%; pointer-events: auto; box-sizing: border-box; z-index: var(--td-popup-frame-z-index); }
+      .td-close { position: absolute; background: transparent; border: none; cursor: var(--td-close-btn-cursor); line-height: var(--td-close-btn-line-height); padding: 0; display: flex; align-items: center; justify-content: center; z-index: 1; }
+    `;
+      shadow.appendChild(style);
+      if (a.overlay?.enabled) {
+        const overlayEl = document.createElement("div");
+        overlayEl.className = "td-overlay";
+        Object.assign(overlayEl.style, {
+          background: a.overlay.color ?? "#000000B3"
+        });
+        if (a.overlay.close_on_click_outside) {
+          overlayEl.setAttribute("data-engage-popup-close", "");
+        }
+        shadow.appendChild(overlayEl);
+      }
+      const frame = document.createElement("div");
+      frame.className = "td-frame";
+      const bgPadding = a.background?.padding ?? 0;
+      Object.assign(frame.style, {
+        maxWidth: `${maxWidth}px`,
+        background: a.background?.color ?? "#FFFFFF",
+        borderRadius: `${a.background?.border_radius ?? 8}px`,
+        padding: `${bgPadding}px`
+      });
+      if (a.close_button?.enabled !== false) {
+        const size = a.close_button?.size ?? 28;
+        const offsetTop = a.close_button?.offset_top ?? 2;
+        const offsetRight = a.close_button?.offset_right ?? 4;
+        const closeBtn = document.createElement("button");
+        closeBtn.type = "button";
+        closeBtn.className = "td-close";
+        closeBtn.setAttribute("aria-label", "Close");
+        closeBtn.setAttribute("data-engage-popup-close", "");
+        Object.assign(closeBtn.style, {
+          top: `${offsetTop}px`,
+          right: `${offsetRight}px`,
+          width: `${size}px`,
+          height: `${size}px`,
+          fontSize: `${size * 0.7}px`,
+          color: a.close_button?.color ?? "#FFFFFF"
+        });
+        closeBtn.textContent = "×";
+        frame.appendChild(closeBtn);
+      }
+      const content = document.createElement("div");
+      content.innerHTML = message.content_html;
+      frame.appendChild(content);
+      shadow.appendChild(frame);
+      shadow.addEventListener("click", (e) => {
+        const target = e.target;
+        if (target.hasAttribute("data-engage-popup-close")) {
+          container.remove();
+        }
+      });
+      document.body.appendChild(container);
+    } catch {
+    }
+  }
+  function renderInline(message) {
+    if (!message.css_selector) return;
+    try {
+      const els = document.querySelectorAll(message.css_selector);
+      for (const el of els) {
+        el.innerHTML = message.content_html;
+      }
+    } catch {
+    }
+  }
+  function compareMessages(a, b) {
+    const tsDiff = Number(b.created_at_millisecond ?? 0) - Number(a.created_at_millisecond ?? 0);
+    if (tsDiff !== 0) return tsDiff;
+    const sectionDiff = b._sectionName.localeCompare(a._sectionName);
+    if (sectionDiff !== 0) return sectionDiff;
+    return b._arrayIndex - a._arrayIndex;
+  }
+  function sortedInlineMessages(messages) {
+    return messages.filter((m) => m.type === "inline" && m.css_selector).sort((a, b) => -compareMessages(a, b));
+  }
+  function pickPopup(messages) {
+    const popups = messages.filter((m) => m.type === "popup").sort(compareMessages);
+    return popups[0];
+  }
+  function applyAccumulatedInline() {
+    for (const msg of accumulatedInline) {
+      renderInline(msg);
+    }
+  }
+  function setupInlineObserver() {
+    if (inlineObserver) {
+      inlineObserver.disconnect();
+      inlineObserver = null;
+    }
+    if (accumulatedInline.length === 0) return;
+    inlineObserver = new MutationObserver(() => {
+      inlineObserver.disconnect();
+      applyAccumulatedInline();
+      inlineObserver.observe(document.body, { childList: true, subtree: true });
+    });
+    inlineObserver.observe(document.body, { childList: true, subtree: true });
+  }
+  function extractMessages(response) {
+    const offers = response.offers;
+    if (!offers) return [];
+    const allMessages = [];
+    for (const [sectionName, section] of Object.entries(offers)) {
+      const tdApp = section?.td_app;
+      if (!tdApp) continue;
+      const messages = parseMessages(tdApp);
+      messages.forEach((m, i) => {
+        allMessages.push({ ...m, _sectionName: sectionName, _arrayIndex: i });
+      });
+    }
+    return allMessages;
+  }
+  function handlePersonalizationResponse(response) {
+    try {
+      const messages = extractMessages(response);
+      if (messages.length === 0) return;
+      ensureNavigationCleanup();
+      if (!isPopupDisplayed()) {
+        const popup = pickPopup(messages);
+        if (popup) {
+          renderPopup(popup);
+        }
+      }
+      const inline = sortedInlineMessages(messages);
+      if (inline.length > 0) {
+        accumulatedInline.push(...inline);
+        applyAccumulatedInline();
+        setupInlineObserver();
+      }
+    } catch {
+    }
+  }
+  function configureValues(getUUID, version) {
+    return {
+      td_version: () => version,
+      td_client_id: getUUID,
+      td_charset: () => (document.characterSet || document.charset || "-").toLowerCase(),
+      td_language: () => {
+        const nav = navigator;
+        return (nav && (nav.language || nav.browserLanguage) || "-").toLowerCase();
+      },
+      td_color: () => screen ? screen.colorDepth + "-bit" : "-",
+      td_screen: () => screen ? `${screen.width}x${screen.height}` : "-",
+      td_viewport: () => {
+        const clientHeight = document.documentElement && document.documentElement.clientHeight;
+        const clientWidth = document.documentElement && document.documentElement.clientWidth;
+        const innerHeight = window.innerHeight;
+        const innerWidth = window.innerWidth;
+        const height = (clientHeight || 0) < innerHeight ? innerHeight : clientHeight || 0;
+        const width = (clientWidth || 0) < innerWidth ? innerWidth : clientWidth || 0;
+        return `${width}x${height}`;
+      },
+      td_title: () => document.title,
+      td_description: () => getMetaContent("description"),
+      td_url: () => {
+        return !document.location || !document.location.href ? "" : document.location.href.split("#")[0] || "";
+      },
+      td_user_agent: () => {
+        const userAgent = navigator.userAgent;
+        const sdkUserAgent = `WEBSDK/${version}`;
+        return [userAgent, sdkUserAgent].join(";");
+      },
+      td_platform: () => {
+        return navigator.platform || navigator.userAgentData?.platform || "-";
+      },
+      td_host: () => document.location.host,
+      td_path: () => document.location.pathname,
+      td_referrer: () => document.referrer
+    };
+  }
+  function getMetaContent(metaName) {
+    const head = document.head || document.getElementsByTagName("head")[0];
+    const metas = head.getElementsByTagName("meta");
+    const metaLength = metas.length;
+    for (let i = 0; i < metaLength; i++) {
+      const meta = metas[i];
+      if (meta && meta.getAttribute("name") === metaName) {
+        return (meta.getAttribute("content") || "").substr(0, 8192);
+      }
+    }
+    return "";
+  }
+  function track() {
+    return {
+      name: "track",
+      setup(core, sdk) {
+        const trackValues = configureValues(() => sdk.getUUID(), CONFIG.VERSION);
+        function getTrackValues() {
+          const result = {};
+          for (const [key, value] of Object.entries(trackValues)) {
+            if (value) {
+              result[key] = typeof value === "function" ? value() : value;
+            }
+          }
+          return result;
+        }
+        function trackEvent(table, record2, success, failure) {
+          const tableName = table || "events";
+          const values = getTrackValues();
+          const merged = Object.assign(values, record2);
+          const personalization2 = core.config.personalization;
+          if (personalization2) {
+            const personalizationConfig = {
+              endpoint: personalization2.endpoint,
+              database: personalization2.database || core.config.database,
+              table: tableName,
+              token: personalization2.token
+            };
+            const payload = {
+              ...sdk.get("$global"),
+              ...sdk.get(tableName),
+              ...getTrackValues(),
+              ...record2
+            };
+            sdk.fetchPersonalization(
+              personalizationConfig,
+              payload,
+              (response) => {
+                handlePersonalizationResponse(response);
+                if (typeof sdk.applyPersonalization === "function") {
+                  sdk.applyPersonalization(
+                    response
+                  );
+                }
+              },
+              (error) => {
+                core.log.error("Personalization failed:", error);
+              }
+            );
+            return;
+          }
+          sdk.addRecord(tableName, merged, success, failure);
+        }
+        function trackPageview(table, success, failure, options) {
+          const tableName = table || "pageviews";
+          const eventRecord = options?.payload ?? {};
+          trackEvent(tableName, eventRecord, success, failure);
+        }
+        function getPersonalizationConfig() {
+          return core.config.personalization;
+        }
+        function setPersonalizationConfig(options) {
+          core.config.personalization = options;
+        }
+        return {
+          trackEvent,
+          trackPageview,
+          getTrackValues,
+          getPersonalizationConfig,
+          setPersonalizationConfig
+        };
+      }
+    };
+  }
+  function getEventTarget(event) {
+    const target = event.target || event.srcElement || document;
+    return target.nodeType === 3 ? target.parentNode : target;
+  }
+  function addEventListener(el, type, fn) {
+    if ("addEventListener" in el) {
+      el.addEventListener(type, handler, false);
+      return disposable(() => {
+        el.removeEventListener(type, handler, false);
+      });
+    } else if ("attachEvent" in el) {
+      el.attachEvent("on" + type, handler);
+      return disposable(() => {
+        el.detachEvent("on" + type, handler);
+      });
+    } else {
+      throw new Error("addEventListener not supported");
+    }
+    function handler(event) {
+      fn.call(el, event || window.event);
+    }
+  }
+  function htmlTreeAsString(elem) {
+    const MAX_TRAVERSE_HEIGHT = 5;
+    const MAX_OUTPUT_LEN = 80;
+    const out = [];
+    let height = 0;
+    let len = 0;
+    const separator = " > ";
+    const sepLength = separator.length;
+    let nextStr;
+    let currentElem = elem;
+    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+      nextStr = htmlElementAsString(currentElem);
+      if (nextStr === "html" || height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN) {
+        break;
+      }
+      out.push(nextStr);
+      len += nextStr.length;
+      currentElem = currentElem.parentNode;
+    }
+    const result = out.reverse().join(separator);
+    if (result.length > MAX_OUTPUT_LEN) {
+      return result.substring(0, MAX_OUTPUT_LEN - 3) + "...";
+    }
+    return result;
+  }
+  function htmlElementAsString(elem) {
+    const out = [];
+    let classes;
+    let key;
+    let attr;
+    let i;
+    if (!elem || !elem.tagName) {
+      return "";
+    }
+    out.push(elem.tagName.toLowerCase());
+    if (elem.id) {
+      out.push("#" + elem.id);
+    }
+    const className = elem.className;
+    if (className && isString(className)) {
+      classes = className.split(" ");
+      for (i = 0; i < classes.length; i++) {
+        const cls = classes[i];
+        if (cls && cls.trim()) {
+          out.push("." + cls.trim());
+        }
+      }
+    }
+    const attrWhitelist = ["type", "name", "title", "alt"];
+    for (i = 0; i < attrWhitelist.length; i++) {
+      key = attrWhitelist[i];
+      attr = elem.getAttribute(key);
+      if (attr) {
+        out.push("[" + key + '="' + attr + '"]');
+      }
+    }
+    return out.join("");
+  }
+  function hasAttribute(element, attrName) {
+    if (typeof element.hasAttribute === "function") {
+      return element.hasAttribute(attrName);
+    }
+    return element.getAttribute(attrName) !== null;
+  }
+  function findElement(el) {
+    if (!el || !el.tagName) return null;
+    let currentEl = el;
+    let tag = currentEl.tagName.toLowerCase();
+    while (tag && tag !== "body" && currentEl) {
+      const type = currentEl.getAttribute("type");
+      if (tag === "input" && type === "password") return null;
+      const role = currentEl.getAttribute("role");
+      if (role === "button" || role === "link" || tag === "a" || tag === "button" || tag === "input") {
+        return currentEl;
+      }
+      currentEl = currentEl.parentNode;
+      tag = currentEl && currentEl.tagName ? currentEl.tagName.toLowerCase() : "";
+    }
+    return null;
+  }
+  function createTreeHasIgnoreAttribute(ignoreAttribute) {
+    const dataIgnoreAttribute = "data-" + ignoreAttribute;
+    return function treeHasIgnoreAttribute(el) {
+      if (!el || !el.tagName || el.tagName.toLowerCase() === "html") return false;
+      if (hasAttribute(el, ignoreAttribute) || hasAttribute(el, dataIgnoreAttribute))
+        return true;
+      return treeHasIgnoreAttribute(el.parentNode);
+    };
+  }
+  function getElementData(el) {
+    const data = {
+      tag: el.tagName.toLowerCase(),
+      tree: htmlTreeAsString(el)
+    };
+    const attributesToCapture = [
+      "alt",
+      "class",
+      "href",
+      "id",
+      "name",
+      "role",
+      "title",
+      "type"
+    ];
+    attributesToCapture.forEach((attrName) => {
+      if (hasAttribute(el, attrName)) {
+        const value = el.getAttribute(attrName);
+        if (value) data[attrName] = value;
+      }
+    });
+    return data;
+  }
+  function clicks() {
+    return {
+      name: "clicks",
+      setup(_core, sdk) {
+        let clickTrackingInstalled = false;
+        return {
+          trackClicks(options) {
+            if (clickTrackingInstalled) return void 0;
+            const opts = {
+              element: options?.element ?? window.document,
+              extendClickData: options?.extendClickData ?? ((_e, data) => data),
+              ignoreAttribute: options?.ignoreAttribute ?? "td-ignore",
+              tableName: options?.tableName ?? "clicks"
+            };
+            const treeHasIgnoreAttribute = createTreeHasIgnoreAttribute(
+              opts.ignoreAttribute
+            );
+            const removeClickTracker = addEventListener(
+              opts.element,
+              "click",
+              (e) => {
+                const eventTarget = getEventTarget(e);
+                const target = findElement(eventTarget);
+                if (target && !treeHasIgnoreAttribute(target)) {
+                  const elementData = getElementData(target);
+                  const data = opts.extendClickData(
+                    e,
+                    elementData
+                  );
+                  if (data) {
+                    sdk.trackEvent(opts.tableName, data);
+                  }
+                }
+              }
+            );
+            clickTrackingInstalled = true;
+            return disposable(() => {
+              removeClickTracker();
+              clickTrackingInstalled = false;
+            });
+          }
+        };
+      }
+    };
+  }
+  const DEFAULT_UTM_PARAMS = [
+    "utm_id",
+    "utm_medium",
+    "utm_source_platform",
+    "utm_source",
+    "utm_campaign",
+    "utm_marketing_tactic"
+  ];
+  function collectUTMParametersFromURL(utmParams = DEFAULT_UTM_PARAMS) {
+    if (typeof window === "undefined" || !window.location) {
+      return {};
+    }
+    const searchString = window.location.search;
+    const URLSearchParamsClass = window.URLSearchParams || URLSearchParams;
+    const searchParams = new URLSearchParamsClass(searchString);
+    const hasParams = utmParams.some((param) => searchParams.has(param));
+    if (!hasParams) {
+      return {};
+    }
+    return utmParams.reduce(
+      (acc, paramName) => {
+        const paramValue = searchParams.get(paramName);
+        if (paramValue) {
+          acc[paramName] = paramValue;
+        }
+        return acc;
+      },
+      {}
+    );
+  }
+  function utm(options = {}) {
+    return {
+      name: "utm",
+      setup(_core, sdk) {
+        const opts = {
+          customParameters: options.customParameters || DEFAULT_UTM_PARAMS,
+          autoCollect: options.autoCollect ?? true,
+          table: options.table || "$global"
+        };
+        let collectedParams = {};
+        function collectUTMParameters() {
+          const params = collectUTMParametersFromURL(opts.customParameters);
+          if (isObject$1(params) && !isEmpty(params)) {
+            if (opts.table === "$global") {
+              sdk.set(params);
+            } else {
+              Object.keys(params).forEach((paramName) => {
+                sdk.set(opts.table, paramName, params[paramName]);
+              });
+            }
+            collectedParams = { ...collectedParams, ...params };
+          }
+          return params;
+        }
+        function getUTMParameters() {
+          return { ...collectedParams };
+        }
+        if (opts.autoCollect) {
+          collectUTMParameters();
+        }
+        return {
+          getUTMParameters,
+          collectUTMParameters
+        };
+      }
+    };
+  }
+  const DEFAULT_CDP_HOST = "cdp.in.treasuredata.com";
+  function invariant(condition, message) {
+    if (!condition) {
+      throw new Error(message);
+    }
+  }
+  function personalization() {
+    return {
+      name: "personalization",
+      setup(core, sdk) {
+        const config = core.config;
+        const cdpHost = config.cdpHost || DEFAULT_CDP_HOST;
+        function fetchUserSegments(tokenOrOptions, successCallback, errorCallback) {
+          const noop = () => {
+          };
+          const success = successCallback || noop;
+          const error = errorCallback || noop;
+          const isConfigObject = isObject$1(tokenOrOptions) && !isArray(tokenOrOptions);
+          const audienceToken = isConfigObject ? tokenOrOptions.audienceToken : tokenOrOptions;
+          const keys = isConfigObject && tokenOrOptions.keys || {};
+          invariant(
+            typeof audienceToken === "string" || isArray(audienceToken),
+            `audienceToken must be a string or array; received "${String(audienceToken)}"`
+          );
+          invariant(
+            isObject$1(keys),
+            `keys must be an object; received "${String(keys)}"`
+          );
+          const token = isArray(audienceToken) ? audienceToken.join(",") : audienceToken;
+          const keysArray = [];
+          Object.keys(keys).forEach((key) => {
+            keysArray.push(`key.${key}=${String(keys[key])}`);
+          });
+          const keyString = keysArray.join("&");
+          const url = `https://${cdpHost}/cdp/lookup/collect/segments?version=2&token=${token}${keyString ? "&" + keyString : ""}`;
+          api.getWithTimeout(url, 1e4, {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          }).then(success).catch(error);
+        }
+        function fetchPersonalization(config2, data, successCallback, errorCallback) {
+          const noop = () => {
+          };
+          const success = successCallback || noop;
+          const error = errorCallback || noop;
+          invariant(
+            isObject$1(config2),
+            `config must be an object, received "${String(config2)}"`
+          );
+          invariant(!!config2.endpoint, "endpoint is invalid");
+          invariant(!!config2.database, "database is invalid");
+          invariant(!!config2.table, "table is invalid");
+          invariant(!!config2.token, "token is invalid");
+          const eventsBlocked = typeof sdk.areEventsBlocked === "function" ? sdk.areEventsBlocked() : false;
+          if (eventsBlocked) {
+            return;
+          }
+          const url = `https://${config2.endpoint}/public/${config2.database}/${config2.table}`;
+          let payload = data || {};
+          const isSignedMode = typeof sdk.inSignedMode === "function" ? sdk.inSignedMode() : true;
+          if (!isSignedMode) {
+            payload = omit(
+              payload,
+              "td_ip",
+              "td_client_id",
+              "td_global_id"
+            );
+          }
+          api.postWithTimeout(url, payload, 1e4, {
+            headers: {
+              "Content-Type": "application/vnd.treasuredata.v1+json",
+              Authorization: `TD1 ${core.config.writeKey}`,
+              "WP13n-Token": config2.token
+            }
+          }).then(success).catch(error);
+        }
+        return {
+          fetchUserSegments,
+          fetchPersonalization
+        };
+      }
+    };
+  }
+  const VENDOR_FUNCTION_MAPPINGS = {
+    google_ads: ["getGoogle_gclid_Param", "getGoogle_wbraid_Param"],
+    google_ga: ["getGoogle_ga_Cookie"],
+    google_mp: ["getGoogle_gcl_Cookies"],
+    meta: [
+      "getFacebook_fbp_Cookie",
+      "getFacebook_fbc_Cookie",
+      "getFacebook_fbclid_Param"
+    ],
+    instagram: [
+      "getInstagram_shbts_Cookie",
+      "getInstagram_shbid_Cookie",
+      "getInstagram_ds_user_id_Cookie",
+      "getInstagram_ig_did_Cookie"
+    ],
+    yahoojp_ads: [
+      "getYahoo_ly_c_Param",
+      "getYahoo_ly_c_Cookie",
+      "getYahoo_ly_r_Cookie",
+      "getYahoo_ly_su_Cookie",
+      "getYahoo_yclid_Param",
+      "getYahoo_yj_r_Param",
+      "getYahoo_ycl_yjad_Cookie",
+      "getYahoo_yjr_yjad_Cookie",
+      "getYahoo_yjsu_yjad_Cookie"
+    ],
+    line: [
+      "getLine_lt_cid_Cookie",
+      "getLine_lt_sid_Cookie",
+      "getLine_ldtag_cl_Param"
+    ],
+    x: ["getX_twclid_Param", "getX_twclid_Cookie"],
+    pinterest: ["getPinterest_epik_Param", "getPinterest_epik_Cookie"],
+    snapchat: ["getSnapchat_sccid_Param"],
+    tiktok: ["getTiktok_ttp_Cookie"],
+    marketo: ["getMarketo_mkto_trk_Cookie"],
+    tealium: ["getTealium_utag_main_Cookie"]
+  };
+  function getCookie(key) {
+    if (typeof document === "undefined") return null;
+    return cookie.getItem(key);
+  }
+  function getCookieByNamePrefix(prefix) {
+    if (typeof document === "undefined") return {};
+    return cookie.keys().filter((key) => key.startsWith(prefix)).reduce(
+      (acc, key) => {
+        const value = cookie.getItem(key);
+        if (value !== null) acc[key] = value;
+        return acc;
+      },
+      {}
+    );
+  }
+  function getParam(key) {
+    if (typeof window === "undefined" || !window.location) return null;
+    const queryString = window.location.search;
+    const URLSearchParamsClass = window.URLSearchParams || URLSearchParams;
+    const urlParams = new URLSearchParamsClass(queryString);
+    return urlParams.get(key);
+  }
+  function conversionAPI() {
+    return {
+      name: "conversionAPI",
+      setup(_core, sdk) {
+        const tagCollectors = {
+          // Google
+          getGoogle_gclid_Param: () => ({ gclid: getParam("gclid") }),
+          getGoogle_wbraid_Param: () => ({ wbraid: getParam("wbraid") }),
+          getGoogle_ga_Cookie: () => ({ _ga: getCookie("_ga") }),
+          getGoogle_gcl_Cookies: (options = {}) => {
+            const prefix = options.gclPrefix || "_gcl";
+            return getCookieByNamePrefix(prefix);
+          },
+          // Meta/Facebook
+          getFacebook_fbp_Cookie: () => ({ _fbp: getCookie("_fbp") }),
+          getFacebook_fbc_Cookie: () => ({ _fbc: getCookie("_fbc") }),
+          getFacebook_fbclid_Param: () => ({ fbclid: getParam("fbclid") }),
+          // Instagram
+          getInstagram_shbts_Cookie: () => ({ shbts: getCookie("shbts") }),
+          getInstagram_shbid_Cookie: () => ({ shbid: getCookie("shbid") }),
+          getInstagram_ds_user_id_Cookie: () => ({
+            ds_user_id: getCookie("ds_user_id")
+          }),
+          getInstagram_ig_did_Cookie: () => ({ ig_did: getCookie("ig_did") }),
+          // Yahoo Japan
+          getYahoo_yclid_Param: () => ({ yclid: getParam("yclid") }),
+          getYahoo_yj_r_Param: () => ({ yj_r: getParam("yj_r") }),
+          getYahoo_ycl_yjad_Cookie: () => ({ _ycl_yjad: getCookie("_ycl_yjad") }),
+          getYahoo_yjr_yjad_Cookie: () => ({ _yjr_yjad: getCookie("_yjr_yjad") }),
+          getYahoo_yjsu_yjad_Cookie: () => ({
+            _yjsu_yjad: getCookie("_yjsu_yjad")
+          }),
+          getYahoo_ly_c_Param: () => ({ ly_c: getParam("_ly_c") }),
+          getYahoo_ly_c_Cookie: () => ({ ly_c: getCookie("_ly_c") }),
+          getYahoo_ly_r_Cookie: () => ({ ly_r: getCookie("_ly_r") }),
+          getYahoo_ly_su_Cookie: () => ({ ly_su: getCookie("_ly_su") }),
+          // Line
+          getLine_lt_cid_Cookie: () => ({ __lt_cid: getCookie("__lt__cid") }),
+          getLine_lt_sid_Cookie: () => ({ __lt_sid: getCookie("__lt__sid") }),
+          getLine_ldtag_cl_Param: () => ({ ldtag_cl: getParam("ldtag_cl") }),
+          // Twitter/X
+          getX_twclid_Param: () => ({ twclid: getParam("twclid") }),
+          getX_twclid_Cookie: () => ({ _twclid: getCookie("_twclid") }),
+          // Pinterest
+          getPinterest_epik_Param: () => ({ epik: getParam("epik") }),
+          getPinterest_epik_Cookie: () => ({ _epik: getCookie("_epik") }),
+          // Snapchat
+          getSnapchat_sccid_Param: () => ({ ScCid: getParam("ScCid") }),
+          // TikTok
+          getTiktok_ttp_Cookie: () => ({ _ttp: getCookie("_ttp") }),
+          // Marketo
+          getMarketo_mkto_trk_Cookie: () => ({
+            _mkto_trk: getCookie("_mkto_trk")
+          }),
+          // Tealium
+          getTealium_utag_main_Cookie: () => ({
+            utag_main: getCookie("utag_main")
+          })
+        };
+        function collectTagsByVendors(vendors = [], options = {}) {
+          return vendors.reduce(
+            (acc, vendor) => {
+              const fnNames = VENDOR_FUNCTION_MAPPINGS[vendor] || [];
+              fnNames.forEach((fnName) => {
+                const result = tagCollectors[fnName](options);
+                Object.assign(acc, result);
+              });
+              return acc;
+            },
+            {}
+          );
+        }
+        function collectTagsByCookieNames(cookieNames = []) {
+          return cookieNames.reduce(
+            (acc, cookieName) => {
+              acc[cookieName] = getCookie(cookieName);
+              return acc;
+            },
+            {}
+          );
+        }
+        function collectTagsByParamNames(params = []) {
+          return params.reduce(
+            (acc, paramName) => {
+              acc[paramName] = getParam(paramName);
+              return acc;
+            },
+            {}
+          );
+        }
+        function collectAllTags(options = {}) {
+          const tags = {};
+          const vendorKeys = Object.keys(VENDOR_FUNCTION_MAPPINGS);
+          vendorKeys.forEach((vendor) => {
+            const vendorFns = VENDOR_FUNCTION_MAPPINGS[vendor];
+            if (vendorFns) {
+              vendorFns.forEach((fnName) => {
+                const result = tagCollectors[fnName](options);
+                Object.assign(tags, result);
+              });
+            }
+          });
+          return Object.keys(tags).reduce(
+            (acc, key) => {
+              if (tags[key]) {
+                acc[key] = tags[key];
+              }
+              return acc;
+            },
+            {}
+          );
+        }
+        function collectTags(config = {}, options = {}) {
+          const isEmptyConfigValues = isEmpty(config.vendors) && isEmpty(config.cookies) && isEmpty(config.params);
+          let tags = {};
+          if (isEmpty(config) || isEmptyConfigValues) {
+            tags = collectAllTags(options);
+          } else {
+            if (!isEmpty(config.vendors)) {
+              Object.assign(tags, collectTagsByVendors(config.vendors, options));
+            }
+            if (!isEmpty(config.cookies)) {
+              Object.assign(tags, collectTagsByCookieNames(config.cookies));
+            }
+            if (!isEmpty(config.params)) {
+              Object.assign(tags, collectTagsByParamNames(config.params));
+            }
+          }
+          Object.keys(tags).forEach((tagKey) => {
+            const tagValue = tags[tagKey];
+            if (tagValue) {
+              sdk.set({ [tagKey]: tagValue });
+            }
+          });
+        }
+        return {
+          collectTags
+        };
+      }
+    };
+  }
+  const MODE_QUERY_PARAM = "td-personalization-mode";
+  const INIT_MESSAGE_TYPE = "td:p13n-studio:init";
+  const READY_MESSAGE_TYPE = "td:p13n-studio:ready";
+  const PROD_ORIGINS = [
+    // us01
+    "https://console-development-next.us01.treasuredata.com",
+    "https://console-staging-next.us01.treasuredata.com",
+    "https://console-next.us01.treasuredata.com",
+    // tokyo
+    "https://console-staging-next.treasuredata.co.jp",
+    "https://console-next.treasuredata.co.jp",
+    // eu01
+    "https://console-development-next.eu01.treasuredata.com",
+    "https://console-next.eu01.treasuredata.com",
+    // ap02
+    "https://console-next.ap02.treasuredata.com",
+    // ap03
+    "https://console-staging-next.ap03.treasuredata.com",
+    "https://console-next.ap03.treasuredata.com"
+  ];
+  const ALLOWED_PARENT_ORIGINS = Object.freeze(
+    [...PROD_ORIGINS]
+  );
+  /**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   */
+  const proxyMarker = Symbol("Comlink.proxy");
+  const createEndpoint = Symbol("Comlink.endpoint");
+  const releaseProxy = Symbol("Comlink.releaseProxy");
+  const finalizer = Symbol("Comlink.finalizer");
+  const throwMarker = Symbol("Comlink.thrown");
+  const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+  const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+      const { port1, port2 } = new MessageChannel();
+      expose(obj, port1);
+      return [port2, [port2]];
+    },
+    deserialize(port) {
+      port.start();
+      return wrap(port);
+    }
+  };
+  const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+      let serialized;
+      if (value instanceof Error) {
+        serialized = {
+          isError: true,
+          value: {
+            message: value.message,
+            name: value.name,
+            stack: value.stack
+          }
+        };
+      } else {
+        serialized = { isError: false, value };
+      }
+      return [serialized, []];
+    },
+    deserialize(serialized) {
+      if (serialized.isError) {
+        throw Object.assign(new Error(serialized.value.message), serialized.value);
+      }
+      throw serialized.value;
+    }
+  };
+  const transferHandlers = /* @__PURE__ */ new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler]
+  ]);
+  function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+      if (origin === allowedOrigin || allowedOrigin === "*") {
+        return true;
+      }
+      if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    ep.addEventListener("message", function callback(ev) {
+      if (!ev || !ev.data) {
+        return;
+      }
+      if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+        console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+        return;
+      }
+      const { id, type, path } = Object.assign({ path: [] }, ev.data);
+      const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+      let returnValue;
+      try {
+        const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+        const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+        switch (type) {
+          case "GET":
+            {
+              returnValue = rawValue;
+            }
+            break;
+          case "SET":
+            {
+              parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+              returnValue = true;
+            }
+            break;
+          case "APPLY":
+            {
+              returnValue = rawValue.apply(parent, argumentList);
+            }
+            break;
+          case "CONSTRUCT":
+            {
+              const value = new rawValue(...argumentList);
+              returnValue = proxy(value);
+            }
+            break;
+          case "ENDPOINT":
+            {
+              const { port1, port2 } = new MessageChannel();
+              expose(obj, port2);
+              returnValue = transfer(port1, [port1]);
+            }
+            break;
+          case "RELEASE":
+            {
+              returnValue = void 0;
+            }
+            break;
+          default:
+            return;
+        }
+      } catch (value) {
+        returnValue = { value, [throwMarker]: 0 };
+      }
+      Promise.resolve(returnValue).catch((value) => {
+        return { value, [throwMarker]: 0 };
+      }).then((returnValue2) => {
+        const [wireValue, transferables] = toWireValue(returnValue2);
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+        if (type === "RELEASE") {
+          ep.removeEventListener("message", callback);
+          closeEndPoint(ep);
+          if (finalizer in obj && typeof obj[finalizer] === "function") {
+            obj[finalizer]();
+          }
+        }
+      }).catch((error) => {
+        const [wireValue, transferables] = toWireValue({
+          value: new TypeError("Unserializable return value"),
+          [throwMarker]: 0
+        });
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      });
+    });
+    if (ep.start) {
+      ep.start();
+    }
+  }
+  function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+  }
+  function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+      endpoint.close();
+  }
+  function wrap(ep, target) {
+    const pendingListeners = /* @__PURE__ */ new Map();
+    ep.addEventListener("message", function handleMessage(ev) {
+      const { data } = ev;
+      if (!data || !data.id) {
+        return;
+      }
+      const resolver = pendingListeners.get(data.id);
+      if (!resolver) {
+        return;
+      }
+      try {
+        resolver(data);
+      } finally {
+        pendingListeners.delete(data.id);
+      }
+    });
+    return createProxy(ep, pendingListeners, [], target);
+  }
+  function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+      throw new Error("Proxy has been released and is not useable");
+    }
+  }
+  function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+      type: "RELEASE"
+    }).then(() => {
+      closeEndPoint(ep);
+    });
+  }
+  const proxyCounter = /* @__PURE__ */ new WeakMap();
+  const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+    const newCount = (proxyCounter.get(ep) || 0) - 1;
+    proxyCounter.set(ep, newCount);
+    if (newCount === 0) {
+      releaseEndpoint(ep);
+    }
+  });
+  function registerProxy(proxy2, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+      proxyFinalizers.register(proxy2, ep, proxy2);
+    }
+  }
+  function unregisterProxy(proxy2) {
+    if (proxyFinalizers) {
+      proxyFinalizers.unregister(proxy2);
+    }
+  }
+  function createProxy(ep, pendingListeners, path = [], target = function() {
+  }) {
+    let isProxyReleased = false;
+    const proxy2 = new Proxy(target, {
+      get(_target, prop) {
+        throwIfProxyReleased(isProxyReleased);
+        if (prop === releaseProxy) {
+          return () => {
+            unregisterProxy(proxy2);
+            releaseEndpoint(ep);
+            pendingListeners.clear();
+            isProxyReleased = true;
+          };
+        }
+        if (prop === "then") {
+          if (path.length === 0) {
+            return { then: () => proxy2 };
+          }
+          const r = requestResponseMessage(ep, pendingListeners, {
+            type: "GET",
+            path: path.map((p) => p.toString())
+          }).then(fromWireValue);
+          return r.then.bind(r);
+        }
+        return createProxy(ep, pendingListeners, [...path, prop]);
+      },
+      set(_target, prop, rawValue) {
+        throwIfProxyReleased(isProxyReleased);
+        const [value, transferables] = toWireValue(rawValue);
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "SET",
+          path: [...path, prop].map((p) => p.toString()),
+          value
+        }, transferables).then(fromWireValue);
+      },
+      apply(_target, _thisArg, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const last = path[path.length - 1];
+        if (last === createEndpoint) {
+          return requestResponseMessage(ep, pendingListeners, {
+            type: "ENDPOINT"
+          }).then(fromWireValue);
+        }
+        if (last === "bind") {
+          return createProxy(ep, pendingListeners, path.slice(0, -1));
+        }
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "APPLY",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      },
+      construct(_target, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "CONSTRUCT",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      }
+    });
+    registerProxy(proxy2, ep);
+    return proxy2;
+  }
+  function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+  }
+  function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+  }
+  const transferCache = /* @__PURE__ */ new WeakMap();
+  function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+  }
+  function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+  }
+  function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+      if (handler.canHandle(value)) {
+        const [serializedValue, transferables] = handler.serialize(value);
+        return [
+          {
+            type: "HANDLER",
+            name,
+            value: serializedValue
+          },
+          transferables
+        ];
+      }
+    }
+    return [
+      {
+        type: "RAW",
+        value
+      },
+      transferCache.get(value) || []
+    ];
+  }
+  function fromWireValue(value) {
+    switch (value.type) {
+      case "HANDLER":
+        return transferHandlers.get(value.name).deserialize(value.value);
+      case "RAW":
+        return value.value;
+    }
+  }
+  function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+    return new Promise((resolve) => {
+      const id = generateUUID();
+      pendingListeners.set(id, resolve);
+      if (ep.start) {
+        ep.start();
+      }
+      ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+  }
+  function generateUUID() {
+    return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+  }
+  function onParentPort(onPort) {
+    let activePort = null;
+    const onInit = (ev) => {
+      if (!ALLOWED_PARENT_ORIGINS.includes(ev.origin)) return;
+      if (ev.data !== INIT_MESSAGE_TYPE) return;
+      const port = ev.ports[0];
+      if (!port) return;
+      window.removeEventListener("message", onInit);
+      activePort = port;
+      onPort(port);
+    };
+    window.addEventListener("message", onInit);
+    try {
+      window.parent.postMessage(READY_MESSAGE_TYPE, "*");
+    } catch {
+    }
+    return {
+      dispose() {
+        window.removeEventListener("message", onInit);
+        activePort?.close();
+        activePort = null;
+      }
+    };
+  }
+  function exposeRpc(rpc) {
+    return onParentPort((port) => {
+      expose(rpc, port);
+    });
+  }
+  function wrapParentRpc() {
+    let api2 = null;
+    const runtime = onParentPort((port) => {
+      port.start();
+      api2 = wrap(port);
+    });
+    return {
+      getApi: () => api2,
+      dispose() {
+        runtime.dispose?.();
+        api2 = null;
+      }
+    };
+  }
+  function querySpot(doc, selector) {
+    try {
+      const nodes = doc.querySelectorAll(selector);
+      return { element: nodes[0] ?? null, matchCount: nodes.length };
+    } catch {
+      return null;
+    }
+  }
+  function ensureShadowRoot(host) {
+    if (host.shadowRoot) return { ok: true, shadow: host.shadowRoot };
+    try {
+      return { ok: true, shadow: host.attachShadow({ mode: "open" }) };
+    } catch (err) {
+      return { ok: false, name: err instanceof Error ? err.name : "" };
+    }
+  }
+  function classifyShadowError(name) {
+    switch (name) {
+      case "NotSupportedError":
+        return "unsupported_element";
+      case "InvalidStateError":
+        return "already_has_shadow";
+      default:
+        return "injection_error";
+    }
+  }
+  function applySpot(doc, spot) {
+    const query = querySpot(doc, spot.selector);
+    if (!query) {
+      return { selector: spot.selector, success: false, reason: "invalid_spot" };
+    }
+    if (!query.element) {
+      return {
+        selector: spot.selector,
+        success: false,
+        reason: "not_found",
+        matchCount: 0
+      };
+    }
+    const shadowResult = ensureShadowRoot(query.element);
+    if (!shadowResult.ok) {
+      return {
+        selector: spot.selector,
+        success: false,
+        reason: classifyShadowError(shadowResult.name),
+        matchCount: query.matchCount
+      };
+    }
+    const shadow = shadowResult.shadow;
+    try {
+      shadow.replaceChildren();
+      if (spot.css) {
+        const style = doc.createElement("style");
+        style.textContent = spot.css;
+        shadow.appendChild(style);
+      }
+      if (spot.html) {
+        const wrapper = doc.createElement("div");
+        wrapper.innerHTML = spot.html;
+        shadow.appendChild(wrapper);
+      }
+      return {
+        selector: spot.selector,
+        success: true,
+        matchCount: query.matchCount
+      };
+    } catch {
+      return {
+        selector: spot.selector,
+        success: false,
+        reason: "injection_error",
+        matchCount: query.matchCount
+      };
+    }
+  }
+  function removeSpot(doc, ref) {
+    let host;
+    try {
+      host = doc.querySelector(ref.selector);
+    } catch {
+      return;
+    }
+    const shadow = host?.shadowRoot;
+    if (!shadow) return;
+    shadow.replaceChildren(doc.createElement("slot"));
+  }
+  function validateSpot(value) {
+    if (!value || typeof value !== "object") {
+      return { ok: false, reason: `not an object (${typeof value})` };
+    }
+    const v = value;
+    if (typeof v["selector"] !== "string") {
+      return {
+        ok: false,
+        reason: `selector not a string (${typeof v["selector"]})`
+      };
+    }
+    if (v["selector"].length === 0) {
+      return { ok: false, reason: "selector empty" };
+    }
+    if (v["html"] !== void 0 && typeof v["html"] !== "string") {
+      return { ok: false, reason: `html not a string (${typeof v["html"]})` };
+    }
+    if (v["css"] !== void 0 && typeof v["css"] !== "string") {
+      return { ok: false, reason: `css not a string (${typeof v["css"]})` };
+    }
+    return { ok: true, spot: value };
+  }
+  function isSpotRef(value) {
+    if (!value || typeof value !== "object") return false;
+    const sel = value.selector;
+    return typeof sel === "string" && sel.length > 0;
+  }
+  function getSelector(value) {
+    if (value && typeof value === "object" && "selector" in value) {
+      return value.selector;
+    }
+    return null;
+  }
+  function buildRpc(log) {
+    return {
+      async applySpots(spots) {
+        invariant$1(
+          Array.isArray(spots),
+          "pagePersonalize/preview: applySpots requires an array"
+        );
+        return spots.map((entry, i) => {
+          const validated = validateSpot(entry);
+          if (!validated.ok) {
+            log.warn(
+              `pagePersonalize/preview: applySpots[${i}] invalid_spot: ${validated.reason}`
+            );
+            return {
+              selector: getSelector(entry),
+              success: false,
+              reason: "invalid_spot"
+            };
+          }
+          const result = applySpot(document, validated.spot);
+          if (!result.success) {
+            log.warn(
+              `pagePersonalize/preview: applySpot "${result.selector}" -> ${result.reason}` + (result.matchCount !== void 0 ? ` (matchCount=${result.matchCount})` : "")
+            );
+          }
+          return result;
+        });
+      },
+      async removeSpots(spots) {
+        invariant$1(
+          Array.isArray(spots),
+          "pagePersonalize/preview: removeSpots requires an array"
+        );
+        for (let i = 0; i < spots.length; i++) {
+          const entry = spots[i];
+          if (!isSpotRef(entry)) {
+            log.warn(
+              `pagePersonalize/preview: removeSpots[${i}] skipped malformed ref`
+            );
+            continue;
+          }
+          removeSpot(document, entry);
+        }
+      }
+    };
+  }
+  const previewHandler = {
+    mode: "preview",
+    activate(core) {
+      return exposeRpc(buildRpc(core.log));
+    }
+  };
+  const UNSTABLE_ID_PATTERNS = [
+    /^[0-9]+$/,
+    // numeric-only
+    /^:r/,
+    // React :r IDs
+    /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+    // UUIDs
+  ];
+  const UNSTABLE_DATA_VALUE_PATTERNS = [
+    /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i,
+    // UUIDs
+    /^[a-z0-9]{20,}$/i
+    // long token-like strings
+  ];
+  const UNSTABLE_CLASS_PATTERNS = [
+    /^css-/,
+    // CSS-in-JS (emotion, etc.)
+    /^sc-/,
+    // styled-components
+    /^emotion-/,
+    /^[a-zA-Z0-9]{5,}$/
+    // random 5+ char alphanum (likely generated)
+  ];
+  const SEMANTIC_TAGS = [
+    "main",
+    "nav",
+    "header",
+    "footer",
+    "aside",
+    "article",
+    "section"
+  ];
+  const ARIA_LANDMARK_ROLES = [
+    "banner",
+    "complementary",
+    "contentinfo",
+    "form",
+    "main",
+    "navigation",
+    "region",
+    "search"
+  ];
+  function isStableId(id) {
+    return !UNSTABLE_ID_PATTERNS.some((pattern) => pattern.test(id));
+  }
+  function isStableDataValue(value) {
+    return !UNSTABLE_DATA_VALUE_PATTERNS.some((pattern) => pattern.test(value));
+  }
+  function isStableClass(className) {
+    if (className.startsWith("p13n-sdk-")) return false;
+    return !UNSTABLE_CLASS_PATTERNS.some((pattern) => pattern.test(className));
+  }
+  function isUnique(selector) {
+    return document.querySelectorAll(selector).length === 1;
+  }
+  function validate(selector, element) {
+    try {
+      return document.querySelector(selector) === element;
+    } catch {
+      return false;
+    }
+  }
+  function getTagName(element) {
+    return element.localName;
+  }
+  function tryDirectAnchor(element) {
+    if (element.id && isStableId(element.id)) {
+      const selector = `#${CSS.escape(element.id)}`;
+      if (validate(selector, element)) return selector;
+    }
+    for (const attr of element.attributes) {
+      if (attr.name.startsWith("data-") && attr.value && isStableDataValue(attr.value)) {
+        const selector = `[${CSS.escape(attr.name)}="${CSS.escape(attr.value)}"]`;
+        if (isUnique(selector) && validate(selector, element)) return selector;
+      }
+    }
+    for (const cls of element.classList) {
+      if (isStableClass(cls)) {
+        const selector = `.${CSS.escape(cls)}`;
+        if (isUnique(selector) && validate(selector, element)) return selector;
+      }
+    }
+    const tag = getTagName(element);
+    for (const cls of element.classList) {
+      if (isStableClass(cls)) {
+        const selector = `${tag}.${CSS.escape(cls)}`;
+        if (isUnique(selector) && validate(selector, element)) return selector;
+      }
+    }
+    const role = element.getAttribute("role");
+    if (role && ARIA_LANDMARK_ROLES.includes(role)) {
+      const selector = `[role="${role}"]`;
+      if (isUnique(selector) && validate(selector, element)) return selector;
+    }
+    if (SEMANTIC_TAGS.includes(tag)) {
+      if (isUnique(tag) && validate(tag, element)) return tag;
+    }
+    return null;
+  }
+  function getNthOfTypeIndex(element) {
+    const tag = getTagName(element);
+    let index = 1;
+    let sibling = element.previousElementSibling;
+    while (sibling) {
+      if (sibling.localName === tag) index++;
+      sibling = sibling.previousElementSibling;
+    }
+    return index;
+  }
+  function buildRelativePath(from, to) {
+    const parts = [];
+    let current = to;
+    while (current && current !== from) {
+      const tag = getTagName(current);
+      const index = getNthOfTypeIndex(current);
+      parts.unshift(`${tag}:nth-of-type(${index})`);
+      current = current.parentElement;
+    }
+    return parts.join(" > ");
+  }
+  function tryAnchoredPath(element) {
+    let ancestor = element.parentElement;
+    while (ancestor && ancestor !== document.documentElement) {
+      const anchorSelector = tryDirectAnchor(ancestor);
+      if (anchorSelector) {
+        const relativePath = buildRelativePath(ancestor, element);
+        const selector = `${anchorSelector} > ${relativePath}`;
+        if (validate(selector, element)) return selector;
+      }
+      ancestor = ancestor.parentElement;
+    }
+    return null;
+  }
+  function buildFullPath(element) {
+    const parts = [];
+    let current = element;
+    while (current && current !== document.documentElement) {
+      const tag = getTagName(current);
+      const index = getNthOfTypeIndex(current);
+      parts.unshift(`${tag}:nth-of-type(${index})`);
+      current = current.parentElement;
+    }
+    const selector = `html > ${parts.join(" > ")}`;
+    if (validate(selector, element)) return selector;
+    return null;
+  }
+  function generateSelector(element) {
+    if (!element || element === document.documentElement || element === document.body) {
+      return element === document.body ? "body" : "html";
+    }
+    const direct = tryDirectAnchor(element);
+    if (direct) return direct;
+    const anchored = tryAnchoredPath(element);
+    if (anchored) return anchored;
+    return buildFullPath(element) ?? element.localName;
+  }
+  const SDK_ATTR = "data-p13n-sdk";
+  const HIGHLIGHT_CLASS = "p13n-sdk-highlight";
+  const SUPPRESSED_EVENTS = [
+    "mousedown",
+    "mouseup",
+    "pointerdown",
+    "pointerup",
+    "keydown",
+    "keyup",
+    "focusin",
+    "submit"
+  ];
+  const INJECTED_CSS = `
+  .${HIGHLIGHT_CLASS} {
+    outline: 2px solid blue !important;
+    outline-offset: -2px !important;
+    cursor: crosshair !important;
+  }
+  .p13n-sdk-tooltip {
+    position: fixed;
+    z-index: 2147483647;
+    background: rgba(0, 0, 0, 0.8);
+    color: #fff;
+    font-family: monospace;
+    font-size: 12px;
+    padding: 4px 8px;
+    border-radius: 4px;
+    pointer-events: none;
+    white-space: nowrap;
+  }
+`;
+  function isSdkElement(target) {
+    let current = target;
+    while (current) {
+      if (current.hasAttribute && current.hasAttribute(SDK_ATTR)) return true;
+      current = current.parentElement;
+    }
+    return false;
+  }
+  function getElementDimensions(element) {
+    if (element.offsetWidth !== 0) {
+      return { width: element.offsetWidth, height: element.offsetHeight };
+    }
+    const rect = element.getBoundingClientRect();
+    return { width: Math.round(rect.width), height: Math.round(rect.height) };
+  }
+  function createSelectionRuntime(onSelect) {
+    let highlightedElement = null;
+    const style = document.createElement("style");
+    style.setAttribute(SDK_ATTR, "");
+    style.textContent = INJECTED_CSS;
+    document.head.appendChild(style);
+    const tooltip = document.createElement("div");
+    tooltip.className = "p13n-sdk-tooltip";
+    tooltip.setAttribute(SDK_ATTR, "");
+    tooltip.style.display = "none";
+    document.body.appendChild(tooltip);
+    function positionTooltip(event) {
+      const offset = 15;
+      let x = event.clientX + offset;
+      let y = event.clientY + offset;
+      const tooltipRect = tooltip.getBoundingClientRect();
+      const tooltipWidth = tooltipRect.width || 150;
+      const tooltipHeight = tooltipRect.height || 24;
+      if (x + tooltipWidth > window.innerWidth) {
+        x = event.clientX - offset - tooltipWidth;
+      }
+      if (y + tooltipHeight > window.innerHeight) {
+        y = event.clientY - offset - tooltipHeight;
+      }
+      tooltip.style.left = `${x}px`;
+      tooltip.style.top = `${y}px`;
+    }
+    function onMouseOver(event) {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      if (isSdkElement(target)) return;
+      if (highlightedElement && highlightedElement !== target) {
+        highlightedElement.classList.remove(HIGHLIGHT_CLASS);
+      }
+      highlightedElement = target;
+      target.classList.add(HIGHLIGHT_CLASS);
+      const tag = target.localName;
+      const { width, height } = getElementDimensions(target);
+      tooltip.textContent = `${tag} ${width}×${height}`;
+      tooltip.style.display = "block";
+      positionTooltip(event);
+    }
+    function onMouseMove(event) {
+      if (tooltip.style.display === "block") {
+        positionTooltip(event);
+      }
+    }
+    function onMouseOut(event) {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      if (isSdkElement(target)) return;
+      if (highlightedElement === target) {
+        target.classList.remove(HIGHLIGHT_CLASS);
+        highlightedElement = null;
+      }
+      tooltip.style.display = "none";
+    }
+    function suppressEvent(event) {
+      if (isSdkElement(event.target)) return;
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+    }
+    function onClick(event) {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      suppressEvent(event);
+      const selector = generateSelector(target);
+      onSelect(selector);
+    }
+    function attachListeners() {
+      document.addEventListener("mouseover", onMouseOver, true);
+      document.addEventListener("mousemove", onMouseMove, true);
+      document.addEventListener("mouseout", onMouseOut, true);
+      document.addEventListener("click", onClick, true);
+      for (const eventType of SUPPRESSED_EVENTS) {
+        document.addEventListener(eventType, suppressEvent, true);
+      }
+    }
+    function detachListeners() {
+      document.removeEventListener("mouseover", onMouseOver, true);
+      document.removeEventListener("mousemove", onMouseMove, true);
+      document.removeEventListener("mouseout", onMouseOut, true);
+      document.removeEventListener("click", onClick, true);
+      for (const eventType of SUPPRESSED_EVENTS) {
+        document.removeEventListener(eventType, suppressEvent, true);
+      }
+    }
+    function clearHighlightState() {
+      if (highlightedElement) {
+        highlightedElement.classList.remove(HIGHLIGHT_CLASS);
+        highlightedElement = null;
+      }
+      tooltip.style.display = "none";
+    }
+    attachListeners();
+    return {
+      dispose() {
+        detachListeners();
+        clearHighlightState();
+        tooltip.remove();
+        style.remove();
+        highlightedElement = null;
+      }
+    };
+  }
+  const spotSelectionHandler = {
+    mode: "spot-selection",
+    activate(core) {
+      const bridge = wrapParentRpc();
+      const runtime = createSelectionRuntime((selector) => {
+        const api2 = bridge.getApi();
+        if (api2) {
+          api2.onSpotSelected(selector);
+        } else {
+          core.log.warn(
+            "pagePersonalize/spot-selection: no parent RPC connection, cannot send selector"
+          );
+        }
+      });
+      return {
+        dispose() {
+          runtime.dispose?.();
+          bridge.dispose?.();
+        }
+      };
+    }
+  };
+  const MODE_HANDLERS = {
+    preview: previewHandler,
+    "spot-selection": spotSelectionHandler
+  };
+  function readMode() {
+    if (typeof window === "undefined" || !window.location) return null;
+    let raw_mode_param;
+    try {
+      raw_mode_param = new URLSearchParams(window.location.search).get(
+        MODE_QUERY_PARAM
+      );
+    } catch {
+      return null;
+    }
+    if (!raw_mode_param) return null;
+    if (Object.hasOwn(MODE_HANDLERS, raw_mode_param))
+      return raw_mode_param;
+    return null;
+  }
+  function runRouter(core) {
+    const mode = readMode();
+    if (!mode) return null;
+    let runtime;
+    try {
+      runtime = MODE_HANDLERS[mode].activate(core);
+    } catch (err) {
+      core.log.error(
+        `pagePersonalize: activation failed for mode "${mode}":`,
+        err
+      );
+      return null;
+    }
+    return runtime ? mode : null;
+  }
+  function numAttr(attrs, key) {
+    const raw = attrs[key];
+    if (typeof raw !== "string" || raw.length === 0) return null;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : null;
+  }
+  function strAttr(attrs, key) {
+    const raw = attrs[key];
+    return typeof raw === "string" && raw.length > 0 ? raw : null;
+  }
+  function isInWindow(attrs, now) {
+    const start = numAttr(attrs, "td_personalization.campaigns_start_date");
+    if (start !== null && now < start) return false;
+    const end = numAttr(attrs, "td_personalization.campaigns_end_date");
+    if (end !== null && now >= end) return false;
+    return true;
+  }
+  function isLiveOffer(offer, now) {
+    const attrs = offer.attributes;
+    return !!attrs && typeof attrs === "object" && isInWindow(attrs, now);
+  }
+  function toScoredOffer(offer) {
+    const attrs = offer.attributes;
+    if (!attrs) return null;
+    const rank = numAttr(attrs, "td_personalization.audience_rank");
+    if (rank === null) return null;
+    const updated = numAttr(attrs, "td_personalization.campaign_updated_at") ?? -Infinity;
+    return { offer, updated, rank };
+  }
+  function maxBy(items, ranksAbove) {
+    return items.reduce(
+      (best, item) => best === null || ranksAbove(item, best) ? item : best,
+      null
+    );
+  }
+  function selectWinningOffer(payload, now = Date.now() / 1e3) {
+    const offers = payload?.offers;
+    if (!offers || typeof offers !== "object") return null;
+    const candidates = Object.values(offers).filter((offer) => isLiveOffer(offer, now)).flatMap((offer) => toScoredOffer(offer) ?? []);
+    const winner = maxBy(
+      candidates,
+      (a, b) => a.updated > b.updated || a.updated === b.updated && a.rank < b.rank
+    );
+    return winner?.offer ?? null;
+  }
+  function parseEntries(p13n) {
+    if (typeof p13n !== "string") return null;
+    try {
+      const parsed = JSON.parse(p13n);
+      return Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  function toSpot(entry) {
+    if (!entry || typeof entry !== "object") return null;
+    const {
+      css_selector: selector,
+      html_value: html,
+      css_value: css
+    } = entry;
+    if (typeof selector !== "string" || selector.length === 0) return null;
+    if (typeof html !== "string") return null;
+    if (typeof css !== "string") return null;
+    return { selector, html, css };
+  }
+  function decodeEntry(entry, campaign) {
+    const spot = toSpot(entry);
+    if (!spot) return null;
+    const id = entry.id;
+    const creative = typeof id === "number" && Number.isFinite(id) ? String(id) : null;
+    const impression = campaign && creative ? { campaign, creative } : null;
+    return { spot, impression };
+  }
+  function decodeOffers(payload, now) {
+    const offer = selectWinningOffer(payload, now);
+    if (!offer) return [];
+    const attrs = offer.attributes;
+    const campaign = attrs ? strAttr(attrs, "td_personalization.campaign") : null;
+    const entries = parseEntries(attrs?.["td_personalization.content"]);
+    if (!entries) return [];
+    return entries.flatMap((entry) => decodeEntry(entry, campaign) ?? []);
+  }
+  const PERSONALIZATION_DATABASE = "td_c360_personalization";
+  const PERSONALIZATION_TABLE = "events";
+  const CLICKABLE_SELECTOR = 'a, button, [role="button"], [role="link"]';
+  const CAMPAIGN_ATTR = "data-td-personalization-campaign";
+  const CREATIVE_ATTR = "data-td-personalization-creative";
+  function pagePersonalize() {
+    return {
+      name: "pagePersonalize",
+      setup(core, sdk) {
+        const activeMode = runRouter(core);
+        function reportEvent(event, ref) {
+          const base = typeof sdk.getTrackValues === "function" ? sdk.getTrackValues() : {};
+          sdk.addRecord(
+            PERSONALIZATION_TABLE,
+            {
+              ...base,
+              td_event: event,
+              td_personalization_campaign: ref.campaign,
+              td_personalization_creative: ref.creative
+            },
+            void 0,
+            void 0,
+            { database: PERSONALIZATION_DATABASE }
+          );
+        }
+        function handleSpotClick(e) {
+          const node = e.target;
+          if (!(node instanceof Element) || !node.closest(CLICKABLE_SELECTOR)) {
+            return;
+          }
+          const host = e.currentTarget.host;
+          const campaign = host.getAttribute(CAMPAIGN_ATTR);
+          const creative = host.getAttribute(CREATIVE_ATTR);
+          if (campaign && creative) reportEvent("click", { campaign, creative });
+        }
+        function trackSpotClicks(selector, ref) {
+          const host = document.querySelector(selector);
+          if (!host?.shadowRoot) return;
+          host.setAttribute(CAMPAIGN_ATTR, ref.campaign);
+          host.setAttribute(CREATIVE_ATTR, ref.creative);
+          host.shadowRoot.addEventListener("click", handleSpotClick);
+        }
+        function applyPersonalization(payload, options) {
+          if (typeof document === "undefined") return;
+          if (activeMode !== null && !options?.force) return;
+          for (const { spot, impression } of decodeOffers(payload)) {
+            const result = applySpot(document, spot);
+            if (result.success && impression) {
+              reportEvent("impression", impression);
+              trackSpotClicks(spot.selector, impression);
+            }
+          }
+        }
+        function personalizePage(config, data, successCallback, errorCallback) {
+          if (activeMode !== null) {
+            core.log.debug(
+              `pagePersonalize: personalizePage suppressed in "${activeMode}" mode`
+            );
+            return;
+          }
+          const body = {};
+          if (typeof document !== "undefined" && document.location) {
+            body["td_url"] = document.location.href.split("#")[0];
+            body["td_host"] = document.location.host;
+            body["td_path"] = document.location.pathname;
+          }
+          Object.assign(body, data);
+          sdk.fetchPersonalization(
+            config,
+            body,
+            (response) => {
+              const payload = response;
+              applyPersonalization(payload);
+              successCallback?.(payload);
+            },
+            errorCallback
+          );
+        }
+        return { applyPersonalization, personalizePage };
+      }
+    };
+  }
+  function globalId() {
+    return {
+      name: "globalId",
+      setup(core, sdk) {
+        const config = core.config;
+        const noop = () => {
+        };
+        function fetchGlobalID(success, error, forceFetch = false, options = {}) {
+          const successCallback = success || noop;
+          const errorCallback = error || noop;
+          if (!sdk.inSignedMode()) {
+            return errorCallback("not in signed in mode");
+          }
+          if (!sdk.isGlobalIdEnabled()) {
+            return errorCallback("global id is not enabled");
+          }
+          const cookieName = config.globalIdCookie || "_td_global";
+          const cachedGlobalId = cookie.getItem(cookieName);
+          if (cachedGlobalId && !forceFetch) {
+            setTimeout(() => successCallback(cachedGlobalId), 0);
+            return;
+          }
+          const sameSite = options.sameSite || "None";
+          const url = `https://${config.host}`;
+          const headers = {
+            Authorization: `TD1 ${config.writeKey}`,
+            "Content-Type": globalIdAdlHeaders["Content-Type"],
+            Accept: globalIdAdlHeaders["Accept"]
+          };
+          if (typeof navigator !== "undefined") {
+            headers["User-Agent"] = navigator.userAgent;
+          }
+          api.get(url, { headers }).then((res) => {
+            if (!res["global_id"]) {
+              successCallback(null);
+              return;
+            }
+            const globalIdValue = res["global_id"];
+            const maxAge = options.maxAge ?? 6e3;
+            cookie.setItem(
+              cookieName,
+              globalIdValue,
+              maxAge,
+              options.path,
+              options.domain,
+              options.secure,
+              sameSite
+            );
+            successCallback(globalIdValue);
+          }).catch((err) => {
+            errorCallback(err);
+          });
+        }
+        return { fetchGlobalID };
+      }
+    };
+  }
+  const LOADER_METHODS = [
+    "set",
+    "collectTags",
+    "blockEvents",
+    "unblockEvents",
+    "setSignedMode",
+    "setAnonymousMode",
+    "fetchServerCookie",
+    "fetchGlobalID",
+    "fetchUserSegments",
+    "fetchPersonalization",
+    "resetUUID",
+    "addRecord",
+    "trackEvent",
+    "trackPageview",
+    "trackClicks",
+    "ready"
+  ];
+  function processQueuedCalls(loaderClient, actualClient) {
+    if (loaderClient._init && loaderClient._init.length > 0) ;
+    LOADER_METHODS.forEach((method) => {
+      const queuedCalls = loaderClient["_" + method];
+      if (queuedCalls && Array.isArray(queuedCalls) && queuedCalls.length > 0) {
+        queuedCalls.forEach((args) => {
+          if (typeof actualClient[method] === "function") {
+            actualClient[method].apply(actualClient, args);
+          }
+        });
+      }
+    });
+  }
+  function replaceLoaderStub(globalName, sdkConstructor) {
+    const global = typeof window !== "undefined" ? window : globalThis;
+    if (global[globalName] && global[globalName].clients) {
+      const clients = global[globalName].clients;
+      global[globalName] = sdkConstructor;
+      clients.forEach((loaderClient) => {
+        let actualClient;
+        if (loaderClient._init && loaderClient._init.length > 0) {
+          const initArgs = loaderClient._init[0];
+          actualClient = new sdkConstructor(...initArgs || []);
+        } else {
+          actualClient = new sdkConstructor();
+        }
+        processQueuedCalls(loaderClient, actualClient);
+        Object.setPrototypeOf(loaderClient, actualClient);
+        Object.assign(loaderClient, actualClient);
+      });
+    }
+  }
+  class Treasure2 {
+    _sdk;
+    constructor(config) {
+      if (!(this instanceof Treasure2)) {
+        return new Treasure2(config);
+      }
+      this._sdk = this.init(config);
+      this.bindMethods();
+      return this;
+    }
+    /**
+     * Initialize the SDK with all plugins
+     */
+    init(config) {
+      const processedConfig = configure(config);
+      const sdk = createSDK(processedConfig).use(session()).use(record()).use(track()).use(clicks()).use(utm()).use(personalization()).use(conversionAPI()).use(serverCookie()).use(globalId()).use(pagePersonalize());
+      return sdk;
+    }
+    /**
+     * Bind all SDK methods to this instance for direct access
+     */
+    bindMethods() {
+      const methodNames = /* @__PURE__ */ new Set();
+      let current = this._sdk;
+      while (current && current !== Object.prototype) {
+        Object.getOwnPropertyNames(current).forEach((name) => {
+          if (typeof current[name] === "function" && name !== "constructor") {
+            methodNames.add(name);
+          }
+        });
+        current = Object.getPrototypeOf(current);
+      }
+      methodNames.forEach((methodName) => {
+        if (!this.hasOwnProperty(methodName) && methodName !== "init" && methodName !== "bindMethods") {
+          this[methodName] = this._sdk[methodName].bind(
+            this._sdk
+          );
+        }
+      });
+    }
+    /**
+     * Get the underlying SDK instance
+     */
+    get sdk() {
+      return this._sdk;
+    }
+    /**
+     * Get the configuration
+     */
+    get config() {
+      return this._sdk.config;
+    }
+    /**
+     * Version information
+     */
+    static version = "1.0.0";
+    get version() {
+      return Treasure2.version;
+    }
+    // Core methods
+    /**
+     * Add a record to a table
+     */
+    addRecord = (table, record2, success, error, options) => {
+      return this._sdk.addRecord(table, record2, success, error, options);
+    };
+    /**
+     * Track a custom event
+     */
+    trackEvent = (table, data, success, error) => {
+      return this._sdk.trackEvent(table, data, success, error);
+    };
+    /**
+     * Track a page view
+     */
+    trackPageview = (table, success, error, options) => {
+      return this._sdk.trackPageview(table, success, error, options);
+    };
+    /**
+     * Start tracking clicks
+     */
+    trackClicks = (options) => {
+      return this._sdk.trackClicks(options);
+    };
+    fetchUserSegments(tokenOrOptions, successCallback, errorCallback) {
+      return this._sdk.fetchUserSegments(
+        tokenOrOptions,
+        successCallback,
+        errorCallback
+      );
+    }
+    /**
+     * Fetch personalization data
+     */
+    fetchPersonalization = (config, data, successCallback, errorCallback) => {
+      return this._sdk.fetchPersonalization(
+        config,
+        data,
+        successCallback,
+        errorCallback
+      );
+    };
+    /**
+     * Apply an already-fetched personalization payload to the current page
+     */
+    applyPersonalization = (payload, options) => {
+      this._sdk.applyPersonalization(payload, options);
+    };
+    /**
+     * Fetch personalization offers and apply them to the current page
+     */
+    personalizePage = (config, data, successCallback, errorCallback) => {
+      this._sdk.personalizePage(config, data, successCallback, errorCallback);
+    };
+    /**
+     * Collect UTM parameters
+     */
+    collectUTMParameters = () => {
+      return this._sdk.collectUTMParameters();
+    };
+    /**
+     * Get UTM parameters
+     */
+    getUTMParameters = () => {
+      return this._sdk.getUTMParameters();
+    };
+    /**
+     * Set global or table-specific values
+     */
+    set = (table, property, value) => {
+      return this._sdk.set(table, property, value);
+    };
+    /**
+     * Get global or table-specific values
+     */
+    get = (table, key) => {
+      return this._sdk.get(table, key);
+    };
+    /**
+     * Set signed mode
+     */
+    setSignedMode = () => {
+      return this._sdk.setSignedMode();
+    };
+    /**
+     * Set anonymous mode
+     */
+    setAnonymousMode = (keepIdentifier) => {
+      return this._sdk.setAnonymousMode(keepIdentifier);
+    };
+    /**
+     * Check if in signed mode
+     */
+    inSignedMode = () => {
+      return this._sdk.inSignedMode();
+    };
+    /**
+     * Block events
+     */
+    blockEvents = () => {
+      return this._sdk.blockEvents();
+    };
+    /**
+     * Unblock events
+     */
+    unblockEvents = () => {
+      return this._sdk.unblockEvents();
+    };
+    /**
+     * Check if events are blocked
+     */
+    areEventsBlocked = () => {
+      return this._sdk.areEventsBlocked();
+    };
+    /**
+     * Reset UUID
+     */
+    resetUUID = () => {
+      return this._sdk.resetUUID();
+    };
+    /**
+     * Get track values
+     */
+    getTrackValues = () => {
+      return this._sdk.getTrackValues();
+    };
+    /**
+     * Get the personalization config
+     */
+    getPersonalizationConfig = () => {
+      return this._sdk.getPersonalizationConfig();
+    };
+    /**
+     * Set the personalization config (pass undefined to disable)
+     */
+    setPersonalizationConfig = (options) => {
+      return this._sdk.setPersonalizationConfig(options);
+    };
+    /**
+     * Get the configured write key
+     */
+    getWriteKey = () => {
+      return this._sdk.getWriteKey();
+    };
+    /**
+     * Set the write key
+     */
+    setWriteKey = (writeKey) => {
+      return this._sdk.setWriteKey(writeKey);
+    };
+    /**
+     * Collect conversion tracking tags
+     */
+    collectTags = (options) => {
+      return this._sdk.collectTags(options);
+    };
+    /**
+     * Fetch server-side cookie ID
+     */
+    fetchServerCookie = (success, error, forceFetch) => {
+      return this._sdk.fetchServerCookie(success, error, forceFetch);
+    };
+    /**
+     * Fetch Global ID
+     */
+    fetchGlobalID = (success, error, forceFetch, options) => {
+      return this._sdk.fetchGlobalID(success, error, forceFetch, options);
+    };
+  }
+  if (typeof window !== "undefined") {
+    replaceLoaderStub("Treasure", Treasure2);
+  }
+  return Treasure2;
+}();