@treasuredata/web-sdk 1.0.0

package/dist/td-sdk.esm.js

@@ -0,0 +1,3263 @@
+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"
+  );
+}
+function isValidUUID(uuid) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+}
+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");
+}
+const _validateRecord = validateRecord;
+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, version2) {
+  return {
+    td_version: () => version2,
+    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/${version2}`;
+      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(element2, attrName) {
+  if (typeof element2.hasAttribute === "function") {
+    return element2.hasAttribute(attrName);
+  }
+  return element2.getAttribute(attrName) !== null;
+}
+const element = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addEventListener,
+  getEventTarget,
+  hasAttribute,
+  htmlElementAsString,
+  htmlTreeAsString
+}, Symbol.toStringTag, { value: "Module" }));
+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, element2) {
+  try {
+    return document.querySelector(selector) === element2;
+  } catch {
+    return false;
+  }
+}
+function getTagName(element2) {
+  return element2.localName;
+}
+function tryDirectAnchor(element2) {
+  if (element2.id && isStableId(element2.id)) {
+    const selector = `#${CSS.escape(element2.id)}`;
+    if (validate(selector, element2)) return selector;
+  }
+  for (const attr of element2.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, element2)) return selector;
+    }
+  }
+  for (const cls of element2.classList) {
+    if (isStableClass(cls)) {
+      const selector = `.${CSS.escape(cls)}`;
+      if (isUnique(selector) && validate(selector, element2)) return selector;
+    }
+  }
+  const tag = getTagName(element2);
+  for (const cls of element2.classList) {
+    if (isStableClass(cls)) {
+      const selector = `${tag}.${CSS.escape(cls)}`;
+      if (isUnique(selector) && validate(selector, element2)) return selector;
+    }
+  }
+  const role = element2.getAttribute("role");
+  if (role && ARIA_LANDMARK_ROLES.includes(role)) {
+    const selector = `[role="${role}"]`;
+    if (isUnique(selector) && validate(selector, element2)) return selector;
+  }
+  if (SEMANTIC_TAGS.includes(tag)) {
+    if (isUnique(tag) && validate(tag, element2)) return tag;
+  }
+  return null;
+}
+function getNthOfTypeIndex(element2) {
+  const tag = getTagName(element2);
+  let index = 1;
+  let sibling = element2.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(element2) {
+  let ancestor = element2.parentElement;
+  while (ancestor && ancestor !== document.documentElement) {
+    const anchorSelector = tryDirectAnchor(ancestor);
+    if (anchorSelector) {
+      const relativePath = buildRelativePath(ancestor, element2);
+      const selector = `${anchorSelector} > ${relativePath}`;
+      if (validate(selector, element2)) return selector;
+    }
+    ancestor = ancestor.parentElement;
+  }
+  return null;
+}
+function buildFullPath(element2) {
+  const parts = [];
+  let current = element2;
+  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, element2)) return selector;
+  return null;
+}
+function generateSelector(element2) {
+  if (!element2 || element2 === document.documentElement || element2 === document.body) {
+    return element2 === document.body ? "body" : "html";
+  }
+  const direct = tryDirectAnchor(element2);
+  if (direct) return direct;
+  const anchored = tryAnchoredPath(element2);
+  if (anchored) return anchored;
+  return buildFullPath(element2) ?? element2.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(element2) {
+  if (element2.offsetWidth !== 0) {
+    return { width: element2.offsetWidth, height: element2.offsetHeight };
+  }
+  const rect = element2.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 escapeForInlineScript(value) {
+  return value.replace(/[<>\u2028\u2029/]/g, (char) => {
+    switch (char) {
+      case "<":
+        return "\\u003C";
+      case ">":
+        return "\\u003E";
+      case "/":
+        return "\\u002F";
+      case "\u2028":
+        return "\\u2028";
+      case "\u2029":
+        return "\\u2029";
+      default:
+        return char;
+    }
+  });
+}
+function createLoader(globalName, scriptUrl) {
+  const serializedMethods = escapeForInlineScript(
+    JSON.stringify(LOADER_METHODS)
+  );
+  const serializedScriptUrl = escapeForInlineScript(JSON.stringify(scriptUrl));
+  const serializedGlobalName = escapeForInlineScript(JSON.stringify(globalName));
+  return `!function(t,e){if(void 0===e[t]){e[t]=function(){e[t].clients.push(this),this._init=[Array.prototype.slice.call(arguments)]},e[t].clients=[];for(var r=function(t){return function(){return this["_"+t]=this["_"+t]||[],this["_"+t].push(Array.prototype.slice.call(arguments)),this}},s=${serializedMethods},c=0;c<s.length;c++){var o=s[c];e[t].prototype[o]=r(o)}var n=document.createElement("script");n.type="text/javascript",n.async=!0,n.src=("https:"===document.location.protocol?"https:":"http:")+${serializedScriptUrl};var i=document.getElementsByTagName("script")[0];i.parentNode.insertBefore(n,i)}}(${serializedGlobalName},this);`;
+}
+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 Treasure {
+  _sdk;
+  constructor(config) {
+    if (!(this instanceof Treasure)) {
+      return new Treasure(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 Treasure.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", Treasure);
+}
+function initSDK(globalName = "td") {
+  if (typeof window !== "undefined") {
+    replaceLoaderStub(globalName, Treasure);
+    if (!window[globalName]) {
+      window[globalName] = Treasure;
+    }
+  }
+}
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  const scripts = document.getElementsByTagName("script");
+  const currentScript = scripts[scripts.length - 1];
+  if (currentScript && currentScript.hasAttribute("data-auto-init")) {
+    const globalName = currentScript.getAttribute("data-global-name") || "td";
+    initSDK(globalName);
+  }
+}
+const version = "1.0.0";
+export {
+  BLOCKEVENTSCOOKIE,
+  DEFAULT_CONFIG,
+  SERVER_COOKIE_NAME,
+  SIGNEDMODECOOKIE,
+  Treasure,
+  _validateRecord,
+  adlHeaders,
+  clicks,
+  configure,
+  conversionAPI,
+  cookie,
+  createLoader,
+  createSDK,
+  Treasure as default,
+  element as elementUtils,
+  generateUUID$1 as generateUUID,
+  globalId,
+  globalIdAdlHeaders,
+  initSDK,
+  invariant$1 as invariant,
+  isLocalStorageAccessible,
+  isValidUUID,
+  pagePersonalize,
+  personalization,
+  processQueuedCalls,
+  record,
+  replaceLoaderStub,
+  serverCookie,
+  session,
+  setCookie,
+  track,
+  utm,
+  version
+};