surface_embed_v1.js

"use strict";
(() => {
  // src/lead/site-id.ts
  var ATTRIBUTE_VARIATIONS = [
    "siteId",
    "siteid",
    "site-id",
    "data-site-id"
  ];
  function getSiteIdFromScript(scriptElement) {
    if (!scriptElement) return null;
    for (const attr of ATTRIBUTE_VARIATIONS) {
      const value = scriptElement.getAttribute(attr);
      if (value) return value;
    }
    return null;
  }

  // src/constants.ts
  var SURFACE_USER_JOURNEY_COOKIE_NAME = "surface_journey_id";
  var SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME = "surface_recent_visit";
  var SURFACE_DOMAINS = [
    "https://forms.withsurface.com",
    "https://app.withsurface.com",
    "https://dev.withsurface.com"
  ];
  var LEAD_IDENTIFY_API = "https://forms.withsurface.com/api/v1/lead/identify";
  var USER_JOURNEY_TRACKING_API = "https://forms.withsurface.com/api/v1/lead/track";
  var EXTERNAL_FORM_API = "https://forms.withsurface.com/api/v1";
  var VALID_EMBED_TYPES = [
    "popup",
    "slideover",
    "widget",
    "inline",
    "input-trigger"
  ];
  var LEAD_DATA_TTL = 10 * 60 * 1e3;
  var JOURNEY_COOKIE_MAX_AGE = 5184e3;
  var RECENT_VISIT_COOKIE_MAX_AGE = 86400;

  // src/utils/hash.ts
  async function getHash(input) {
    const encoder = new TextEncoder();
    const data = encoder.encode(input);
    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
  }

  // src/lead/fingerprint.ts
  async function getBrowserFingerprint(environmentId3) {
    const fingerprint = {};
    fingerprint.deviceType = /Mobi|Android/i.test(navigator.userAgent) ? "Mobile" : "Desktop";
    fingerprint.screen = {
      width: screen.width,
      height: screen.height,
      colorDepth: screen.colorDepth
    };
    fingerprint.userAgent = navigator.userAgent;
    const userAgentData = navigator.userAgentData;
    fingerprint.browser = userAgentData?.brands || userAgentData?.uaList || [{ brand: "unknown", version: "unknown" }];
    fingerprint.os = userAgentData?.platform || "unknown";
    fingerprint.language = navigator.language;
    if (navigator.plugins != null) {
      fingerprint.plugins = Array.from(navigator.plugins).map((p) => p.name);
    }
    fingerprint.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
    fingerprint.environmentId = environmentId3;
    const fingerprintString = JSON.stringify(fingerprint);
    const id = await getHash(fingerprintString);
    return { ...fingerprint, id };
  }

  // src/runtime-config.ts
  var CUSTOM_DOMAIN_ATTRIBUTE = "data-custom-domain";
  var CONSENT_MODE_ATTRIBUTE = "data-consent-mode";
  var LANGUAGE_ATTRIBUTE = "data-lang";
  var LANGUAGE_PARAM = "surface-form-language";
  var LANGUAGE_TAG = /^[A-Za-z]{2,8}([-_][A-Za-z0-9]{1,8})*$/;
  function normalizeLanguageTag(value) {
    const trimmed = (value ?? "").trim();
    return LANGUAGE_TAG.test(trimmed) ? trimmed : null;
  }
  var DEFAULT_SURFACE_RUNTIME_CONFIG = {
    apiBaseUrl: EXTERNAL_FORM_API,
    leadIdentifyApi: LEAD_IDENTIFY_API,
    userJourneyTrackingApi: USER_JOURNEY_TRACKING_API,
    surfaceDomains: SURFACE_DOMAINS,
    customOrigin: null,
    waitForCookieConsent: false,
    language: null
  };
  var runtimeConfig = DEFAULT_SURFACE_RUNTIME_CONFIG;
  function normalizeCustomOrigin(value) {
    const trimmed = value.trim();
    if (!trimmed) return null;
    try {
      const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
      if (url.protocol !== "https:" || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
        return null;
      }
      return url.origin;
    } catch {
      return null;
    }
  }
  function resolveSurfaceRuntimeConfig(scriptElement) {
    const waitForCookieConsent = scriptElement?.hasAttribute(CONSENT_MODE_ATTRIBUTE) ?? false;
    const language = normalizeLanguageTag(scriptElement?.getAttribute(LANGUAGE_ATTRIBUTE));
    const customOrigin = normalizeCustomOrigin(
      scriptElement?.getAttribute(CUSTOM_DOMAIN_ATTRIBUTE) ?? ""
    );
    if (!customOrigin) return { ...DEFAULT_SURFACE_RUNTIME_CONFIG, waitForCookieConsent, language };
    const apiBaseUrl = `${customOrigin}/api/v1`;
    return {
      apiBaseUrl,
      leadIdentifyApi: `${apiBaseUrl}/lead/identify`,
      userJourneyTrackingApi: `${apiBaseUrl}/lead/track`,
      surfaceDomains: Array.from(/* @__PURE__ */ new Set([...SURFACE_DOMAINS, customOrigin])),
      customOrigin,
      waitForCookieConsent,
      language
    };
  }
  function initializeSurfaceRuntimeConfig(scriptElement) {
    runtimeConfig = resolveSurfaceRuntimeConfig(scriptElement);
    return runtimeConfig;
  }
  function getSurfaceRuntimeConfig() {
    return runtimeConfig;
  }

  // src/lead/identify.ts
  var environmentId = null;
  var identifyInProgress = false;
  function setEnvironmentId(id) {
    environmentId = id;
  }
  function isIdentifyInProgress() {
    return identifyInProgress;
  }
  function setLeadDataWithTTL(data) {
    const item = {
      ...data,
      expiry: (/* @__PURE__ */ new Date()).getTime() + LEAD_DATA_TTL
    };
    localStorage.setItem("surfaceLeadData", JSON.stringify(item));
  }
  function clearLeadData() {
    localStorage.removeItem("surfaceLeadData");
  }
  function getLeadDataWithTTL() {
    const itemStr = localStorage.getItem("surfaceLeadData");
    if (!itemStr) return null;
    try {
      const item = JSON.parse(itemStr);
      if ((/* @__PURE__ */ new Date()).getTime() > (item.expiry ?? 0)) {
        localStorage.removeItem("surfaceLeadData");
        return null;
      }
      return {
        leadId: item.leadId,
        leadSessionId: item.leadSessionId,
        fingerprint: item.fingerprint,
        landingPageUrl: item.landingPageUrl,
        expiry: item.expiry
      };
    } catch (error) {
      console.error("Error parsing lead data from localStorage:", error);
      return null;
    }
  }
  async function identifyLead(envId, config = getSurfaceRuntimeConfig()) {
    if (identifyInProgress) {
      return waitForCachedData();
    }
    const cached2 = getLeadDataWithTTL();
    if (cached2?.leadSessionId && cached2?.fingerprint) {
      return cached2;
    }
    identifyInProgress = true;
    try {
      const fingerprint = await getBrowserFingerprint(envId);
      const parentUrl = new URL(window.location.href);
      const response = await fetch(config.leadIdentifyApi, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          fingerprint: fingerprint.id,
          environmentId: envId,
          source: "website",
          sourceURL: parentUrl.href,
          sourceURLDomain: parentUrl.hostname,
          sourceURLPath: parentUrl.pathname,
          sourceUrlSearchParams: parentUrl.search,
          leadId: cached2?.leadId,
          sessionIdFromParams: cached2?.leadSessionId
        })
      });
      const jsonData = await response.json();
      if (response.ok && jsonData.data?.data) {
        const leadId = jsonData.data.data.leadId || null;
        const leadSessionId = jsonData.data.data.sessionId || null;
        setLeadDataWithTTL({
          leadId,
          leadSessionId,
          fingerprint: fingerprint.id,
          landingPageUrl: window.location.href
        });
        return { leadId, leadSessionId, fingerprint: fingerprint.id };
      }
    } catch (error) {
      console.error("Error identifying lead:", error);
    } finally {
      identifyInProgress = false;
    }
    return null;
  }
  async function waitForCachedData() {
    const maxWait = 5e3;
    const interval = 100;
    const start = Date.now();
    while (identifyInProgress && Date.now() - start < maxWait) {
      await new Promise((r) => setTimeout(r, interval));
      const cached2 = getLeadDataWithTTL();
      if (cached2?.leadSessionId && cached2?.fingerprint) {
        return cached2;
      }
    }
    return null;
  }

  // src/consent/consent.ts
  var SURFACE_CONSENT_MESSAGE_TYPE = "surface:consent";
  var SURFACE_CONSENT_EVENT = "surface:consent";
  var normalize = (granted) => ({
    adTracking: granted?.adTracking === true,
    surfaceAnalytics: granted?.surfaceAnalytics === true,
    cookieTracking: granted?.cookieTracking === true
  });
  var consent = typeof window !== "undefined" && window.__SURFACE_CONSENT__ ? normalize(window.__SURFACE_CONSENT__) : null;
  var onChange = null;
  var dispatching = false;
  if (typeof window !== "undefined") {
    window.addEventListener(SURFACE_CONSENT_EVENT, (event) => {
      if (dispatching) return;
      consent = normalize(event.detail);
      onChange?.();
    });
  }
  var getSurfaceConsent = () => consent;
  var onSurfaceConsentChange = (callback) => {
    onChange = callback;
  };
  var setSurfaceConsent = (granted) => {
    consent = normalize(granted);
    if (typeof window !== "undefined") {
      window.__SURFACE_CONSENT__ = { ...consent };
      dispatching = true;
      try {
        window.dispatchEvent(new CustomEvent(SURFACE_CONSENT_EVENT, { detail: { ...consent } }));
      } finally {
        dispatching = false;
      }
    }
    onChange?.();
  };

  // src/utils/debug.ts
  var cached = null;
  function isDebugMode() {
    if (cached !== null) return cached;
    cached = window.location.search.includes("surfaceDebug=true");
    return cached;
  }

  // src/utils/logger.ts
  function createLogger(prefix) {
    const fmt = (msg) => {
      if (typeof msg === "string") {
        return `${prefix} :: ${msg}`;
      }
      return {
        prefix,
        ...msg
      };
    };
    return {
      info: (msg) => {
        if (isDebugMode()) console.log(fmt(msg));
      },
      warn: (msg) => console.warn(fmt(msg)),
      error: (msg) => console.error(fmt(msg))
    };
  }

  // src/utils/cookies.ts
  function parseCookies() {
    const cookies = {};
    if (typeof document === "undefined") return cookies;
    document.cookie.split(";").forEach((cookie) => {
      const trimmed = cookie.trim();
      const eqIndex = trimmed.indexOf("=");
      if (eqIndex === -1) return;
      const key = trimmed.substring(0, eqIndex);
      const value = trimmed.substring(eqIndex + 1);
      if (!key || value === void 0) return;
      try {
        cookies[key] = decodeURIComponent(value);
      } catch {
        cookies[key] = value;
      }
    });
    return cookies;
  }
  function setCookie(name, value, options = {}) {
    if (typeof document === "undefined") return;
    const encoded = encodeURIComponent(value);
    const path = options.path || "/";
    const maxAge = options.maxAge ?? 604800;
    const sameSite = options.sameSite || "lax";
    const domainAttr = options.domain ? `; domain=${options.domain}` : "";
    document.cookie = `${name}=${encoded}; path=${path}; max-age=${maxAge}; samesite=${sameSite}${domainAttr}`;
  }
  function getCookie(name) {
    const cookies = parseCookies();
    return cookies[name] || null;
  }
  function deleteCookie(name, options = {}) {
    if (typeof document === "undefined") return;
    const domainAttr = options.domain ? `; domain=${options.domain}` : "";
    document.cookie = `${name}=; path=/; max-age=0; samesite=lax${domainAttr}`;
  }

  // src/utils/url.ts
  function getUrlParams() {
    const params = {};
    const searchParams = new URLSearchParams(window.location.search);
    for (const [key, value] of searchParams) {
      params[key] = value;
    }
    return params;
  }

  // src/utils/route-observer.ts
  var callbacks = [];
  var installed = false;
  var currentUrl = "";
  function onRouteChange(callback) {
    callbacks.push(callback);
    if (!installed) {
      install();
      installed = true;
    }
  }
  function notify() {
    const newUrl = window.location.href;
    if (newUrl === currentUrl) return;
    currentUrl = newUrl;
    callbacks.forEach((cb) => cb(newUrl));
  }
  function install() {
    currentUrl = window.location.href;
    window.addEventListener("popstate", notify);
    const origPush = history.pushState;
    const origReplace = history.replaceState;
    history.pushState = function(...args) {
      origPush.apply(history, args);
      setTimeout(notify, 0);
    };
    history.replaceState = function(...args) {
      origReplace.apply(history, args);
      setTimeout(notify, 0);
    };
  }

  // src/conversions/providers.ts
  var w = () => window;
  var ensureTwq = (pixelId) => {
    const win = w();
    if (!win.twq) {
      const s = win.twq = function(...args) {
        s.exe ? s.exe.apply(s, args) : s.queue.push(args);
      };
      s.version = "1.1";
      s.queue = [];
      const el = document.createElement("script");
      el.async = true;
      el.src = "https://static.ads-twitter.com/uwt.js";
      document.head.appendChild(el);
    }
    win.twq("config", pixelId);
  };
  var ensureFbq = (pixelId) => {
    const win = w();
    if (!win.fbq) {
      const n = win.fbq = function(...args) {
        n.callMethod ? n.callMethod.apply(n, args) : n.queue.push(args);
      };
      if (!win._fbq) win._fbq = n;
      n.push = n;
      n.loaded = true;
      n.version = "2.0";
      n.queue = [];
      const el = document.createElement("script");
      el.async = true;
      el.src = "https://connect.facebook.net/en_US/fbevents.js";
      document.head.appendChild(el);
    }
    win.fbq("init", pixelId);
  };
  var ensureOaiq = (pixelId) => {
    const win = w();
    if (!win.oaiq) {
      const q = win.oaiq = function(...args) {
        q.q.push(args);
      };
      q.q = [];
      const el = document.createElement("script");
      el.async = true;
      el.src = "https://bzrcdn.openai.com/sdk/oaiq.min.js";
      document.head.appendChild(el);
    }
    win.oaiq("init", { pixelId });
  };
  var ensureGtag = (measurementId) => {
    const win = w();
    if (!win.gtag) {
      win.dataLayer = win.dataLayer || [];
      win.gtag = function(...args) {
        win.dataLayer.push(args);
      };
      const el = document.createElement("script");
      el.async = true;
      el.src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`;
      document.head.appendChild(el);
      win.gtag("js", /* @__PURE__ */ new Date());
    }
    win.gtag("config", measurementId, { send_page_view: false });
  };
  var ensureLintrk = (partnerId) => {
    const win = w();
    if (!win.lintrk) {
      win._linkedin_partner_id = partnerId;
      const l = win.lintrk = function(a, b) {
        l.q.push([a, b]);
      };
      l.q = [];
      const el = document.createElement("script");
      el.async = true;
      el.src = "https://snap.licdn.com/li.lms-analytics/insight.min.js";
      document.head.appendChild(el);
    }
    win._linkedin_data_partner_ids = win._linkedin_data_partner_ids || [];
    if (!win._linkedin_data_partner_ids.includes(partnerId)) {
      win._linkedin_data_partner_ids.push(partnerId);
    }
  };
  var fireConversion = (provider, event, ctx) => {
    const win = w();
    try {
      switch (provider) {
        case "x":
          ensureTwq(event.pixel_id);
          win.twq("event", event.event_id, {
            conversion_id: ctx.response_id,
            ...ctx.twclid ? { twclid: ctx.twclid } : {},
            ...ctx.email ? { email_address: ctx.email } : {}
          });
          return true;
        case "meta":
          ensureFbq(event.pixel_id);
          win.fbq("track", event.event_name, {}, { eventID: ctx.response_id });
          return true;
        case "openai":
          ensureOaiq(event.pixel_id);
          win.oaiq("measure", event.event_name, { type: "customer_action" }, { event_id: ctx.response_id });
          return true;
        case "ga4":
          ensureGtag(event.measurement_id);
          win.gtag("event", event.event_name, {
            transaction_id: ctx.response_id,
            send_to: event.measurement_id
          });
          return true;
        case "linkedin":
          ensureLintrk(event.partner_id);
          win.lintrk("track", { conversion_id: event.conversion_id });
          return true;
        default:
          return false;
      }
    } catch {
      return false;
    }
  };

  // src/conversions/conversion-listener.ts
  var CONVERSION_MESSAGE_TYPE = "surface:conversion";
  var CONVERSION_ACK_TYPE = "surface:conversion:ack";
  var VALID_PROVIDERS = ["x", "meta", "openai", "ga4", "linkedin"];
  var firedIds = /* @__PURE__ */ new Set();
  var isConversionMessage = (data) => !!data && data.type === CONVERSION_MESSAGE_TYPE && typeof data.id === "string" && VALID_PROVIDERS.includes(data.provider) && !!data.event && typeof data.response_id === "string";
  var handleConversionMessage = (event, log3) => {
    const data = event.data;
    if (!isConversionMessage(data)) return;
    const ack = () => {
      try {
        event.source?.postMessage(
          { type: CONVERSION_ACK_TYPE, id: data.id },
          event.origin
        );
      } catch {
      }
    };
    if (firedIds.has(data.id)) {
      ack();
      return;
    }
    firedIds.add(data.id);
    const fired = fireConversion(data.provider, data.event, {
      response_id: data.response_id,
      email: data.email,
      twclid: data.twclid,
      fbclid: data.fbclid,
      gclid: data.gclid,
      li_fat_id: data.li_fat_id
    });
    log3.info({
      message: "Conversion handled",
      response: { provider: data.provider, responseId: data.response_id, fired }
    });
    ack();
  };

  // src/embed/popup-dimensions.ts
  var DEFAULT_DIMENSIONS = {
    width: "calc(100% - 80px)",
    height: "calc(100% - 80px)"
  };
  var SIZE_PRESETS = {
    small: { width: "500px", height: "80%" },
    medium: { width: "70%", height: "80%" },
    large: DEFAULT_DIMENSIONS
  };
  function getPopupDimensions(size) {
    if (typeof size === "string" && SIZE_PRESETS[size]) {
      return { ...SIZE_PRESETS[size] };
    }
    if (typeof size === "object" && size !== null && ("width" in size || "height" in size)) {
      return {
        width: size.width || DEFAULT_DIMENSIONS.width,
        height: size.height || DEFAULT_DIMENSIONS.height
      };
    }
    return { ...DEFAULT_DIMENSIONS };
  }

  // src/embed/inline-layout.ts
  var INLINE_EMBED_PARAM = "surfaceEmbed";
  var INLINE_CAPS_PARAM = "surfaceTagCaps";
  var INLINE_LAYOUT_CAP = "inline-layout";
  var INLINE_LAYOUT_MESSAGE_TYPE = "SURFACE_INLINE_LAYOUT";
  var INLINE_OVERLAY_DISMISSED_MESSAGE_TYPE = "SURFACE_INLINE_OVERLAY_DISMISSED";
  var MAX_STRIP_HEIGHT = 4e3;
  var MOBILE_MAX_WIDTH = 480;
  var supportsTopLayer = (el) => typeof el.showPopover === "function";
  var entries = /* @__PURE__ */ new Map();
  function registerInlineIframe(embed, wrapper, iframe) {
    const trap = supportsTopLayer(wrapper) ? null : detectFixedTrap(wrapper);
    if (trap) warnTrap(embed, trap);
    entries.set(iframe, {
      embed,
      wrapper,
      iframe,
      trap,
      layout: null,
      overlayKind: null,
      overlaySession: 0,
      lastStripHeight: null,
      placeholder: null,
      closeBox: null,
      savedWrapperCss: "",
      savedIframeCss: "",
      prevBodyOverflow: "",
      prevFocus: null,
      cleanup: []
    });
  }
  function findInlineEntryForSource(source) {
    releaseDetachedInlineOverlays();
    for (const entry of entries.values()) {
      if (entry.iframe.contentWindow === source) return entry;
    }
    return null;
  }
  function handleInlineLayoutMessage(event) {
    const data = event.data;
    if (!data || data.type !== INLINE_LAYOUT_MESSAGE_TYPE || data.sender !== "surface_form") return;
    const entry = findInlineEntryForSource(event.source);
    if (!entry) return;
    if (data.layout === "overlay") {
      enterOverlay(entry);
      return;
    }
    if (data.layout === "strip") {
      const height = Number(data.height);
      if (!Number.isFinite(height) || height < 1) {
        entry.embed.log.warn({ message: "Ignoring inline strip layout with invalid height", response: { height: data.height } });
        return;
      }
      applyStrip(entry, Math.min(MAX_STRIP_HEIGHT, Math.round(height)));
    }
  }
  function releaseDetachedInlineOverlays() {
    for (const entry of entries.values()) {
      if (entry.iframe.isConnected) continue;
      if (entry.layout === "overlay") exitOverlay(entry);
      entries.delete(entry.iframe);
    }
  }
  function releaseWhenDetached(entry) {
    if (typeof MutationObserver === "undefined") return;
    const observer = new MutationObserver(() => {
      if (entry.iframe.isConnected) return;
      exitOverlay(entry);
      entries.delete(entry.iframe);
    });
    observer.observe(document.documentElement, { childList: true, subtree: true });
    entry.cleanup.push(() => observer.disconnect());
  }
  function keepFocusInside(entry) {
    const onFocusIn = (event) => {
      if (entry.wrapper.contains(event.target)) return;
      entry.iframe.focus();
    };
    document.addEventListener("focusin", onFocusIn);
    entry.cleanup.push(() => document.removeEventListener("focusin", onFocusIn));
  }
  function warnTrap(embed, trap) {
    embed.log.warn({
      message: "Inline embed ancestor creates a containing block for position:fixed; the compact pop-out will use the Fullscreen API on this page",
      response: trap
    });
  }
  var TRANSFORM_PROPERTIES = ["transform", "translate", "rotate", "scale", "filter", "backdropFilter", "perspective"];
  var TRAPPING_WILL_CHANGE = ["transform", "perspective", "filter", "backdrop-filter"];
  var TRAPPING_CONTAIN = ["paint", "layout", "strict", "content"];
  function detectFixedTrap(start) {
    for (let el = start; el && el !== document.documentElement; el = el.parentElement) {
      const style = getComputedStyle(el);
      for (const property of TRANSFORM_PROPERTIES) {
        const value = style[property];
        if (value && value !== "none") return { element: describe(el), property, value };
      }
      const willChange = (style.willChange ?? "").split(",").map((token) => token.trim());
      if (willChange.some((token) => TRAPPING_WILL_CHANGE.includes(token))) {
        return { element: describe(el), property: "willChange", value: style.willChange };
      }
      const contain = (style.contain ?? "").split(/\s+/);
      if (contain.some((token) => TRAPPING_CONTAIN.includes(token))) {
        return { element: describe(el), property: "contain", value: style.contain };
      }
      if (style.position !== "static" && style.zIndex !== "auto" && style.zIndex !== "") {
        return { element: describe(el), property: "zIndex", value: style.zIndex };
      }
      if (style.opacity !== "" && Number(style.opacity) < 1) {
        return { element: describe(el), property: "opacity", value: style.opacity };
      }
      if (style.isolation === "isolate") return { element: describe(el), property: "isolation", value: "isolate" };
      if (style.mixBlendMode && style.mixBlendMode !== "normal") {
        return { element: describe(el), property: "mixBlendMode", value: style.mixBlendMode };
      }
    }
    return null;
  }
  function describe(el) {
    const id = el.id ? `#${el.id}` : "";
    const classes = el.classList.length ? `.${Array.from(el.classList).join(".")}` : "";
    return `${el.tagName.toLowerCase()}${id}${classes}`;
  }
  function applyStrip(entry, height) {
    if (entry.layout === "overlay") exitOverlay(entry);
    entry.lastStripHeight = height;
    entry.iframe.style.height = `${height}px`;
    entry.layout = "strip";
  }
  function enterOverlay(entry) {
    if (entry.layout === "overlay") return;
    const { wrapper, iframe } = entry;
    entry.layout = "overlay";
    entry.savedWrapperCss = wrapper.style.cssText;
    entry.savedIframeCss = iframe.style.cssText;
    entry.prevFocus = document.activeElement;
    entry.overlaySession += 1;
    releaseWhenDetached(entry);
    keepFocusInside(entry);
    if (supportsTopLayer(wrapper)) {
      enterTopLayer(entry);
      return;
    }
    const trap = detectFixedTrap(wrapper);
    if (trap && !entry.trap) warnTrap(entry.embed, trap);
    entry.trap = trap;
    if (entry.trap) {
      enterFullscreen(entry);
      return;
    }
    entry.overlayKind = "fixed";
    keepStripSpace(entry);
    entry.prevBodyOverflow = document.body.style.overflow;
    document.body.style.overflow = "hidden";
    applyOverlayGeometry(entry);
    wrapper.style.position = "fixed";
    addDismissHandlers(entry, { backdrop: true, escape: true });
    reveal(entry);
  }
  function enterTopLayer(entry) {
    const { wrapper } = entry;
    entry.overlayKind = "topLayer";
    keepStripSpace(entry);
    entry.prevBodyOverflow = document.body.style.overflow;
    document.body.style.overflow = "hidden";
    wrapper.setAttribute("popover", "manual");
    applyOverlayGeometry(entry);
    Object.assign(wrapper.style, { position: "fixed", inset: "0", border: "0", overflow: "visible", color: "inherit" });
    wrapper.showPopover();
    addDismissHandlers(entry, { backdrop: true, escape: true });
    reveal(entry);
  }
  function enterFullscreen(entry) {
    const { wrapper } = entry;
    if (typeof wrapper.requestFullscreen !== "function") {
      enterExpanded(entry);
      return;
    }
    entry.overlayKind = "fullscreen";
    keepStripSpace(entry);
    const onFullscreenChange = () => {
      if (document.fullscreenElement !== wrapper) dismissOverlay(entry);
    };
    document.addEventListener("fullscreenchange", onFullscreenChange);
    entry.cleanup.push(() => document.removeEventListener("fullscreenchange", onFullscreenChange));
    const session = entry.overlaySession;
    const stale = () => entry.layout !== "overlay" || entry.overlaySession !== session;
    wrapper.requestFullscreen().then(
      () => {
        if (stale()) {
          if (document.fullscreenElement === wrapper) document.exitFullscreen().catch(() => {
          });
          return;
        }
        applyOverlayGeometry(entry);
        addDismissHandlers(entry, { backdrop: true, escape: false });
        reveal(entry);
      },
      (error) => {
        if (stale()) return;
        entry.embed.log.warn({ message: "Fullscreen request rejected; expanding the inline embed in place", response: { error: String(error) } });
        runCleanup(entry);
        entry.placeholder?.remove();
        entry.placeholder = null;
        enterExpanded(entry);
      }
    );
  }
  function enterExpanded(entry) {
    entry.overlayKind = "expanded";
    entry.wrapper.style.position = "relative";
    entry.iframe.style.height = `${Math.round(window.innerHeight * 0.85)}px`;
    entry.iframe.scrollIntoView({ block: "nearest" });
    addDismissHandlers(entry, { backdrop: false, escape: true });
  }
  function keepStripSpace(entry) {
    const height = entry.wrapper.getBoundingClientRect().height;
    if (height <= 0) return;
    const placeholder = document.createElement("div");
    placeholder.style.height = `${height}px`;
    entry.wrapper.insertAdjacentElement("afterend", placeholder);
    entry.placeholder = placeholder;
  }
  function applyOverlayGeometry(entry) {
    const { wrapper, iframe } = entry;
    wrapper.setAttribute("role", "dialog");
    wrapper.setAttribute("aria-modal", "true");
    Object.assign(wrapper.style, {
      top: "0",
      left: "0",
      width: "100%",
      height: "100%",
      margin: "0",
      padding: "0",
      zIndex: "99999",
      boxSizing: "border-box",
      background: "rgba(0,0,0,0.5)",
      display: "flex",
      alignItems: "center",
      justifyContent: "center",
      opacity: "0",
      transition: "opacity 0.15s ease"
    });
    const mobile = window.innerWidth <= MOBILE_MAX_WIDTH;
    const dimensions = mobile ? { width: "100%", height: "100%" } : getPopupDimensions("large");
    Object.assign(iframe.style, {
      width: dimensions.width,
      height: dimensions.height,
      maxWidth: "100%",
      maxHeight: "100%",
      border: "0",
      borderRadius: mobile ? "0" : "15px",
      background: "#fff"
    });
  }
  function reveal(entry) {
    const timer = setTimeout(() => {
      entry.wrapper.style.opacity = "1";
      entry.iframe.focus();
    }, 50);
    entry.cleanup.push(() => clearTimeout(timer));
  }
  function addDismissHandlers(entry, handlers) {
    const { wrapper } = entry;
    const closeBox = document.createElement("button");
    closeBox.type = "button";
    closeBox.setAttribute("aria-label", "Close");
    closeBox.textContent = "\xD7";
    Object.assign(closeBox.style, {
      appearance: "none",
      border: "0",
      padding: "0",
      margin: "0",
      font: "inherit",
      position: "absolute",
      top: "12px",
      right: "16px",
      zIndex: "100000",
      width: "32px",
      height: "32px",
      borderRadius: "50%",
      background: "#fff",
      color: "#000",
      display: "flex",
      alignItems: "center",
      justifyContent: "center",
      fontSize: "22px",
      lineHeight: "1",
      cursor: "pointer",
      opacity: "0.9",
      userSelect: "none"
    });
    const dismiss = () => dismissOverlay(entry);
    closeBox.addEventListener("click", dismiss);
    wrapper.appendChild(closeBox);
    entry.closeBox = closeBox;
    if (handlers.backdrop) {
      const onBackdropClick = (event) => {
        if (event.target === wrapper) dismiss();
      };
      wrapper.addEventListener("click", onBackdropClick);
      entry.cleanup.push(() => wrapper.removeEventListener("click", onBackdropClick));
    }
    if (handlers.escape) {
      const onKeydown = (event) => {
        if (event.key === "Escape" && entry.layout === "overlay") dismiss();
      };
      document.addEventListener("keydown", onKeydown);
      entry.cleanup.push(() => document.removeEventListener("keydown", onKeydown));
    }
  }
  function runCleanup(entry) {
    entry.cleanup.forEach((fn) => fn());
    entry.cleanup = [];
  }
  function exitOverlay(entry) {
    const { wrapper, iframe } = entry;
    const kind = entry.overlayKind;
    runCleanup(entry);
    if (kind === "fullscreen" && document.fullscreenElement === wrapper) {
      document.exitFullscreen().catch(() => {
      });
    }
    if (kind === "topLayer") {
      try {
        wrapper.hidePopover();
      } catch {
      }
      wrapper.removeAttribute("popover");
    }
    entry.closeBox?.remove();
    entry.closeBox = null;
    entry.placeholder?.remove();
    entry.placeholder = null;
    wrapper.style.cssText = entry.savedWrapperCss;
    iframe.style.cssText = entry.savedIframeCss;
    wrapper.removeAttribute("role");
    wrapper.removeAttribute("aria-modal");
    if (kind === "fixed" || kind === "topLayer") document.body.style.overflow = entry.prevBodyOverflow;
    entry.prevFocus?.focus?.();
    entry.prevFocus = null;
    if (entry.lastStripHeight !== null) iframe.style.height = `${entry.lastStripHeight}px`;
    entry.layout = entry.lastStripHeight === null ? null : "strip";
    entry.overlayKind = null;
  }
  function dismissOverlay(entry) {
    if (entry.layout !== "overlay") return;
    exitOverlay(entry);
    entry.embed.store.postToSurfaceIframe(entry.iframe, {
      type: INLINE_OVERLAY_DISMISSED_MESSAGE_TYPE,
      sender: "surface_tag"
    });
  }

  // src/store/message-listener.ts
  function initializeMessageListener(store) {
    const handleMessage = (event) => {
      const surfaceDomains = store.surfaceDomains ?? SURFACE_DOMAINS;
      if (!event.origin || !surfaceDomains.includes(event.origin)) {
        return;
      }
      if (event.data?.type === "surface:conversion") {
        handleConversionMessage(event, store.log);
        return;
      }
      if (event.data?.type === INLINE_LAYOUT_MESSAGE_TYPE) {
        handleInlineLayoutMessage(event);
        return;
      }
      if (event.data.type === "SEND_DATA") {
        store.sendPayloadToIframes("STORE_UPDATE");
        store.sendConsentToIframes();
        if (store.environmentId && store.cookieTrackingAllowed()) {
          store.identifyAndPushLeadData();
        } else {
          store.sendPayloadToIframes("LEAD_DATA_UPDATE");
        }
      }
      if (event.data.event === "CLEAR_USER_JOURNEY_DATA") {
        store.log.info({ message: "Clearing user journey" });
        store.clearUserJourney();
      }
    };
    if (typeof window === "undefined") return;
    window.addEventListener("message", handleMessage);
  }

  // src/store/journey-cookies.ts
  function getJourneyCookieDomain() {
    const hostname = window.location?.hostname ?? "";
    if (!hostname || !hostname.includes(".")) return void 0;
    const parts = hostname.split(".");
    return "." + (parts.length === 2 ? hostname : parts.slice(1).join("."));
  }
  function refreshJourneyCookie(journeyId) {
    if (!journeyId) return;
    setCookie(SURFACE_USER_JOURNEY_COOKIE_NAME, journeyId, {
      maxAge: JOURNEY_COOKIE_MAX_AGE,
      sameSite: "lax",
      domain: getJourneyCookieDomain()
    });
  }
  function getExistingJourneyId() {
    return getCookie(SURFACE_USER_JOURNEY_COOKIE_NAME);
  }

  // src/store/user-journey.ts
  function getBrowserReferrer() {
    return typeof document === "undefined" ? "" : document.referrer || "";
  }
  function getSurfaceLeadDataSafely() {
    try {
      if (typeof localStorage === "undefined") return null;
      return getLeadDataWithTTL();
    } catch {
      return null;
    }
  }
  function createPageViewEvent(url, environmentId3) {
    return {
      data: {
        type: "page_view",
        payload: {
          url,
          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
          // Native referrer stays fixed to the hard-navigation source across SPA routes.
          referrer: getBrowserReferrer()
        }
      },
      metadata: {
        ...environmentId3 ? { environmentId: environmentId3 } : {},
        ...getSurfaceLeadDataSafely() ?? {}
      }
    };
  }
  function initializeUserJourneyTracking(environmentId3, log3, getJourneyId, setJourneyId, config = getSurfaceRuntimeConfig(), isAllowed = () => true) {
    try {
      if (typeof window === "undefined") return;
      const existingId = getExistingJourneyId();
      setJourneyId(existingId);
      log3.info({ message: "Existing journey ID", response: { id: existingId || "none" } });
      const currentUrl2 = window.location.href;
      const recentVisit = getCookie(SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME);
      if (recentVisit === currentUrl2) {
        log3.info({ message: "Skipping duplicate page view (same as recent visit)" });
        return;
      }
      trackToRedis(
        createPageViewEvent(currentUrl2, environmentId3),
        log3,
        getJourneyId,
        setJourneyId,
        config,
        isAllowed
      );
      setCookie(SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME, currentUrl2, {
        maxAge: RECENT_VISIT_COOKIE_MAX_AGE,
        sameSite: "lax",
        domain: getJourneyCookieDomain()
      });
      log3.info({ message: "User journey tracking initialized" });
    } catch (error) {
      log3.error({ message: "Error initializing user journey tracking", error });
    }
  }
  var journeyCreation = Promise.resolve();
  function trackToRedis(event, log3, getJourneyId, setJourneyId, config = getSurfaceRuntimeConfig(), isAllowed = () => true) {
    const send = () => isAllowed() ? sendToRedis(event, log3, getJourneyId, setJourneyId, config) : Promise.resolve(null);
    if (getJourneyId()) return send();
    const sent = journeyCreation.then(send, send);
    journeyCreation = sent;
    return sent;
  }
  async function sendToRedis(event, log3, getJourneyId, setJourneyId, config) {
    try {
      const journeyId = getJourneyId();
      const payload = { ...event };
      if (journeyId) payload.id = journeyId;
      log3.info({ message: "Tracking to Redis", response: payload });
      if (journeyId && typeof navigator !== "undefined" && navigator.sendBeacon) {
        const blob = new Blob([JSON.stringify(payload)], {
          type: "text/plain"
        });
        const sent = navigator.sendBeacon(config.userJourneyTrackingApi, blob);
        if (sent) {
          refreshJourneyCookie(journeyId);
          log3.info({ message: "Tracking sent via sendBeacon", response: { sent } });
          return { success: true };
        }
        log3.warn({ message: "sendBeacon failed, falling back to fetch" });
      }
      const response = await fetch(config.userJourneyTrackingApi, {
        method: "POST",
        headers: { "Content-Type": "text/plain" },
        body: JSON.stringify(payload),
        priority: "low"
      });
      if (!response.ok) {
        log3.warn({ message: "Tracking API returned status", response: { status: response.status } });
        return null;
      }
      const data = await response.json();
      if (data?.data?.id) {
        setJourneyId(data.data.id);
        log3.info({ message: "Journey ID stored", response: { id: data.data.id } });
      }
      refreshJourneyCookie(getJourneyId());
      return data;
    } catch (error) {
      log3.error({ message: "Error tracking to Redis", error });
      return null;
    }
  }
  function updateUserJourneyOnRouteChange(environmentId3, newUrl, log3, getJourneyId, setJourneyId, config = getSurfaceRuntimeConfig(), isAllowed = () => true) {
    try {
      if (typeof window === "undefined") return;
      const currentUrl2 = newUrl || window.location.href;
      const recentVisit = getCookie(SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME);
      if (recentVisit === currentUrl2) {
        log3.info({ message: "Skipping duplicate page view on route change" });
        return;
      }
      trackToRedis(
        createPageViewEvent(currentUrl2, environmentId3),
        log3,
        getJourneyId,
        setJourneyId,
        config,
        isAllowed
      );
      setCookie(SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME, currentUrl2, {
        maxAge: RECENT_VISIT_COOKIE_MAX_AGE,
        sameSite: "lax",
        domain: getJourneyCookieDomain()
      });
      log3.info({ message: "User journey updated on route change", response: { url: currentUrl2 } });
    } catch (error) {
      log3.error({ message: "Error updating user journey on route change", error });
    }
  }
  function clearUserJourney(log3, setJourneyId) {
    const domain = getJourneyCookieDomain();
    deleteCookie(SURFACE_USER_JOURNEY_COOKIE_NAME, { domain });
    deleteCookie(SURFACE_USER_JOURNEY_RECENT_VISIT_COOKIE_NAME, { domain });
    setJourneyId(null);
    log3.info({ message: "User journey cleared" });
  }

  // src/store/store.ts
  var SurfaceStore = class {
    constructor(environmentId3 = null, config = getSurfaceRuntimeConfig()) {
      this.journeyStarted = false;
      // Embeds with a language of their own; their iframes get it instead of the page's.
      this.embeds = [];
      this.windowUrl = new URL(window.location.href).toString();
      this.origin = new URL(window.location.href).origin.toString();
      this.referrer = document.referrer || "";
      this.cookies = {};
      this.metadata = {};
      this.urlParams = {};
      this.partialFilledData = {};
      this.validEmbedTypes = VALID_EMBED_TYPES;
      this.debugMode = isDebugMode();
      this.config = config;
      this.surfaceDomains = config.surfaceDomains;
      this.userJourneyId = null;
      this.userJourney = [];
      this.environmentId = environmentId3;
      this.language = config.language;
      this.log = createLogger("Surface Store");
      this.cachedIdentifyData = this.cookieTrackingAllowed() ? getLeadDataWithTTL() : null;
      initializeMessageListener(this);
      if ((this.cachedIdentifyData || !isIdentifyInProgress()) && !this.isCurrentOriginSurfaceDomain()) {
        if (this.cookieTrackingAllowed()) this.startJourneyTracking();
        this.setupRouteChangeDetection();
      }
      const pushInitialData = () => {
        if (!this.hasSurfaceIframe()) return;
        this.sendPayloadToIframes("STORE_UPDATE");
        if (!this.cookieTrackingAllowed()) {
          this.sendPayloadToIframes("LEAD_DATA_UPDATE");
        } else if (this.environmentId) {
          this.identifyAndPushLeadData();
        } else if (getLeadDataWithTTL()) {
          this.sendPayloadToIframes("LEAD_DATA_UPDATE");
        }
      };
      if (document.readyState === "loading") {
        document.addEventListener("DOMContentLoaded", pushInitialData);
      } else {
        setTimeout(pushInitialData, 0);
      }
    }
    hasSurfaceIframe() {
      return Array.from(document.querySelectorAll("iframe")).some((iframe) => {
        try {
          return this.surfaceDomains.includes(new URL(iframe.src).origin);
        } catch {
          return false;
        }
      });
    }
    isCurrentOriginSurfaceDomain() {
      const origin = window.location?.origin ?? "";
      return this.surfaceDomains.includes(origin);
    }
    /**
     * Whether this tag may recognise the visitor: read or write the lead cache,
     * the journey cookies and the page's cookies. Always true unless the script
     * was loaded with `data-consent-mode`, in which case the page's banner has to
     * grant `cookieTracking` first.
     */
    cookieTrackingAllowed() {
      return !this.config.waitForCookieConsent || getSurfaceConsent()?.cookieTracking === true;
    }
    /** Re-evaluates host-side tracking after the page reports a consent change. */
    applyConsent() {
      if (!this.config.waitForCookieConsent) return;
      if (this.cookieTrackingAllowed()) {
        if (!this.isCurrentOriginSurfaceDomain()) this.startJourneyTracking();
        if (this.environmentId && this.hasSurfaceIframe()) this.identifyAndPushLeadData();
        return;
      }
      this.clearUserJourney();
      this.journeyStarted = false;
      this.cachedIdentifyData = null;
      clearLeadData();
    }
    startJourneyTracking() {
      if (this.journeyStarted) return;
      this.journeyStarted = true;
      initializeUserJourneyTracking(
        this.environmentId,
        this.log,
        () => this.userJourneyId,
        (id) => this.adoptJourneyId(id),
        this.config,
        () => this.cookieTrackingAllowed()
      );
    }
    /**
     * Journey ids resolve after a network round trip. One that lands after the
     * visitor withdrew is dropped again rather than kept; otherwise iframes that
     * already received a STORE_UPDATE get a refresh to stitch this pageview.
     */
    adoptJourneyId(id) {
      if (!this.cookieTrackingAllowed()) {
        this.clearUserJourney();
        return;
      }
      const resolved = !!id && id !== this.userJourneyId;
      this.userJourneyId = id;
      if (resolved) this.sendPayloadToIframes("STORE_UPDATE");
    }
    identifyAndPushLeadData() {
      if (!this.environmentId) return;
      const identify = this.config.customOrigin ? identifyLead(this.environmentId, this.config) : identifyLead(this.environmentId);
      identify.then(() => {
        if (!this.cookieTrackingAllowed()) {
          clearLeadData();
          return;
        }
        this.sendPayloadToIframes("LEAD_DATA_UPDATE");
      }).catch((e) => this.log.error({ message: "Identify failed", error: e }));
    }
    setupRouteChangeDetection() {
      onRouteChange((newUrl) => {
        this.windowUrl = new URL(newUrl).toString();
        if (this.cookieTrackingAllowed()) {
          updateUserJourneyOnRouteChange(
            this.environmentId,
            newUrl,
            this.log,
            () => this.userJourneyId,
            (id) => this.adoptJourneyId(id),
            this.config,
            () => this.cookieTrackingAllowed()
          );
        }
        this.sendPayloadToIframes("STORE_UPDATE");
        this.log.info({ message: "Route changed, updated journey", response: { url: newUrl } });
      });
    }
    /**
     * The page's language for every Surface form on it that has no language of its own;
     * forms re-render in place when it changes. Null clears it.
     */
    setLanguage(language) {
      this.language = normalizeLanguageTag(language);
      this.sendPayloadToIframes("STORE_UPDATE");
    }
    /** Lets an embed's own language reach its iframe in every payload the store sends. */
    registerEmbed(embed) {
      if (!this.embeds.includes(embed)) this.embeds.push(embed);
    }
    languageFor(iframe) {
      return this.embeds.find((embed) => embed.iframe === iframe)?.language ?? this.language;
    }
    sendPayloadToIframes(type) {
      const iframes = document.querySelectorAll("iframe");
      if (iframes.length === 0) return;
      this.urlParams = getUrlParams();
      this.urlParams.url = window.location.href;
      this.log.info({ message: "Updating iframe params", response: { type, iframeCount: iframes.length } });
      iframes.forEach((iframe) => this.notifyIframe(iframe, type));
    }
    notifyIframe(iframe, type) {
      const target = iframe || document.querySelector("#surface-iframe");
      if (!target) return;
      this.postToSurfaceIframe(target, {
        type,
        payload: { ...this.getPayload(), language: this.languageFor(target) },
        sender: "surface_tag"
      });
    }
    postToSurfaceIframe(target, message) {
      try {
        const targetOrigin = new URL(target.src).origin;
        if (!this.surfaceDomains.includes(targetOrigin)) return;
        target.contentWindow?.postMessage(message, targetOrigin);
      } catch {
      }
    }
    // Relays the page's consent answer to every Surface form on it. Forms with a
    // category set to "On consent" stay dark until this arrives, so it is also
    // re-sent on each SEND_DATA handshake for frames that mount later.
    sendConsentToIframes() {
      const consent2 = getSurfaceConsent();
      if (!consent2) return;
      document.querySelectorAll("iframe").forEach(
        (iframe) => this.postToSurfaceIframe(iframe, {
          type: SURFACE_CONSENT_MESSAGE_TYPE,
          sender: "surface_tag",
          consent: consent2
        })
      );
    }
    getUrlParams() {
      return getUrlParams();
    }
    getPayload() {
      const allowed = this.cookieTrackingAllowed();
      return {
        windowUrl: this.windowUrl,
        referrer: this.referrer,
        cookies: !allowed ? {} : Object.keys(this.cookies).length === 0 ? parseCookies() : this.cookies,
        origin: this.origin,
        questionIds: this.partialFilledData,
        urlParams: this.urlParams,
        surfaceLeadData: allowed ? getLeadDataWithTTL() : null,
        userJourneyId: allowed ? this.userJourneyId : null,
        language: this.language
      };
    }
    clearUserJourney() {
      clearUserJourney(this.log, (id) => {
        this.userJourneyId = id;
      });
    }
  };

  // src/utils/beacon.ts
  async function sendBeacon(url, payload) {
    try {
      const blob = new Blob([JSON.stringify(payload)], {
        type: "application/json"
      });
      if (navigator.sendBeacon) {
        const sent = navigator.sendBeacon(url, blob);
        if (sent) return true;
      }
      const response = await fetch(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
        keepalive: true
      });
      if (!response.ok) {
        throw new Error("Network response was not ok");
      }
      return true;
    } catch (error) {
      console.error("Beacon send failed:", error);
      return false;
    }
  }

  // src/external-form/form-handlers.ts
  function attachFormHandlers(form) {
    if (!form.environmentId) {
      form.log("No environment id configured", "warn");
      return;
    }
    if (form.forms.length === 0) {
      form.log("No forms with data-id attribute found", "warn");
      return;
    }
    form.forms.forEach((htmlForm) => {
      const formId = htmlForm.getAttribute("data-id");
      form.log(`Attaching handlers to form: ${formId}`);
      htmlForm.querySelectorAll(
        "input[data-id], select[data-id], textarea[data-id], fieldset[data-id]"
      ).forEach(
        (el) => el.addEventListener(
          "change",
          (e) => form.handleInputChange(formId, e)
        )
      );
      const nextButtons = htmlForm.getElementsByClassName("surface-next-button");
      const submitButtons = htmlForm.getElementsByClassName("surface-submit-button");
      if (nextButtons.length > 0) {
        Array.from(nextButtons).forEach((btn) => {
          btn.addEventListener("click", () => form.submitForm(htmlForm, false));
        });
      }
      if (submitButtons.length > 0) {
        Array.from(submitButtons).forEach((btn) => {
          btn.addEventListener("click", (e) => {
            e.preventDefault();
            form.submitForm(htmlForm, true);
          });
        });
      } else {
        htmlForm.addEventListener("submit", (e) => {
          e.preventDefault();
          form.log(`Form ${formId} submitted`);
          form.submitForm(htmlForm, true);
        });
      }
      form.formStates[formId] = {};
      form.formStarted[formId] = false;
      form.initializeForm(formId);
    });
  }

  // src/external-form/external-form.ts
  var SurfaceExternalForm = class {
    constructor(props) {
      this.initialRenderTime = /* @__PURE__ */ new Date();
      this.formStates = {};
      this.responseIds = {};
      this.windowUrl = new URL(window.location.href).toString();
      this.formSessions = {};
      this.formInitializationStatus = {};
      this.formStarted = {};
      this.config = {
        serverBaseUrl: props?.serverBaseUrl || getSurfaceRuntimeConfig().apiBaseUrl,
        debugMode: isDebugMode()
      };
      this.environmentId = props?.siteId || getSiteIdFromScript(document.currentScript);
      this.forms = Array.from(document.querySelectorAll("form")).filter(
        (form) => Boolean(form.getAttribute("data-id"))
      );
    }
    getLeadSessionId(formId) {
      return this.formSessions[formId]?.sessionId || null;
    }
    callFormViewApi(formId) {
      sendBeacon(`${this.config.serverBaseUrl}/externalForm/initialize`, {
        formId,
        environmentId: this.environmentId,
        leadSessionId: this.getLeadSessionId(formId)
      });
    }
    callFormStartedApi(formId) {
      sendBeacon(`${this.config.serverBaseUrl}/externalForm/formStarted`, {
        formId,
        environmentId: this.environmentId,
        leadSessionId: this.getLeadSessionId(formId)
      });
    }
    log(message, level = "log") {
      if (!this.config.debugMode) return;
      switch (level) {
        case "warn":
          console.warn(message);
          break;
        case "error":
          console.error(message);
          break;
        default:
          console.log(message);
          break;
      }
    }
    async identify(formId) {
      const apiUrl = `${this.config.serverBaseUrl}/lead/identify`;
      const parentUrl = new URL(this.windowUrl);
      try {
        const response = await fetch(apiUrl, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            formId,
            environmentId: this.environmentId,
            source: "surfaceForm",
            sourceURL: parentUrl.href,
            sourceURLDomain: parentUrl.hostname,
            sourceURLPath: parentUrl.pathname,
            sourceUrlSearchParams: parentUrl.search,
            leadId: null,
            sessionIdFromParams: null
          })
        });
        const jsonData = await response.json();
        if (response.ok && jsonData.data?.data?.sessionId) {
          this.formSessions[formId] = jsonData.data.data;
        }
      } catch (error) {
        this.log("Error identifying lead: " + error, "error");
      }
    }
    async initializeForm(formId) {
      if (this.formInitializationStatus[formId]) return;
      this.formInitializationStatus[formId] = true;
      await this.identify(formId);
      this.callFormViewApi(formId);
    }
    storeQuestionData(params) {
      const { formId, questionId, value } = params;
      const variableName = params.variableName ?? "value";
      if (!this.formStates[formId]) this.formStates[formId] = {};
      if (!this.formStates[formId][questionId]) this.formStates[formId][questionId] = {};
      this.formStates[formId][questionId][variableName] = value;
    }
    sendBeacon(url, payload) {
      sendBeacon(url, payload);
    }
    submitForm(form, finished = false) {
      const formId = form.getAttribute("data-id");
      const responses = Object.entries(this.formStates[formId] || {}).map(
        ([questionId, data]) => ({ questionId, response: data })
      );
      const payload = {
        id: this.responseIds[formId],
        formId,
        responses,
        finished,
        environmentId: this.environmentId,
        leadSessionId: this.getLeadSessionId(formId),
        initialRenderTime: this.initialRenderTime.toISOString()
      };
      this.log("Submitting form data:" + JSON.stringify(payload));
      if (!this.environmentId) {
        this.log("Skipping form submission: environmentId not configured", "error");
        return;
      }
      fetch(`${this.config.serverBaseUrl}/externalForm/submit`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload)
      }).then((r) => r.json()).then((data) => {
        if (data?.data?.response?.id) {
          this.responseIds[formId] = data.data.response.id;
          this.log("Response ID stored: " + data.data.response.id);
        }
      }).catch((error) => this.log("Error submitting form: " + error, "error"));
    }
    handleInputChange(formId, event) {
      if (!this.formStarted[formId]) {
        this.callFormStartedApi(formId);
        this.formStarted[formId] = true;
      }
      const target = event.target;
      const elementId = target.getAttribute("data-id") || "";
      const [questionId, variableName] = elementId.includes("_") ? elementId.split("_") : [elementId, null];
      const value = target.value;
      this.log(
        `Form ${formId} element changed - Question ID: ${questionId}, Variable Name: ${variableName}, Value: ${value}`
      );
      this.storeQuestionData({
        formId,
        questionId,
        variableName: variableName ?? "value",
        value
      });
    }
    attachFormHandlers() {
      attachFormHandlers(this);
    }
  };

  // src/embed/breakpoints.ts
  var BREAKPOINTS = [
    { name: "2xl", min: 1536 },
    { name: "xl", min: 1280 },
    { name: "lg", min: 1024 },
    { name: "md", min: 768 },
    { name: "sm", min: 0 }
  ];
  function resolveEmbedType(input, log3) {
    if (typeof input === "string") return input;
    if (typeof input === "object") return resolveResponsiveType(input, log3);
    log3.error({ message: "Invalid embed type: must be string or object" });
    return null;
  }
  function resolveResponsiveType(config, log3) {
    const withDefault = ensureDefault(config);
    const breakpoint = getCurrentBreakpoint();
    if (!breakpoint) {
      log3.info({ message: "No matching breakpoint, using default embed type" });
      return withDefault.default;
    }
    const embedType = withDefault[breakpoint];
    if (embedType) {
      log3.info({ message: "Using breakpoint embed type", response: { breakpoint, embedType } });
      return embedType;
    }
    log3.warn({ message: "No embed type for breakpoint, using default", response: { breakpoint } });
    return withDefault.default;
  }
  function ensureDefault(config) {
    if (config.default) return config;
    return { ...config, default: config.sm || Object.values(config)[0] };
  }
  function getCurrentBreakpoint() {
    const width = window.innerWidth;
    const match = BREAKPOINTS.find((bp) => width >= bp.min);
    return match?.name ?? null;
  }

  // src/embed/iframe-updater.ts
  function updateIframeWithOptions(options, iframeReference) {
    const iframe = iframeReference.querySelector("#surface-iframe");
    const spinner = iframeReference.querySelector(".surface-loading-spinner");
    const closeBtn = iframeReference.querySelector(".close-btn-container");
    if (iframe) {
      this.iframe = iframe;
    }
    const optionsKey = JSON.stringify(options);
    if (this._cachedOptionsKey === optionsKey && iframe?.src) {
      if (this._iframePreloaded) {
        if (spinner) spinner.style.display = "none";
        if (closeBtn) closeBtn.style.display = "flex";
        iframe.style.opacity = "1";
        return;
      }
      iframe.onload = () => {
        this._iframePreloaded = true;
        iframe.style.opacity = "1";
        if (spinner) spinner.style.display = "none";
        if (closeBtn) closeBtn.style.display = "flex";
      };
      return;
    }
    this._cachedOptionsKey = optionsKey;
    this._iframePreloaded = false;
    if (spinner) spinner.style.display = "flex";
    if (closeBtn) closeBtn.style.display = "none";
    if (iframe) {
      iframe.style.opacity = "0";
      setTimeout(() => {
        try {
          const url = new URL(this._getSrcUrl());
          if (url.protocol !== "https:") {
            this.log.error({ message: "Only HTTPS URLs are allowed" });
            if (spinner) spinner.style.display = "none";
            return;
          }
          iframe.src = url.toString();
          iframe.onload = () => {
            this._iframePreloaded = true;
            iframe.style.opacity = "1";
            if (spinner) spinner.style.display = "none";
            if (closeBtn) closeBtn.style.display = "flex";
          };
          iframe.onerror = () => {
            this.log.error({ message: "Failed to load iframe content" });
            if (spinner) spinner.style.display = "none";
          };
        } catch (error) {
          this.log.error({ message: "Invalid iframe URL", error });
          if (spinner) spinner.style.display = "none";
        }
      }, 0);
    }
  }

  // src/embed/click-handlers.ts
  function setupClickHandlers() {
    if (this._clickHandler) {
      document.removeEventListener("click", this._clickHandler);
    }
    this._clickHandler = (event) => {
      const target = event.target;
      const clickedButton = target.closest(
        this.documentReferenceSelector + this.target_element_class
      );
      if (clickedButton) {
        if (!this.initialized) {
          this.initializeEmbed();
        }
        this.shouldShowSurfaceForm();
      }
    };
    document.addEventListener("click", this._clickHandler);
  }

  // src/embed/preload.ts
  function preloadIframe() {
    if (this.initialized || this._preload === "false") return;
    if (this._preload === "true") {
      const initWhenIdle = () => {
        if (this.initialized) return;
        if ("requestIdleCallback" in window) {
          window.requestIdleCallback(
            () => {
              if (!this.initialized) this.initializeEmbed();
            },
            { timeout: 3e3 }
          );
        } else {
          setTimeout(() => {
            if (!this.initialized) this.initializeEmbed();
          }, 100);
        }
      };
      if (document.readyState === "complete") {
        initWhenIdle();
      } else {
        window.addEventListener("load", initWhenIdle, { once: true });
      }
    }
    if (this._preload === "pageLoad") {
      this.initializeEmbed();
    }
  }

  // src/embed/show-from-url.ts
  function showSurfaceFormFromUrlParameter() {
    try {
      const params = this.store.getUrlParams();
      if (params?.showSurfaceForm === "true") {
        this.showSurfaceForm();
      }
    } catch (error) {
      this.log.error({ message: "Failed to show Surface Form from URL parameter", error });
    }
  }

  // src/utils/dom.ts
  function injectStyle(css) {
    const style = document.createElement("style");
    style.innerHTML = css;
    document.head.appendChild(style);
    return style;
  }
  function setupDismissHandlers(overlay2, closeBtn, hideCallback) {
    closeBtn.addEventListener("click", hideCallback);
    window.addEventListener("click", (event) => {
      if (event.target === overlay2) hideCallback();
    });
  }

  // src/embed/types/inline.ts
  function embedInline() {
    if (this.surface_inline_reference == null) {
      this.log.warn({ message: "Surface Form could not find target div", response: { targetClass: this.target_element_class } });
    }
    const src = this._getSrcUrl();
    const targetDivs = this.inline_embed_references;
    targetDivs.forEach((clientDiv) => {
      if (clientDiv.querySelector("#surface-inline-div")) return;
      const wrapper = document.createElement("div");
      wrapper.id = "surface-inline-div";
      const iframe = document.createElement("iframe");
      iframe.id = "surface-iframe";
      iframe.src = src;
      iframe.frameBorder = "0";
      iframe.allowFullscreen = true;
      if (!this.iframe) this.iframe = iframe;
      if (this.iframeInlineStyle && typeof this.iframeInlineStyle === "object") {
        Object.assign(iframe.style, this.iframeInlineStyle);
      }
      clientDiv.appendChild(wrapper);
      wrapper.appendChild(iframe);
      registerInlineIframe(this, wrapper, iframe);
      injectStyle(`
      #surface-inline-div { width: 100%; height: 100%; }
      #surface-inline-div iframe { width: 100%; height: 100%; }
    `);
      this.updateIframeWithOptions({}, wrapper);
    });
  }

  // src/embed/styles/loader.ts
  function getLoaderStyles() {
    return `
    .surface-loading-spinner {
      height: 5px;
      width: 5px;
      color: #fff;
      box-shadow: -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px;
      animation: loader-38 6s infinite;
    }

    @keyframes loader-38 {
      0%     { box-shadow: -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px; }
      8.33%  { box-shadow: -10px -10px 0 5px,  10px -10px 0 5px,  10px -10px 0 5px,  10px -10px 0 5px; }
      16.66% { box-shadow: -10px -10px 0 5px,  10px -10px 0 5px,  10px  10px 0 5px,  10px  10px 0 5px; }
      24.99% { box-shadow: -10px -10px 0 5px,  10px -10px 0 5px,  10px  10px 0 5px, -10px  10px 0 5px; }
      33.32% { box-shadow: -10px -10px 0 5px,  10px -10px 0 5px,  10px  10px 0 5px, -10px -10px 0 5px; }
      41.65% { box-shadow:  10px -10px 0 5px,  10px -10px 0 5px,  10px  10px 0 5px,  10px -10px 0 5px; }
      49.98% { box-shadow:  10px  10px 0 5px,  10px  10px 0 5px,  10px  10px 0 5px,  10px  10px 0 5px; }
      58.31% { box-shadow: -10px  10px 0 5px, -10px  10px 0 5px,  10px  10px 0 5px, -10px  10px 0 5px; }
      66.64% { box-shadow: -10px -10px 0 5px, -10px -10px 0 5px,  10px  10px 0 5px, -10px  10px 0 5px; }
      74.97% { box-shadow: -10px -10px 0 5px,  10px -10px 0 5px,  10px  10px 0 5px, -10px  10px 0 5px; }
      83.3%  { box-shadow: -10px -10px 0 5px,  10px  10px 0 5px,  10px  10px 0 5px, -10px  10px 0 5px; }
      91.63% { box-shadow: -10px -10px 0 5px, -10px  10px 0 5px, -10px  10px 0 5px, -10px  10px 0 5px; }
      100%   { box-shadow: -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px, -10px -10px 0 5px; }
    }

    @keyframes spin {
      0%   { transform: translate(-50%, -50%) rotate(0deg); }
      100% { transform: translate(-50%, -50%) rotate(360deg); }
    }
  `;
  }

  // src/embed/styles/close-button.ts
  function getCloseButtonStyles(variant) {
    if (variant === "slideover") {
      return `
      .close-btn-container {
        position: absolute;
        right: 20px;
        top: 10px;
        z-index: 100000;
        display: none;
        justify-content: center;
        align-items: center;
        background: #ffffff;
        border: none;
        border-radius: 50%;
        width: 24px;
        height: 24px;
        opacity: .75;
      }

      .close-btn {
        display: block;
        padding: 0;
        margin: 0 0 6px 0;
        font-size: 20px;
        font-weight: normal;
        line-height: 24px;
        text-align: center;
        text-transform: none;
        cursor: pointer;
        transition: opacity .25s ease-in-out;
        text-decoration: none;
        color: #000;
        height: 20px;
      }
    `;
    }
    return `
    .close-btn-container {
      position: absolute;
      display: none;
      justify-content: center;
      align-items: center;
      top: 6px;
      right: 8px;
      background: #ffffff;
      border: none;
      border-radius: 50%;
      width: 24px;
      height: 24px;
      opacity: .75;
    }

    @media (min-width: 481px) {
      .close-btn-container {
        top: -34px;
        right: 0;
        background: none;
        border: none;
        border-radius: 0;
      }
    }

    .close-btn {
      display: block;
      padding: 0;
      margin: 0 0 6px 0;
      font-size: 20px;
      font-weight: normal;
      line-height: 24px;
      text-align: center;
      text-transform: none;
      cursor: pointer;
      transition: opacity .25s ease-in-out;
      text-decoration: none;
      color: #000;
      height: 20px;
    }

    @media (min-width: 481px) {
      .close-btn {
        color: #ffffff;
        font-size: 32px;
        margin-bottom: 0px;
        height: auto;
      }
    }
  `;
  }

  // src/embed/styles/popup.ts
  function getPopupStyles(dimensions) {
    return `
    ${getLoaderStyles()}

    #surface-popup {
      display: none;
      justify-content: center;
      align-items: center;
      position: fixed;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      z-index: 99999;
      background-color: rgba(0,0,0,0.5);
      opacity: 0;
      transition: opacity 0.15s ease;
    }

    .surface-popup-content {
      position: relative;
      top: 0;
      left: 0;
      transform: scale(0.9);
      width: calc(100% - 20px);
      height: calc(100% - 20px);
      background-color: transparent;
      border-radius: 15px;
      opacity: 0;
      transition: transform 0.15s ease, opacity 0.15s ease;
    }

    .surface-popup-content iframe {
      width: 100%;
      height: 100%;
      border-radius: 15px;
    }

    @media (min-width: 481px) {
      .surface-popup-content {
        width: ${dimensions.width};
        height: ${dimensions.height};
        margin: 20px;
      }
    }

    #surface-iframe {
      transition: opacity 0.15s ease-in-out;
    }

    #surface-popup.active {
      opacity: 1;
    }

    #surface-popup.active .surface-popup-content {
      transform: scale(1);
      opacity: 1;
    }

    ${getCloseButtonStyles("popup")}
  `;
  }

  // src/embed/types/popup.ts
  var POPUP_HTML = (src) => `
  <div class="surface-popup-content">
    <div style="display:flex;justify-content:center;align-items:center;height:100%;position:absolute;top:0;left:0;width:100%;pointer-events:none;">
      <div class="surface-loading-spinner"></div>
    </div>
    <iframe id="surface-iframe" src="${src}" frameborder="0" allowfullscreen style="opacity:0;"></iframe>
    <div class="close-btn-container" style="display:none;">
      <span class="close-btn">&times;</span>
    </div>
  </div>
`;
  function embedPopup() {
    if (!this.surface_popup_reference) {
      this.log.error({ message: "Cannot embed popup", response: { embedType: this.embed_type } });
      return;
    }
    const popup = this.surface_popup_reference;
    const src = this._getSrcUrl();
    if (!this.initialized) {
      popup.id = "surface-popup";
      popup.innerHTML = POPUP_HTML(src);
      document.body.appendChild(popup);
      const dimensions = getPopupDimensions(this._popupSize);
      if (!this.styles.popup) {
        this.styles.popup = injectStyle(getPopupStyles(dimensions));
      }
      const iframe = popup.querySelector("#surface-iframe");
      const spinner = popup.querySelector(".surface-loading-spinner");
      const closeBtn = popup.querySelector(".close-btn-container");
      if (iframe) {
        this.iframe = iframe;
        this._cachedOptionsKey = JSON.stringify({});
        iframe.onload = () => {
          this._iframePreloaded = true;
          iframe.style.opacity = "1";
          if (spinner) spinner.style.display = "none";
          if (closeBtn) closeBtn.style.display = "flex";
        };
      }
    }
    const closeContainer = popup.querySelector(".close-btn-container");
    setupDismissHandlers(popup, closeContainer, () => this.hideSurfacePopup());
  }
  function showSurfacePopup(options = {}) {
    if (!this.surface_popup_reference) {
      this.log.warn({ message: "Invalid showSurfaceForm: embed type is not popup" });
      return;
    }
    this._previouslyFocusedElement = document.activeElement;
    this.updateIframeWithOptions(options, this.surface_popup_reference);
    this.surface_popup_reference.style.display = "flex";
    document.body.style.overflow = "hidden";
    setTimeout(() => {
      this.surface_popup_reference.classList.add("active");
      this.iframe?.focus();
    }, 50);
  }
  function hideSurfacePopup() {
    if (!this.surface_popup_reference) {
      this.log.warn({ message: "Invalid hideSurfaceForm: embed type is not popup" });
      return;
    }
    this.surface_popup_reference.classList.remove("active");
    document.body.style.overflow = "auto";
    if (this._previouslyFocusedElement) {
      this._previouslyFocusedElement.focus();
      this._previouslyFocusedElement = null;
    }
    setTimeout(() => {
      this.surface_popup_reference.style.display = "none";
    }, 200);
  }

  // src/embed/styles/slideover.ts
  function getSlideoverStyles() {
    return `
    ${getLoaderStyles()}

    #surface-popup {
      display: none;
      position: fixed;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      z-index: 99999;
      background-color: rgba(0,0,0,0.5);
      opacity: 0;
      transition: opacity 0.15s ease;
    }

    .surface-popup-content {
      position: absolute;
      top: 0;
      left: 0;
      transform: translateX(80%);
      width: 100%;
      height: 100%;
      background-color: transparent;
      padding: 0;
      box-shadow: 0px 0px 15px rgba(0,0,0,0.2);
      opacity: 0;
      transition: transform 0.2s ease, opacity 0.2s ease;
    }

    .surface-popup-content iframe {
      width: 100%;
      height: 100%;
    }

    #surface-popup.active {
      opacity: 1;
    }

    #surface-popup.active .surface-popup-content {
      transform: translateX(0%);
      opacity: 1;
    }

    ${getCloseButtonStyles("slideover")}
  `;
  }

  // src/embed/types/slideover.ts
  var SLIDEOVER_HTML = (src) => `
  <div class="surface-popup-content">
    <div style="display:flex;justify-content:center;align-items:center;height:100%;position:absolute;top:0;left:0;width:100%;pointer-events:none;">
      <div class="surface-loading-spinner"></div>
    </div>
    <div class="close-btn-container" style="display:none;">
      <span class="close-btn">&times;</span>
    </div>
    <iframe id="surface-iframe" src="${src}" frameborder="0" allowfullscreen style="opacity:0;"></iframe>
  </div>
`;
  function embedSlideover() {
    if (!this.surface_popup_reference) {
      this.log.error({ message: "Cannot embed slideover", response: { embedType: this.embed_type } });
      return;
    }
    const slideover = this.surface_popup_reference;
    const src = this._getSrcUrl();
    slideover.id = "surface-popup";
    slideover.innerHTML = SLIDEOVER_HTML(src);
    document.body.appendChild(slideover);
    injectStyle(getSlideoverStyles());
    const iframe = slideover.querySelector("#surface-iframe");
    const spinner = slideover.querySelector(".surface-loading-spinner");
    const closeBtn = slideover.querySelector(".close-btn-container");
    if (iframe) {
      this.iframe = iframe;
      this._cachedOptionsKey = JSON.stringify({});
      iframe.onload = () => {
        this._iframePreloaded = true;
        iframe.style.opacity = "1";
        if (spinner) spinner.style.display = "none";
        if (closeBtn) closeBtn.style.display = "flex";
      };
    }
    const closeBtnEl = slideover.querySelector(".close-btn");
    setupDismissHandlers(slideover, closeBtnEl, () => this.hideSurfaceSlideover());
  }
  function showSurfaceSlideover(options = {}) {
    if (!this.surface_popup_reference) {
      this.log.warn({ message: "Invalid showSurfaceForm: embed type is not slideover" });
      return;
    }
    this._previouslyFocusedElement = document.activeElement;
    this.updateIframeWithOptions(options, this.surface_popup_reference);
    this.surface_popup_reference.style.display = "block";
    document.body.style.overflow = "hidden";
    setTimeout(() => {
      this.surface_popup_reference.classList.add("active");
      this.iframe?.focus();
    }, 50);
  }
  function hideSurfaceSlideover() {
    if (!this.surface_popup_reference) {
      this.log.warn({ message: "Invalid hideSurfaceForm: embed type is not slideover" });
      return;
    }
    this.surface_popup_reference.classList.remove("active");
    document.body.style.overflow = "auto";
    if (this._previouslyFocusedElement) {
      this._previouslyFocusedElement.focus();
      this._previouslyFocusedElement = null;
    }
    setTimeout(() => {
      this.surface_popup_reference.style.display = "none";
    }, 300);
  }

  // src/embed/styles/widget.ts
  function getWidgetStyles(ws) {
    return `
    #surface-widget-button {
      position: fixed;
      bottom: ${ws.bottomMargin};
      ${ws.position}: ${ws.sideMargin};
      z-index: 99998;
      cursor: pointer;
    }

    .widget-button-inner {
      width: ${ws.size};
      height: ${ws.size};
      border-radius: 50%;
      background-color: ${ws.backgroundColor};
      display: flex;
      align-items: center;
      justify-content: center;
      box-shadow: ${ws.boxShadow};
      transition: transform 0.2s ease;
    }

    .widget-button-inner:hover {
      transform: scale(${ws.hoverScale});
    }
  `;
  }

  // src/embed/types/widget.ts
  var WIDGET_SVG = `
  <svg width="29" height="34" viewBox="0 0 29 34" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path d="M15.008 33.986C10.6773 33.986 7.27467 33.0773 4.8 31.26C2.364 29.404 1.088 26.852 0.972 23.604H8.222C8.338 24.6867 8.93733 25.6727 10.02 26.562C11.1027 27.4513 12.804 27.896 15.124 27.896C17.0573 27.896 18.5847 27.548 19.706 26.852C20.866 26.156 21.446 25.2087 21.446 24.01C21.446 22.966 21.0013 22.1347 20.112 21.516C19.2613 20.8973 17.792 20.4913 15.704 20.298L12.92 20.008C9.40133 19.6213 6.69467 18.616 4.8 16.992C2.90533 15.368 1.958 13.2027 1.958 10.496C1.958 8.33067 2.49933 6.51333 3.582 5.044C4.66467 3.57466 6.15333 2.47266 8.048 1.738C9.98133 0.964665 12.1853 0.577999 14.66 0.577999C18.5267 0.577999 21.6587 1.42867 24.056 3.13C26.4533 4.83133 27.71 7.32533 27.826 10.612H20.576C20.4987 9.52933 19.9573 8.60133 18.952 7.828C17.9467 7.05467 16.4967 6.668 14.602 6.668C12.9007 6.668 11.586 6.99667 10.658 7.654C9.73 8.31133 9.266 9.162 9.266 10.206C9.266 11.2113 9.63333 11.9847 10.368 12.526C11.1413 13.0673 12.3787 13.4347 14.08 13.628L16.864 13.918C20.576 14.3047 23.476 15.3293 25.564 16.992C27.6907 18.6547 28.754 20.8973 28.754 23.72C28.754 25.808 28.174 27.6253 27.014 29.172C25.8927 30.68 24.3073 31.8593 22.258 32.71C20.2087 33.5607 17.792 33.986 15.008 33.986Z" fill="white"/>
  </svg>
`;
  function addWidgetButton() {
    const button = document.createElement("div");
    button.id = "surface-widget-button";
    button.innerHTML = `<div class="widget-button-inner">${WIDGET_SVG}</div>`;
    document.body.appendChild(button);
    injectStyle(getWidgetStyles(this.widgetStyle));
    button.addEventListener("click", () => {
      if (!this.initialized) this.initializeEmbed();
      this.showSurfaceForm();
    });
  }

  // src/embed/input-trigger/field-validation.ts
  function getFieldValue(field) {
    const tagName = field.tagName.toLowerCase();
    const type = field.type?.toLowerCase();
    if (tagName === "select") {
      const select = field;
      if (select.multiple) {
        return Array.from(select.selectedOptions).map((opt) => opt.value);
      }
      return select.value;
    }
    if (tagName === "textarea") {
      return field.value.trim();
    }
    if (tagName === "input") {
      const input = field;
      if (type === "checkbox") {
        return input.checked ? input.value || "true" : null;
      }
      if (type === "radio") {
        const group = document.querySelectorAll(
          `input[type="radio"][name="${input.name}"]`
        );
        const checked = Array.from(group).find((r) => r.checked);
        return checked ? checked.value : null;
      }
      return input.value.trim();
    }
    return null;
  }
  function validateField(field, value) {
    const isArray = Array.isArray(value);
    const isEmpty = isArray ? value.length === 0 : value === null || value === "";
    if (isEmpty) {
      if (field.hasAttribute("required") || field.required) {
        return { valid: false, field };
      }
      return { valid: true, field: null };
    }
    const type = field.type?.toLowerCase();
    if (type === "email") {
      const emailRegex = /^[^\s@]+@[^\s@]+\.[a-zA-Z]{2,}$/;
      const values = isArray ? value : [value];
      if (!values.every((v) => emailRegex.test(v))) {
        return { valid: false, field };
      }
    }
    if (field.hasAttribute("pattern")) {
      const pattern = new RegExp(field.getAttribute("pattern"));
      const values = isArray ? value : [value];
      if (!values.every((v) => pattern.test(v))) {
        return { valid: false, field };
      }
    }
    if (field.hasAttribute("minlength")) {
      const minLength = parseInt(field.getAttribute("minlength"));
      if (value.length < minLength) {
        return { valid: false, field };
      }
    }
    if (field.hasAttribute("maxlength")) {
      const maxLength = parseInt(field.getAttribute("maxlength"));
      if (value.length > maxLength) {
        return { valid: false, field };
      }
    }
    if (!field.checkValidity()) {
      return { valid: false, field };
    }
    return { valid: true, field: null };
  }

  // src/embed/input-trigger/field-collection.ts
  function collectFormFields(form, defaultQuestionId) {
    const fields = [];
    const formQuestionId = form.getAttribute("data-question-id") || defaultQuestionId;
    const processedFields = /* @__PURE__ */ new Set();
    const elementsWithQuestionId = form.querySelectorAll("[data-question-id]");
    elementsWithQuestionId.forEach((element) => {
      const questionId = element.getAttribute("data-question-id");
      const formField = findFormField(element);
      if (formField) {
        const fieldNameFromParent = element.getAttribute("data-field-name");
        processField(formField, questionId, fieldNameFromParent, fields, processedFields);
      }
    });
    const elementsWithFieldName = form.querySelectorAll("[data-field-name]");
    elementsWithFieldName.forEach((element) => {
      if (!element.hasAttribute("data-question-id")) {
        const formField = findFormField(element);
        if (formField && !processedFields.has(formField)) {
          const fieldNameFromParent = element.getAttribute("data-field-name");
          processField(formField, formQuestionId, fieldNameFromParent, fields, processedFields);
        }
      }
    });
    const emailInput = form.querySelector('input[type="email"]');
    if (emailInput && !processedFields.has(emailInput)) {
      processField(emailInput, formQuestionId, "emailAddress", fields, processedFields);
    }
    return fields;
  }
  function findFormField(element) {
    const tagName = element.tagName.toLowerCase();
    if (tagName === "input" || tagName === "select" || tagName === "textarea") {
      return element;
    }
    return element.querySelector("input, select, textarea");
  }
  function processField(field, questionId, fieldNameFromParent, fields, processed) {
    if (processed.has(field)) return;
    const fieldType = field.type?.toLowerCase();
    let fieldName;
    if (fieldType === "email") {
      fieldName = "emailAddress";
    } else {
      fieldName = fieldNameFromParent || field.getAttribute("data-field-name") || "";
    }
    if (field.type === "radio") {
      const radioGroupName = field.name;
      const alreadyProcessed = fields.some(
        (f) => f.field.type === "radio" && f.field.name === radioGroupName
      );
      if (alreadyProcessed) return;
    }
    fields.push({
      field,
      questionId,
      fieldName,
      value: getFieldValue(field)
    });
    processed.add(field);
  }

  // src/embed/input-trigger/submit-handler.ts
  function createSubmitHandler(embed, form, questionId) {
    return (e) => {
      e.preventDefault();
      const formFields = collectFormFields(form, questionId);
      const options = {};
      let hasError = false;
      let firstInvalid = null;
      formFields.forEach(({ field, questionId: qId, fieldName, value }) => {
        const isArray = Array.isArray(value);
        const isEmpty = isArray ? value.length === 0 : value === null || value === "";
        if (isEmpty && !field.hasAttribute("required") && !field.required) {
          return;
        }
        const result = validateField(field, value);
        if (!result.valid) {
          hasError = true;
          if (!firstInvalid) firstInvalid = result.field || field;
          return;
        }
        if (!isEmpty) {
          const key = fieldName ? `${qId}_${fieldName}` : qId;
          options[key] = value;
        }
      });
      if (hasError && firstInvalid) {
        firstInvalid.reportValidity();
        return;
      }
      if (Object.keys(options).length > 0) {
        const existingData = Array.isArray(embed.store.partialFilledData) ? embed.store.partialFilledData : [];
        const dataMap = /* @__PURE__ */ new Map();
        existingData.forEach((entry, index) => {
          const key = Object.keys(entry)[0];
          dataMap.set(key, index);
        });
        Object.entries(options).forEach(([key, value]) => {
          const newEntry = { [key]: value };
          if (dataMap.has(key)) {
            existingData[dataMap.get(key)] = newEntry;
          } else {
            existingData.push(newEntry);
          }
        });
        embed.store.partialFilledData = existingData;
        if (!embed.initialized) embed.initializeEmbed();
        embed.store.notifyIframe(embed.iframe, "STORE_UPDATE");
        embed.showSurfaceForm();
      } else {
        const emailInput = form.querySelector('input[type="email"]');
        if (emailInput) emailInput.reportValidity();
      }
    };
  }
  function createKeyDownHandler(form) {
    return (e) => {
      const ke = e;
      if (ke.key !== "Enter") return;
      const active = document.activeElement;
      const tagName = active.tagName.toLowerCase();
      const type = active.type?.toLowerCase();
      if (tagName === "textarea") return;
      if (type === "checkbox" || type === "radio") return;
      if (tagName === "input" && type !== "checkbox" && type !== "radio" || tagName === "select") {
        ke.preventDefault();
        form.dispatchEvent(new Event("submit", { cancelable: true }));
      }
    };
  }

  // src/embed/input-trigger/input-trigger.ts
  function formInputTriggerInitialize() {
    const questionId = this.currentQuestionId || "";
    if (this._formHandlers) {
      this._formHandlers.forEach(({ form, submitHandler, keydownHandler }) => {
        form.removeEventListener("submit", submitHandler);
        form.removeEventListener("keydown", keydownHandler);
      });
    }
    this._formHandlers = [];
    const allForms = document.querySelectorAll("form.surface-form-handler");
    let forms = Array.from(allForms).filter(
      (form) => form.getAttribute("data-question-id") === questionId
    );
    if (forms.length === 0) {
      const formsWithQuestionId = Array.from(allForms).filter(
        (f) => f.hasAttribute("data-question-id")
      );
      if (!formsWithQuestionId.length) {
        forms = Array.from(allForms);
      }
    }
    forms.forEach((form) => {
      const submitHandler = createSubmitHandler(this, form, questionId);
      const keydownHandler = createKeyDownHandler(form);
      form.addEventListener("submit", submitHandler);
      form.addEventListener("keydown", keydownHandler);
      this._formHandlers.push({ form, submitHandler, keydownHandler });
    });
  }

  // src/embed/embed.ts
  var DEFAULT_WIDGET_STYLES = {
    position: "right",
    bottomMargin: "40px",
    sideMargin: "30px",
    size: "64px",
    backgroundColor: "#1a56db",
    hoverScale: "1.05",
    boxShadow: "0 6px 12px rgba(0,0,0,0.25)"
  };
  var _SurfaceEmbed = class _SurfaceEmbed {
    constructor(src, surface_embed_type, target_element_class, options = {}) {
      this.src = new URL(src);
      this.log = createLogger("Surface Embed");
      this.store = window.SurfaceTagStore;
      this.currentQuestionId = options.questionId || document.currentScript?.getAttribute("data-question-id") || null;
      _SurfaceEmbed._instances.push(this);
      if (this._isFormPreviewMode()) {
        this.log.info({ message: "Form is in preview mode" });
        this.src.searchParams.append("preview", "true");
      }
      this._popupSize = options.popupSize || "medium";
      this.documentReferenceSelector = options.enforceIDSelector ? "#" : ".";
      this.log.info({ message: "documentReferenceSelector set", response: { selector: this.documentReferenceSelector } });
      const preloadOptions = ["true", "false", "pageLoad"];
      this._preload = preloadOptions.includes(options.preload) ? options.preload : "true";
      this.log.info({ message: "preload set", response: { preload: this._preload } });
      this.styles = { popup: null, widget: null };
      this.initialized = false;
      this.iframe = null;
      this.language = null;
      this.surface_popup_reference = null;
      this.surface_inline_reference = null;
      this.inline_embed_references = null;
      this.iframeInlineStyle = null;
      this._cachedSrcUrl = null;
      this._cachedOptionsKey = null;
      this._iframePreloaded = false;
      this._previouslyFocusedElement = null;
      this._clickHandler = null;
      this._formHandlers = null;
      this.target_element_class = target_element_class;
      this.options = options;
      this.options.popupSize = this._popupSize;
      this.widgetStyle = { ...DEFAULT_WIDGET_STYLES, ...options.widgetStyles || {} };
      if (options.prefillData) {
        this.store.partialFilledData = Object.entries(options.prefillData).map(
          ([key, value]) => ({ [key]: value })
        );
      }
      this.embed_type = resolveEmbedType(surface_embed_type, this.log);
      this.shouldShowSurfaceForm = () => {
      };
      this.embedSurfaceForm = () => {
      };
      this.hideSurfaceForm = () => {
      };
      if (!this.embed_type || !VALID_EMBED_TYPES.includes(this.embed_type)) {
        this.log.error({ message: "Invalid embed type: must be string or object" });
        return;
      }
      if (!target_element_class) return;
      if (this.embed_type === "inline") {
        this.src.searchParams.set(INLINE_EMBED_PARAM, "inline");
        this.src.searchParams.set(INLINE_CAPS_PARAM, INLINE_LAYOUT_CAP);
      }
      this.language = normalizeLanguageTag(options.language) ?? normalizeLanguageTag(this.src.searchParams.get(LANGUAGE_PARAM));
      if (this.language) this.store?.registerEmbed?.(this);
      const firstPaintLanguage = this.language ?? normalizeLanguageTag(this.store?.language);
      if (firstPaintLanguage) this.src.searchParams.set(LANGUAGE_PARAM, firstPaintLanguage);
      this.wireEmbedType();
      this.surface_popup_reference ?? (this.surface_popup_reference = document.createElement("div"));
      this.setupClickHandlers();
      this.formInputTriggerInitialize();
      this.showSurfaceFormFromUrlParameter();
      this.preloadIframe();
      this.hideFormOnEsc();
      this.setupEmbedRouteDetection();
    }
    wireEmbedType() {
      if (this.initialized) return;
      if (this.embed_type === "inline") {
        this.surface_inline_reference = null;
        this.inline_embed_references = document.querySelectorAll(
          this.documentReferenceSelector + this.target_element_class
        );
        this.embedSurfaceForm = this.embedInline;
        this.initializeEmbed();
      } else if (this.embed_type === "popup" || this.embed_type === "widget" || this.embed_type === "input-trigger") {
        this.embedSurfaceForm = this.embedPopup;
        this.shouldShowSurfaceForm = this.showSurfacePopup;
        this.hideSurfaceForm = this.hideSurfacePopup;
        if (this.embed_type === "widget") {
          this.surface_popup_reference ?? (this.surface_popup_reference = document.createElement("div"));
          this.addWidgetButton();
        }
      } else if (this.embed_type === "slideover") {
        this.embedSurfaceForm = this.embedSlideover;
        this.shouldShowSurfaceForm = this.showSurfaceSlideover;
        this.hideSurfaceForm = this.hideSurfaceSlideover;
      }
    }
    initializeEmbed() {
      if (this.initialized) return;
      this.embedSurfaceForm();
      this.initialized = true;
    }
    showSurfaceForm() {
      if (!this.initialized) this.initializeEmbed();
      this.shouldShowSurfaceForm();
    }
    _getSrcUrl() {
      if (!this._cachedSrcUrl) {
        this._cachedSrcUrl = this.src.toString();
      }
      return this._cachedSrcUrl;
    }
    get popupSize() {
      return this._popupSize;
    }
    set popupSize(size) {
      const validSizes = ["small", "medium", "large"];
      if (!(typeof size === "string" && validSizes.includes(size)) && !(typeof size === "object" && Object.keys(size).length > 0)) {
        this.log.warn({ message: "Invalid popup size, using 'medium' instead", response: { size } });
        this._popupSize = "medium";
      } else {
        this._popupSize = size;
      }
    }
    _isFormPreviewMode() {
      const params = this.store?.getUrlParams?.() ?? {};
      return params.surfaceDebug === "true";
    }
    hideFormOnEsc() {
      document.addEventListener("keydown", (event) => {
        if (event.key === "Escape") this.hideSurfaceForm();
      });
    }
    setupEmbedRouteDetection() {
      let currentUrl2 = window.location.href;
      const handleChange = () => {
        const newUrl = window.location.href;
        if (newUrl === currentUrl2) return;
        currentUrl2 = newUrl;
        this.store.windowUrl = new URL(newUrl).toString();
        releaseDetachedInlineOverlays();
        this.setupClickHandlers();
        this.formInputTriggerInitialize();
        this.log.info({ message: "Route changed, re-initialized handlers", response: { url: newUrl } });
      };
      onRouteChange(handleChange);
      if (typeof MutationObserver !== "undefined") {
        const observer = new MutationObserver((mutations) => {
          let shouldReinit = false;
          mutations.forEach((mutation) => {
            mutation.addedNodes.forEach((node) => {
              if (node.nodeType !== 1) return;
              const el = node;
              if (el.matches?.("form.surface-form-handler") || el.matches?.(this.documentReferenceSelector + this.target_element_class) || el.querySelector?.("form.surface-form-handler") || el.querySelector?.(this.documentReferenceSelector + this.target_element_class)) {
                shouldReinit = true;
              }
            });
          });
          if (shouldReinit) {
            clearTimeout(this._reinitTimeout);
            this._reinitTimeout = setTimeout(() => {
              this.store.windowUrl = new URL(window.location.href).toString();
              this.setupClickHandlers();
              this.formInputTriggerInitialize();
              this.log.info({ message: "DOM changed, re-initialized handlers" });
            }, 100);
          }
        });
        if (document.body) {
          observer.observe(document.body, { childList: true, subtree: true });
        } else {
          const bodyObserver = new MutationObserver(() => {
            if (document.body) {
              observer.observe(document.body, { childList: true, subtree: true });
              bodyObserver.disconnect();
            }
          });
          bodyObserver.observe(document.documentElement, { childList: true });
        }
      }
    }
  };
  _SurfaceEmbed._instances = [];
  var SurfaceEmbed = _SurfaceEmbed;
  Object.assign(SurfaceEmbed.prototype, {
    updateIframeWithOptions,
    setupClickHandlers,
    preloadIframe,
    showSurfaceFormFromUrlParameter,
    embedInline,
    embedPopup,
    showSurfacePopup,
    hideSurfacePopup,
    embedSlideover,
    showSurfaceSlideover,
    hideSurfaceSlideover,
    addWidgetButton,
    formInputTriggerInitialize
  });

  // src/open-triggers/open-trigger-overlay.ts
  var ID = "surface-open-trigger";
  var CONTENT = "surface-ot-content";
  var IFRAME = "surface-ot-iframe";
  var CLOSEBOX = "surface-ot-closebox";
  var CLOSE = "surface-ot-close";
  var SPINNER = "surface-ot-spinner";
  var STYLE_ID = "surface-ot-style";
  var overlayEl = null;
  var prevBodyOverflow = "";
  function openTriggerOverlay(formSrc, mode) {
    if (overlayEl && document.body.contains(overlayEl)) {
      show(overlayEl, mode);
      return;
    }
    injectStyles(mode);
    const overlay2 = document.createElement("div");
    overlay2.id = ID;
    overlay2.style.display = "none";
    overlay2.innerHTML = `
    <div class="${CONTENT}">
      <div style="display:flex;justify-content:center;align-items:center;height:100%;position:absolute;top:0;left:0;width:100%;pointer-events:none;">
        <div class="${SPINNER}"></div>
      </div>
      <iframe id="${IFRAME}" src="${formSrc}" frameborder="0" allowfullscreen style="opacity:0;"></iframe>
      <div class="${CLOSEBOX}" style="display:none;"><span class="${CLOSE}">&times;</span></div>
    </div>
  `;
    document.body.appendChild(overlay2);
    overlayEl = overlay2;
    const iframe = overlay2.querySelector("#" + IFRAME);
    const spinner = overlay2.querySelector("." + SPINNER);
    const closeBox = overlay2.querySelector("." + CLOSEBOX);
    if (iframe) {
      iframe.onload = () => {
        iframe.style.opacity = "1";
        if (spinner) spinner.style.display = "none";
        if (closeBox) closeBox.style.display = "flex";
      };
    }
    const close = () => hide(overlay2);
    overlay2.querySelector("." + CLOSE)?.addEventListener("click", close);
    overlay2.addEventListener("click", (e) => {
      if (e.target === overlay2) close();
    });
    document.addEventListener("keydown", (e) => {
      if (e.key === "Escape" && overlay2.classList.contains("active")) close();
    });
    show(overlay2, mode);
  }
  function show(overlay2, mode) {
    if (overlay2.style.display === "none") {
      prevBodyOverflow = document.body.style.overflow;
    }
    overlay2.style.display = mode === "popup" ? "flex" : "block";
    document.body.style.overflow = "hidden";
    setTimeout(() => {
      overlay2.classList.add("active");
      overlay2.querySelector("#" + IFRAME)?.focus();
    }, 50);
  }
  function hide(overlay2) {
    overlay2.classList.remove("active");
    document.body.style.overflow = prevBodyOverflow;
    setTimeout(() => {
      overlay2.style.display = "none";
    }, 250);
  }
  function injectStyles(mode) {
    if (document.getElementById(STYLE_ID)) return;
    const canonical = mode === "popup" ? getPopupStyles(getPopupDimensions("medium")) : getSlideoverStyles();
    const style = document.createElement("style");
    style.id = STYLE_ID;
    style.textContent = namespace(canonical);
    document.head.appendChild(style);
  }
  function namespace(css) {
    return css.replace(/surface-popup-content/g, CONTENT).replace(/surface-loading-spinner/g, SPINNER).replace(/close-btn-container/g, CLOSEBOX).replace(/close-btn/g, CLOSE).replace(/surface-iframe/g, IFRAME).replace(/surface-popup/g, ID);
  }

  // src/open-triggers/resolve.ts
  var OPENABLE_MODES = ["popup", "slideover"];
  function pickOpenTrigger(search, map) {
    if (!map) return null;
    const params = new URLSearchParams(search);
    for (const [key, value] of params) {
      if (value !== "true") continue;
      const entry = map[key];
      if (entry && entry.formId && entry.formSrc && OPENABLE_MODES.includes(entry.mode)) {
        return entry;
      }
    }
    return null;
  }

  // src/open-triggers/open-triggers.ts
  var SESSION_PREFIX = "surface_open_triggers:";
  var CACHE_TTL_MS = 5 * 60 * 1e3;
  var REUSE_POLL_INTERVAL_MS = 150;
  var REUSE_POLL_MAX_TRIES = 12;
  async function resolveOpenTriggersOnLoad(environmentId3, config = getSurfaceRuntimeConfig()) {
    try {
      if (!environmentId3) return;
      if (!window.location.search) return;
      const map = await fetchOpenTriggersMap(environmentId3, config);
      const entry = pickOpenTrigger(window.location.search, map);
      if (!entry) return;
      openTriggerForm(entry);
    } catch {
    }
  }
  async function fetchOpenTriggersMap(environmentId3, config) {
    const w3 = window;
    if (w3.__SURFACE_OPEN_TRIGGERS_MAP) return w3.__SURFACE_OPEN_TRIGGERS_MAP;
    const sessionKey = `${SESSION_PREFIX}${config.apiBaseUrl}:${environmentId3}`;
    try {
      const cached2 = sessionStorage.getItem(sessionKey);
      if (cached2) {
        const parsed = JSON.parse(cached2);
        if (parsed && parsed.map && typeof parsed.ts === "number" && Date.now() - parsed.ts < CACHE_TTL_MS) {
          return parsed.map;
        }
      }
    } catch {
    }
    const base = w3.__SURFACE_OPEN_TRIGGERS_BASE || config.apiBaseUrl;
    const response = await fetch(`${base}/environments/${encodeURIComponent(environmentId3)}/open-triggers`);
    if (!response.ok) return null;
    const json = await response.json();
    const map = json?.data ?? {};
    try {
      sessionStorage.setItem(sessionKey, JSON.stringify({ map, ts: Date.now() }));
    } catch {
    }
    return map;
  }
  function openTriggerForm(entry) {
    let targetPathname = null;
    try {
      targetPathname = new URL(entry.formSrc).pathname;
    } catch {
    }
    if (targetPathname === null) {
      openTriggerOverlay(entry.formSrc, entry.mode);
      return;
    }
    const findSameModeEmbed = () => SurfaceEmbed._instances.find(
      (inst) => inst.embed_type === entry.mode && !!inst.src && inst.src.pathname === targetPathname
    );
    let tries = 0;
    const attempt = () => {
      try {
        const sameMode = findSameModeEmbed();
        if (sameMode) {
          sameMode.showSurfaceForm();
          return;
        }
        if (tries < REUSE_POLL_MAX_TRIES) {
          tries += 1;
          setTimeout(attempt, REUSE_POLL_INTERVAL_MS);
          return;
        }
        openTriggerOverlay(entry.formSrc, entry.mode);
      } catch {
      }
    };
    attempt();
  }

  // src/review/dom.ts
  function escapeSelector(value) {
    return window.CSS && CSS.escape ? CSS.escape(value) : value.replace(/[^\w-]/g, "\\$&");
  }
  function isUnique(selector) {
    try {
      return document.querySelectorAll(selector).length === 1;
    } catch {
      return false;
    }
  }
  function selectorFor(el) {
    if (el.id && isUnique(`#${escapeSelector(el.id)}`)) {
      return `#${escapeSelector(el.id)}`;
    }
    const attrs = ["data-surface-anchor", "data-testid", "data-test", "data-id"];
    for (const attr of attrs) {
      const value = el.getAttribute(attr);
      if (value) {
        const selector = `[${attr}="${escapeSelector(value)}"]`;
        if (isUnique(selector)) return selector;
      }
    }
    if (el === document.body) return "body";
    const parts = [];
    let node = el;
    while (node && node.nodeType === 1 && node !== document.body) {
      if (node.id && isUnique(`#${escapeSelector(node.id)}`)) {
        parts.unshift(`#${escapeSelector(node.id)}`);
        break;
      }
      let part = node.tagName.toLowerCase();
      const parent = node.parentElement;
      if (parent) {
        const siblings = [];
        for (let i = 0; i < parent.children.length; i++) {
          const child = parent.children[i];
          if (child.tagName === node.tagName) siblings.push(child);
        }
        if (siblings.length > 1) {
          part += `:nth-of-type(${siblings.indexOf(node) + 1})`;
        }
      }
      parts.unshift(part);
      node = node.parentElement;
    }
    return parts.join(" > ");
  }
  function rectFor(selector) {
    let el;
    try {
      el = document.querySelector(selector);
    } catch {
      return { selector, rect: null };
    }
    if (!el) return { selector, rect: null };
    const r = el.getBoundingClientRect();
    return {
      selector,
      rect: { x: r.left, y: r.top, width: r.width, height: r.height }
    };
  }
  function scrollToSelector(selector) {
    let el;
    try {
      el = document.querySelector(selector);
    } catch {
      return;
    }
    if (el) el.scrollIntoView({ behavior: "smooth", block: "center" });
  }
  var overlay = null;
  function showHighlight(el) {
    if (!overlay) {
      overlay = document.createElement("div");
      overlay.style.cssText = "position:fixed;z-index:2147483647;pointer-events:none;border:2px solid #2563eb;background:rgba(37,99,235,.08);border-radius:3px";
      document.body.appendChild(overlay);
    }
    const r = el.getBoundingClientRect();
    overlay.style.left = `${r.left}px`;
    overlay.style.top = `${r.top}px`;
    overlay.style.width = `${r.width}px`;
    overlay.style.height = `${r.height}px`;
    overlay.style.display = "block";
  }
  function hideHighlight() {
    if (overlay) overlay.style.display = "none";
  }

  // src/review/review.ts
  var CHANNEL = "surface-review";
  var VERSION = 1;
  var log = createLogger("SurfaceReview");
  function initReview() {
    const token = new URLSearchParams(window.location.search).get(
      "surface_review"
    );
    if (!token || window.parent === window) return;
    let parentOrigin = null;
    let reviewing = false;
    let raf = 0;
    let pinnedEl = null;
    function send(payload) {
      if (!parentOrigin) return;
      window.parent.postMessage({ ...payload, channel: CHANNEL }, parentOrigin);
    }
    function onMessage(e) {
      const m = e.data;
      if (!m || m.channel !== CHANNEL) return;
      if (m.type === "hello") {
        if (parentOrigin) return;
        if (m.token !== token) return;
        parentOrigin = e.origin;
        window.addEventListener("scroll", onViewport, true);
        window.addEventListener("resize", onViewport);
        document.addEventListener("click", onNavClick, true);
        log.info("ready");
        send({ type: "ready", version: VERSION });
        return;
      }
      if (e.origin !== parentOrigin) return;
      if (m.type === "enter-review") enter();
      else if (m.type === "exit-review") exit();
      else if (m.type === "resume-review") resume();
      else if (m.type === "request-rects") {
        send({ type: "rects", rects: (m.selectors ?? []).map(rectFor) });
      } else if (m.type === "scroll-to") {
        scrollToSelector(m.selector);
      }
    }
    function enter() {
      if (reviewing) return;
      reviewing = true;
      document.documentElement.style.cursor = "crosshair";
      document.addEventListener("mousemove", onMove, true);
      document.addEventListener("click", onClick, true);
    }
    function exit() {
      reviewing = false;
      pinnedEl = null;
      document.documentElement.style.cursor = "";
      hideHighlight();
      document.removeEventListener("mousemove", onMove, true);
      document.removeEventListener("click", onClick, true);
    }
    function resume() {
      pinnedEl = null;
      hideHighlight();
    }
    function onMove(e) {
      if (pinnedEl) return;
      if (e.target instanceof Element) showHighlight(e.target);
    }
    function onClick(e) {
      e.preventDefault();
      e.stopPropagation();
      if (pinnedEl) return;
      const el = e.target;
      if (!(el instanceof Element)) return;
      pinnedEl = el;
      showHighlight(el);
      const r = el.getBoundingClientRect();
      send({
        type: "element-clicked",
        selector: selectorFor(el),
        x: e.clientX,
        y: e.clientY,
        scrollY: window.scrollY,
        rect: { x: r.left, y: r.top, width: r.width, height: r.height }
      });
    }
    function onViewport() {
      if (raf) return;
      raf = requestAnimationFrame(() => {
        raf = 0;
        if (pinnedEl) showHighlight(pinnedEl);
        send({ type: "viewport" });
      });
    }
    function onNavClick(e) {
      const target = e.target;
      const anchor = target instanceof Element ? target.closest("a[href]") : null;
      if (!anchor) return;
      const href = anchor.getAttribute("href");
      if (!href || href.charAt(0) === "#") return;
      let dest;
      try {
        dest = new URL(href, window.location.href);
      } catch {
        return;
      }
      if (dest.href.split("#")[0] === window.location.href.split("#")[0]) return;
      e.preventDefault();
      e.stopPropagation();
    }
    window.addEventListener("message", onMessage);
  }

  // src/stub-queue.ts
  var RELAYED_METHODS = [
    "showSurfaceForm",
    "hideSurfaceForm",
    "initializeEmbed"
  ];
  var log2 = createLogger("Surface Stub Queue");
  function drainStubQueue() {
    const w3 = window;
    if (!Array.isArray(w3.SurfaceTagQueue)) return;
    const entries2 = w3.SurfaceTagQueue;
    w3.SurfaceTagQueue = { push: processEntry };
    entries2.forEach(processEntry);
  }
  function processEntry(entry) {
    try {
      if (entry?.type === "consent") {
        setSurfaceConsent(entry.args?.[0] ?? {});
        return;
      }
      if (entry?.type !== "embed") return;
      const [src, embedType, targetClass, options] = Array.from(entry.args ?? []);
      const embed = new SurfaceEmbed(
        src,
        embedType,
        targetClass,
        {
          // The captured script attribute only fills in when the caller didn't
          // pass questionId explicitly — same precedence as direct construction.
          ...entry.questionId ? { questionId: entry.questionId } : {},
          ...options ?? {}
        }
      );
      for (const method of entry.calls ?? []) {
        if (RELAYED_METHODS.includes(method)) embed[method]();
      }
      if (entry.stub && typeof entry.stub === "object") {
        for (const method of RELAYED_METHODS) {
          entry.stub[method] = () => embed[method]();
        }
      }
    } catch (error) {
      log2.error({ message: "Failed to replay queued call", error });
    }
  }

  // src/index.ts
  var scriptTag = document.currentScript;
  var runtimeConfig2 = initializeSurfaceRuntimeConfig(scriptTag);
  var environmentId2 = getSiteIdFromScript(scriptTag);
  setEnvironmentId(environmentId2);
  var SurfaceTagStore = new SurfaceStore(environmentId2, runtimeConfig2);
  var w2 = window;
  w2.SurfaceEmbed = SurfaceEmbed;
  w2.SurfaceExternalForm = SurfaceExternalForm;
  w2.SurfaceTagStore = SurfaceTagStore;
  w2.SurfaceIdentifyLead = identifyLead;
  w2.SurfaceSetLeadDataWithTTL = setLeadDataWithTTL;
  w2.SurfaceGetLeadDataWithTTL = getLeadDataWithTTL;
  w2.SurfaceGetSiteIdFromScript = getSiteIdFromScript;
  w2.SurfaceSetConsent = setSurfaceConsent;
  w2.SurfaceSetLanguage = (language) => SurfaceTagStore.setLanguage(language);
  onSurfaceConsentChange(() => {
    SurfaceTagStore.sendConsentToIframes();
    SurfaceTagStore.applyConsent();
    SurfaceTagStore.sendPayloadToIframes("STORE_UPDATE");
  });
  void resolveOpenTriggersOnLoad(environmentId2, runtimeConfig2);
  initReview();
  drainStubQueue();
})();