@brainfish-ai/widgets-initiator 1.12.0 → 1.13.2

package/dist/web.es.js

@@ -0,0 +1,2023 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+;
+!function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "13ff9fe0-f844-427a-8e83-9c170fcd5721", e._sentryDebugIdIdentifier = "sentry-dbid-13ff9fe0-f844-427a-8e83-9c170fcd5721");
+  } catch (e2) {
+  }
+}();
+class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+var _global = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : {};
+_global.SENTRY_RELEASE = { id: "38135ed0031eaede9a94159dc2d9a3e6df84467d" };
+var WidgetType;
+(function(WidgetType2) {
+  WidgetType2["Sidebar"] = "sidebar";
+  WidgetType2["Searchbar"] = "searchbar";
+  WidgetType2["Popup"] = "popup";
+})(WidgetType || (WidgetType = {}));
+({
+  [WidgetType.Sidebar]: "brainfish-sidebar-widget",
+  [WidgetType.Searchbar]: "brainfish-searchbar-widget",
+  [WidgetType.Popup]: "brainfish-popup-widget"
+});
+class BrainfishWidgetError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    __publicField(this, "cause");
+    this.name = "BrainfishWidgetError";
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, BrainfishWidgetError);
+    }
+    if (this.cause instanceof Error && this.cause.stack) {
+      this.stack = this.stack + "\nCaused by: " + this.cause.stack;
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      cause: this.cause instanceof Error ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : this.cause
+    };
+  }
+}
+var ActionType;
+(function(ActionType2) {
+  ActionType2["LINK"] = "link";
+  ActionType2["CALLBACK"] = "callback";
+  ActionType2["EMAIL"] = "email";
+  ActionType2["PHONE"] = "phone";
+})(ActionType || (ActionType = {}));
+const sendErrors = (apiHost, error, widgetKey) => {
+  if (!navigator || navigator.userAgent.toLowerCase().includes("headless")) {
+    return;
+  }
+  const errorData = error.toJSON();
+  const API_HOST = apiHost || "https://app.brainfi.sh";
+  fetch(`${API_HOST}/api/trackError.widget.create`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "api-key": widgetKey
+    },
+    body: JSON.stringify({
+      error: `WebWidgetVersion: ${"1.13.2"}. ${error.message}`,
+      stack: error.stack,
+      cause: {
+        message: errorData.message,
+        stack: errorData.stack,
+        cause: errorData.cause
+      }
+    })
+  });
+};
+const sendBrainfishWidgetError = (apiHost, error, message, widgetKey) => {
+  let errorMessage = message;
+  let errorDetails = {};
+  if (error instanceof Error) {
+    try {
+      errorDetails = JSON.parse(error.message);
+      errorMessage += ` - ${errorDetails.message || error.message}`;
+    } catch {
+      errorMessage += ` - ${error.message}`;
+    }
+  } else {
+    errorMessage += ` - ${String(error)}`;
+  }
+  const err = new BrainfishWidgetError(errorMessage, {
+    cause: errorDetails
+  });
+  sendErrors(apiHost, err, widgetKey);
+};
+async function fetchWithErrorHandling(apiHost, endpoint, widgetKey) {
+  const maxRetries = 3;
+  const delay = 500;
+  let attempt = 0;
+  let lastError;
+  while (attempt < maxRetries) {
+    try {
+      const response = await fetch(`${apiHost}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "api-key": widgetKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`API call failed with status: ${response.status}`);
+      }
+      const data = await response.json();
+      if (!data) {
+        throw new Error("Error loading config: empty response");
+      }
+      return data;
+    } catch (error) {
+      lastError = error;
+      attempt++;
+      if (attempt >= maxRetries) {
+        sendBrainfishWidgetError(
+          apiHost,
+          error,
+          "Error fetching config",
+          widgetKey
+        );
+        throw lastError;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+const getConfigByKey = async ({
+  widgetKey,
+  apiHost
+}) => {
+  const endpoint = `/api/searchWidgets.getConfigByKey`;
+  return fetchWithErrorHandling(apiHost, endpoint, widgetKey);
+};
+const mapActionButtons = (actionButtons) => actionButtons.map(
+  (action) => action.type === ActionType.CALLBACK && action.value ? { ...action, value: new Function(`return ${action.value}`)() } : action
+);
+const updateActions = (configActions = [], overrideActions) => {
+  const actionMap = new Map(
+    configActions.map((action) => [action.label, action])
+  );
+  overrideActions.forEach((action) => actionMap.set(action.label, action));
+  return Array.from(actionMap.values());
+};
+const transformConfig = ({
+  config,
+  apiKey,
+  apiHost
+}) => {
+  const settings = config.settings || {};
+  ["bodyActionButtons", "footerActionButtons", "nextBestActions"].forEach((key) => {
+    if (settings[key]) {
+      settings[key] = mapActionButtons(
+        settings[key]
+      );
+    }
+  });
+  return {
+    ...config,
+    settings,
+    apiHost,
+    widgetMode: config.widgetType,
+    apiKey
+  };
+};
+const getApiHost = (overrides) => {
+  return overrides?.apiHost || "https://app.brainfi.sh";
+};
+const getWidgetHost = (overrides) => {
+  return overrides?.widgetHost || "https://agent.brainfi.sh";
+};
+const getAnalyticsApiHost = (overrides) => {
+  return overrides?.analyticsApiHost || "";
+};
+const loadSearchWidgetScript = async (url) => {
+  if (document.getElementById("brainfish-widget")) {
+    return window.Brainfish;
+  }
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.id = "brainfish-widget";
+    script.src = url;
+    script.type = "module";
+    script.async = true;
+    script.crossOrigin = "anonymous";
+    script.onload = () => {
+      setTimeout(() => {
+        const module = window.Brainfish;
+        module ? resolve(module) : reject(new Error("Failed to load Brainfish module"));
+      }, 200);
+    };
+    script.onerror = (event) => {
+      const errorEvent = event;
+      const errorDetails = {
+        message: `Failed to load script: ${url}`,
+        type: errorEvent.type,
+        fileName: errorEvent.filename,
+        lineNumber: errorEvent.lineno,
+        columnNumber: errorEvent.colno,
+        error: errorEvent.error ? errorEvent.error.toString() : "Unknown error"
+      };
+      reject(new Error(JSON.stringify(errorDetails)));
+    };
+    document.head.appendChild(script);
+  });
+};
+const init = async ({
+  apiHost,
+  widgetKey,
+  version
+}) => {
+  try {
+    const url = `https://cdn.jsdelivr.net/npm/@brainfish-ai/search-widget@${version}/dist/web.js`;
+    const widget = await loadSearchWidgetScript(url);
+    return { widget };
+  } catch (error) {
+    sendBrainfishWidgetError(
+      apiHost,
+      error,
+      error.message,
+      widgetKey
+    );
+  }
+};
+function initializeWidget(widget, config) {
+  if (config.widgetType === WidgetType.Searchbar || config.widgetType === "Search") {
+    widget.SearchWidget.initStandard(config);
+  } else {
+    widget.HelpWidget.initPopup(config);
+  }
+}
+const initializedWidgets$1 = /* @__PURE__ */ new Set();
+const initSearchWidget = async (options, config) => {
+  const apiHost = getApiHost(options.overrides);
+  try {
+    if (initializedWidgets$1.has(options.widgetKey)) {
+      return void 0;
+    }
+    const result = await init({
+      apiHost,
+      widgetKey: options.widgetKey,
+      version: config.version || "latest"
+    });
+    if (result) {
+      const { widget } = result;
+      const transformedConfig = transformConfig({
+        config,
+        apiKey: options.widgetKey,
+        apiHost
+      });
+      if (options.overrides && config.settings) {
+        Object.entries(options.overrides).forEach(([key, value]) => {
+          if (config.settings && key in config.settings) {
+            config.settings[key] = updateActions(
+              config.settings[key],
+              value
+            );
+          }
+        });
+      }
+      initializeWidget(widget, transformedConfig);
+      initializedWidgets$1.add(options.widgetKey);
+      return widget;
+    }
+  } catch (error) {
+    sendBrainfishWidgetError(
+      apiHost,
+      error,
+      error.message,
+      options.widgetKey
+    );
+  }
+  return void 0;
+};
+const ANALYTICS_API_HOST = "";
+let isTrackerInitialized = false;
+const loadTrackerScript = async (apiHost, widgetKey) => {
+  if (document.getElementById("brainfish-analytics")) {
+    return window.BrainfishAnalytics;
+  }
+  const script = document.createElement("script");
+  script.id = "brainfish-analytics";
+  script.src = `https://cdn.jsdelivr.net/npm/@brainfish-ai/web-tracker@latest/dist/tracker.js`;
+  script.type = "module";
+  script.async = true;
+  script.crossOrigin = "anonymous";
+  script.onerror = () => {
+    sendBrainfishWidgetError(
+      apiHost,
+      new Error(`Failed to load script: ${script.src}`),
+      `Failed to load script: ${script.src}`,
+      widgetKey
+    );
+  };
+  document.head.appendChild(script);
+};
+const isDoNotTrackEnabled = () => {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    return false;
+  }
+  const dntEnabledValues = ["1", "yes", "true"];
+  const nav = navigator;
+  const win = window;
+  const dnt = (nav.doNotTrack || // Standard
+  win.doNotTrack || // IE11, Edge
+  nav.msDoNotTrack || // IE9, IE10
+  "0").toString().toLowerCase();
+  return dntEnabledValues.includes(dnt);
+};
+const initBrainfishAnalytics = async (widgetKey, accessKey, apiHost, analyticsApiHost = ANALYTICS_API_HOST, enableRecording = false, recordingBlocklist = [], _allowLocalhostRecording, _allowScreenRecording) => {
+  if (!accessKey) {
+    sendBrainfishWidgetError(
+      apiHost,
+      new Error("Access key is required"),
+      "Access key is required",
+      widgetKey
+    );
+  }
+  if (isTrackerInitialized) {
+    return;
+  }
+  try {
+    const isDNTEnabled = isDoNotTrackEnabled();
+    window.BrainfishAnalytics("init", {
+      apiUrl: analyticsApiHost,
+      accessKey,
+      trackScreenViews: true,
+      trackAttributes: !isDNTEnabled,
+      trackOutgoingLinks: !isDNTEnabled,
+      enableRecording: !isDNTEnabled && enableRecording,
+      recordingBlocklist,
+      _allowLocalhostRecording,
+      _allowScreenRecording
+    });
+    isTrackerInitialized = true;
+    await loadTrackerScript(apiHost, widgetKey);
+  } catch (error) {
+    sendBrainfishWidgetError(
+      apiHost,
+      error,
+      "Failed to initialize BrainfishAnalytics",
+      widgetKey
+    );
+  }
+};
+function createBrainfishQueue() {
+  let queue = [];
+  let realBrainfish = null;
+  function queueOrExecute(method, args) {
+    if (realBrainfish) {
+      const parts = method.split(".");
+      let obj = realBrainfish;
+      for (let i = 0; i < parts.length - 1; i++) {
+        obj = obj[parts[i]];
+      }
+      const fn = obj[parts[parts.length - 1]];
+      if (typeof fn === "function") {
+        return fn.apply(obj, args);
+      }
+    } else {
+      queue.push([method, args]);
+    }
+  }
+  const brainfishQueue = {
+    Widgets: {
+      init: (...args) => queueOrExecute("Widgets.init", args),
+      identify: (...args) => queueOrExecute("Widgets.identify", args),
+      setSignedAttributes: (...args) => queueOrExecute("Widgets.setSignedAttributes", args),
+      open: () => queueOrExecute("Widgets.open", []),
+      close: () => queueOrExecute("Widgets.close", []),
+      isReady: false
+    },
+    SearchWidget: {
+      initStandard: (...args) => queueOrExecute("SearchWidget.initStandard", args)
+    },
+    HelpWidget: {
+      initPopup: (...args) => queueOrExecute("HelpWidget.initPopup", args),
+      close: (...args) => queueOrExecute("HelpWidget.close", args),
+      open: (...args) => queueOrExecute("HelpWidget.open", args),
+      toggle: (...args) => queueOrExecute("HelpWidget.toggle", args)
+    },
+    _setRealBrainfish: function(bf) {
+      realBrainfish = bf;
+      while (queue.length > 0) {
+        const [method, args] = queue.shift();
+        queueOrExecute(method, args);
+      }
+    }
+  };
+  return brainfishQueue;
+}
+const createQueues = () => {
+  if (window) {
+    window.BrainfishAnalytics = window.BrainfishAnalytics || function(...args) {
+      (window.BrainfishAnalytics.q = window.BrainfishAnalytics.q || []).push(
+        args
+      );
+    };
+  }
+};
+function createElementWithClass(tagName, className, attributes = {}) {
+  const element = document.createElement(tagName);
+  element.className = className;
+  Object.entries(attributes).forEach(([key, value]) => {
+    element.setAttribute(key, value);
+  });
+  return element;
+}
+const IFRAME_CONTAINER_CLASS = "bf-iframe-container";
+const TRIGGER_BUTTON_CLASS = "bf-trigger-button";
+function createTriggerButton(widgetKey, triggerButtonIcon) {
+  const button = createElementWithClass("button", TRIGGER_BUTTON_CLASS, {
+    id: `trigger-button-${widgetKey}`,
+    "aria-controls": IFRAME_CONTAINER_CLASS,
+    "aria-expanded": "false",
+    "data-name": TRIGGER_BUTTON_CLASS
+  });
+  const icon = createElementWithClass("div", "trigger-button-icon", {
+    "aria-hidden": "true"
+  });
+  if (!triggerButtonIcon) {
+    icon.innerHTML = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="currentColor" viewBox="0 0 256 256" class="close-icon">
+      <path d="M213.66,101.66l-80,80a8,8,0,0,1-11.32,0l-80-80A8,8,0,0,1,53.66,90.34L128,164.69l74.34-74.35a8,8,0,0,1,11.32,11.32Z"></path>
+    </svg>
+    <svg width="24" height="14" viewBox="0 0 24 14" fill="none" xmlns="http://www.w3.org/2000/svg" class="fish-icon visible">
+      <path fill-rule="evenodd" clip-rule="evenodd" d="M1.71844 10.3882L4.60606 6.98384L1.71844 3.58375C1.4014 3.21362 1.44424 2.65841 1.81269 2.33993C1.97978 2.1979 2.65242 1.98701 3.04657 2.43461L5.78425 5.65824C6.14281 5.29523 6.51693 4.95924 6.90479 4.65114C8.88976 3.07437 11.2345 2.22803 13.6931 2.22803C16.9492 2.22803 20.0039 3.71718 22.2917 6.41142C22.5702 6.74282 22.5702 7.22916 22.2917 7.56056C20.0039 10.2591 16.9492 11.744 13.6931 11.744C11.2348 11.744 8.89035 10.8948 6.90554 9.31995C6.51741 9.01199 6.14304 8.67628 5.78425 8.31374L3.04657 11.5374C2.72953 11.9075 2.18114 11.9505 1.81269 11.632C1.44852 11.3179 1.40568 10.7584 1.71844 10.3882ZM5.93026 10.4683C8.17161 12.2599 10.8546 13.25 13.6931 13.25C17.4881 13.25 21.019 11.4034 23.4447 8.52942C24.1873 7.64571 24.1843 6.31801 23.4397 5.43663C20.8944 2.43919 17.4337 0.722025 13.6931 0.722025C10.8555 0.722025 8.17194 1.70845 5.92952 3.50276L4.17682 1.43933C3.57943 0.760929 2.79325 0.630009 2.25286 0.662947C1.98116 0.679506 1.73125 0.736852 1.51895 0.811846C1.26839 0.900352 1.03017 1.02718 0.827835 1.20058C-0.165283 2.05903 -0.283916 3.561 0.574656 4.56345L2.63075 6.98445L0.568104 9.41623C-0.272133 10.4106 -0.166523 11.9125 0.827835 12.7714C1.81372 13.6243 3.34308 13.5062 4.19036 12.5171L5.93026 10.4683Z" fill="currentColor"/>
+    </svg>
+  `;
+  } else {
+    icon.innerHTML = `
+      <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="currentColor" viewBox="0 0 256 256" class="close-icon">
+        <path d="M213.66,101.66l-80,80a8,8,0,0,1-11.32,0l-80-80A8,8,0,0,1,53.66,90.34L128,164.69l74.34-74.35a8,8,0,0,1,11.32,11.32Z"></path>
+      </svg>
+      <img src="${triggerButtonIcon}" class="fish-icon visible" alt="Trigger button icon" height="32" width="32" aria-hidden="true" aria-label="help button icon" />
+    `;
+  }
+  button.setAttribute("aria-label", "Open Brainfish widget");
+  button.appendChild(icon);
+  return { button, icon };
+}
+function createIframeContainer(widgetUrl) {
+  const iframeContainer = createElementWithClass(
+    "div",
+    IFRAME_CONTAINER_CLASS,
+    {
+      id: IFRAME_CONTAINER_CLASS,
+      "aria-live": "polite",
+      "aria-hidden": "true"
+    }
+  );
+  const loadingIndicator = createElementWithClass("div", "iframe-loading-indicator");
+  const spinner = createElementWithClass("div", "spinner");
+  loadingIndicator.setAttribute("aria-label", "Loading content");
+  loadingIndicator.setAttribute("role", "status");
+  loadingIndicator.appendChild(spinner);
+  iframeContainer.appendChild(loadingIndicator);
+  const iframe = createElementWithClass("iframe", "trigger-iframe", {
+    src: widgetUrl,
+    sandbox: "allow-scripts allow-same-origin allow-popups allow-forms",
+    allow: "clipboard-write",
+    role: "dialog"
+  });
+  iframe.style.opacity = "0";
+  iframe.addEventListener("load", () => {
+    loadingIndicator.style.display = "none";
+    iframe.style.opacity = "1";
+  });
+  iframe.addEventListener("error", (error) => {
+    console.error("Error loading iframe:", error);
+    loadingIndicator.innerHTML = "";
+    const errorIcon = createElementWithClass("div", "loading-error");
+    loadingIndicator.appendChild(errorIcon);
+    loadingIndicator.setAttribute("aria-label", "Failed to load content");
+  });
+  iframeContainer.appendChild(iframe);
+  return { iframeContainer, iframe };
+}
+function toggleIframeSize() {
+  const iframeContainer = document.querySelector(
+    `.${IFRAME_CONTAINER_CLASS}`
+  );
+  if (iframeContainer.classList.contains("expanded")) {
+    iframeContainer.classList.remove("expanded");
+  } else {
+    iframeContainer.classList.add("expanded");
+  }
+}
+const MOBILE_BREAKPOINT = 576;
+class IframeStateManager {
+  static get isWidgetOpen() {
+    return this.isOpen;
+  }
+  static initialize({
+    button,
+    icon,
+    isButtonHidden
+  }) {
+    this.button = button || null;
+    this.icon = icon || null;
+    this.isButtonHidden = isButtonHidden || false;
+    if (button) {
+      button.addEventListener("click", () => this.toggleIframeVisibility());
+    }
+    if (window.Brainfish?.HelpWidget) {
+      window.Brainfish.HelpWidget.close = () => this.closeWidget();
+      window.Brainfish.HelpWidget.open = () => this.openWidget();
+    }
+    if (window.Brainfish?.Widgets) {
+      window.Brainfish.Widgets.open = () => this.openWidget();
+      window.Brainfish.Widgets.close = () => this.closeWidget();
+    }
+  }
+  static toggleIframeVisibility() {
+    this.isOpen = !this.isOpen;
+    if (this.isOpen) {
+      this.openWidget();
+    } else {
+      this.closeWidget();
+    }
+  }
+  // Open the widget programmatically
+  static openWidget() {
+    this.isOpen = true;
+    const iframeContainer = document.querySelector(".bf-iframe-container");
+    const iframe = iframeContainer?.querySelector("iframe");
+    iframeContainer?.classList.add("open");
+    iframeContainer?.setAttribute("aria-hidden", "false");
+    iframe?.contentWindow?.postMessage({ type: "FOCUS_SEARCH_FIELD" }, "*");
+    if (this.button && this.icon) {
+      const fishIconSVG = this.icon.querySelector(".fish-icon");
+      const closeIconSVG = this.icon.querySelector(".close-icon");
+      this.button.setAttribute("aria-expanded", "true");
+      fishIconSVG.classList.remove("visible");
+      closeIconSVG.classList.add("visible");
+      if (document.body.clientWidth <= MOBILE_BREAKPOINT) {
+        this.hideTriggerButton();
+      }
+    }
+    window.dispatchEvent(new Event("onBrainfishWidgetOpen"));
+    window.BrainfishAnalytics("track", "Open Widget");
+  }
+  // Close the widget programmatically
+  static closeWidget() {
+    this.isOpen = false;
+    const iframeContainer = document.querySelector(".bf-iframe-container");
+    iframeContainer?.classList.remove("open");
+    iframeContainer?.setAttribute("aria-hidden", "true");
+    if (this.button && this.icon) {
+      this.button.setAttribute("aria-expanded", "false");
+      const fishIconSVG = this.icon.querySelector(".fish-icon");
+      const closeIconSVG = this.icon.querySelector(".close-icon");
+      fishIconSVG.classList.add("visible");
+      closeIconSVG.classList.remove("visible");
+      if (document.body.clientWidth <= MOBILE_BREAKPOINT) {
+        this.showTriggerButton();
+      }
+    }
+    window.dispatchEvent(new Event("onBrainfishWidgetClose"));
+    window.BrainfishAnalytics("track", "Close Widget");
+  }
+  static showTriggerButton() {
+    this.button?.classList.remove("hidden");
+  }
+  static hideTriggerButton() {
+    this.button?.classList.add("hidden");
+  }
+}
+__publicField(IframeStateManager, "isOpen", false);
+__publicField(IframeStateManager, "button", null);
+__publicField(IframeStateManager, "icon", null);
+__publicField(IframeStateManager, "isButtonHidden", false);
+function initMessageListener({
+  widgetHost,
+  apiHost,
+  widgetKey,
+  signal
+}) {
+  const messageHandler = (event) => {
+    if (event.origin !== widgetHost) return;
+    const { type } = event.data;
+    if (type === "TOGGLE_WIDGET_SIZE") {
+      toggleIframeSize();
+    }
+    if (type === "TRACK_EVENT") {
+      if (!window.BrainfishAnalytics) return;
+      const { eventName, data } = event.data;
+      window.BrainfishAnalytics("track", eventName, data);
+    }
+    if (type === "CLOSE_WIDGET") {
+      window.BrainfishAnalytics("track", "Close Widget");
+      IframeStateManager.toggleIframeVisibility();
+    }
+    if (type === "NEXT_BEST_ACTION_CLICKED") {
+      const { action, searchQueryId, query, answer } = event.data;
+      const context = { action, searchQueryId };
+      if (!["function", "callback"].includes(action.type)) {
+        console.error("Invalid action type", action);
+        return;
+      }
+      window.__bfCallbacks = window.__bfCallbacks || {};
+      if (window.__bfCallbacks[action.id]) {
+        window.__bfCallbacks[action.id](query, answer, context);
+        return;
+      }
+      const scriptUrl = `${apiHost}/api/searchWidgets.callback.codeblocks?apiKey=${widgetKey}&codeblockId=${action.id}`;
+      const script = document.createElement("script");
+      script.src = scriptUrl;
+      document.head.appendChild(script);
+      script.onload = () => {
+        window.__bfCallbacks[action.id](query, answer, context);
+        setTimeout(() => {
+          document.head.removeChild(script);
+        }, 300);
+      };
+    }
+  };
+  window.addEventListener("message", messageHandler, { signal });
+}
+const styles = '.bf-trigger-button{position:fixed;bottom:16px;right:16px;width:36px;height:36px;border-radius:50%;border:none;box-shadow:0 1px 6px #0000000f,0 2px 32px #00000029;transition:transform 167ms cubic-bezier(.33,0,0,1);box-sizing:content-box;display:flex;align-items:center;justify-content:center;cursor:pointer;z-index:1000;padding:12px;gap:10px;overflow:hidden}.bf-trigger-button.hidden{display:none}.trigger-button-icon{display:flex;align-items:center;justify-content:center;width:36px;height:36px;position:relative}.trigger-button-icon svg{width:100%;height:100%;position:absolute;inset:0}.trigger-button-icon>svg>path{transition:transform .3s ease,opacity .3s ease;transform:scale(.5);transform-origin:center;opacity:0}.trigger-button-icon .fish-icon{display:none}.trigger-button-icon .fish-icon.visible{display:block}.trigger-button-icon svg.visible{display:block}.trigger-button-icon>svg.visible>path{opacity:1;transform:scale(1)}.trigger-iframe{position:relative;width:100%;height:100%;border:none;outline:none;transform:translateZ(0)}.bf-iframe-container{display:none;position:fixed;z-index:2147483000000;background-color:#fff;bottom:0;right:0;width:100vw;height:100vh;border:none;overflow:hidden;opacity:0;pointer-events:none;transform:translateY(20px);transition:opacity .3s ease,transform .3s ease,width .2s ease-in-out,height .2s ease-in-out}.bf-iframe-container.open{display:block;opacity:1;transform:translateY(0);pointer-events:auto;top:0;left:0}@media (min-width: 576px){.bf-iframe-container{bottom:80px;right:24px;width:448px;height:min(750px,calc(100vh - 80px));border-radius:8px;border:1px solid var(--Dark-300, #D4D4D4);box-shadow:0 20px 25px -5px #1212171a,0 10px 10px -5px #1212170a}.bf-iframe-container.open{top:unset;left:unset}.bf-iframe-container.expanded{width:min(calc(448px * 1.35),calc(100vw - 16px));height:min(calc(750px * 1.35),calc(100vh - 80px))}}.iframe-loading-indicator{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);display:flex;align-items:center;justify-content:center;z-index:10}.spinner{width:24px;height:24px;border:2px solid rgba(0,0,0,.1);border-radius:50%;border-top-color:#3498db;animation:spin 1s ease-in-out infinite}@keyframes spin{to{transform:rotate(360deg)}}.loading-error{width:24px;height:24px;position:relative;display:flex;align-items:center;justify-content:center}.loading-error:before,.loading-error:after{content:"";position:absolute;width:16px;height:2px;background-color:#e74c3c;border-radius:2px}.loading-error:before{transform:rotate(45deg)}.loading-error:after{transform:rotate(-45deg)}';
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var getLuminance$1 = { exports: {} };
+var parseToRgb = { exports: {} };
+var _hslToRgb = { exports: {} };
+var hasRequired_hslToRgb;
+function require_hslToRgb() {
+  if (hasRequired_hslToRgb) return _hslToRgb.exports;
+  hasRequired_hslToRgb = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    function colorToInt(color) {
+      return Math.round(color * 255);
+    }
+    function convertToInt(red, green, blue) {
+      return colorToInt(red) + "," + colorToInt(green) + "," + colorToInt(blue);
+    }
+    function hslToRgb(hue, saturation, lightness, convert) {
+      if (convert === void 0) {
+        convert = convertToInt;
+      }
+      if (saturation === 0) {
+        return convert(lightness, lightness, lightness);
+      }
+      var huePrime = (hue % 360 + 360) % 360 / 60;
+      var chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+      var secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));
+      var red = 0;
+      var green = 0;
+      var blue = 0;
+      if (huePrime >= 0 && huePrime < 1) {
+        red = chroma;
+        green = secondComponent;
+      } else if (huePrime >= 1 && huePrime < 2) {
+        red = secondComponent;
+        green = chroma;
+      } else if (huePrime >= 2 && huePrime < 3) {
+        green = chroma;
+        blue = secondComponent;
+      } else if (huePrime >= 3 && huePrime < 4) {
+        green = secondComponent;
+        blue = chroma;
+      } else if (huePrime >= 4 && huePrime < 5) {
+        red = secondComponent;
+        blue = chroma;
+      } else if (huePrime >= 5 && huePrime < 6) {
+        red = chroma;
+        blue = secondComponent;
+      }
+      var lightnessModification = lightness - chroma / 2;
+      var finalRed = red + lightnessModification;
+      var finalGreen = green + lightnessModification;
+      var finalBlue = blue + lightnessModification;
+      return convert(finalRed, finalGreen, finalBlue);
+    }
+    exports["default"] = hslToRgb;
+    module.exports = exports.default;
+  })(_hslToRgb, _hslToRgb.exports);
+  return _hslToRgb.exports;
+}
+var _nameToHex = { exports: {} };
+var hasRequired_nameToHex;
+function require_nameToHex() {
+  if (hasRequired_nameToHex) return _nameToHex.exports;
+  hasRequired_nameToHex = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var namedColorMap = {
+      aliceblue: "f0f8ff",
+      antiquewhite: "faebd7",
+      aqua: "00ffff",
+      aquamarine: "7fffd4",
+      azure: "f0ffff",
+      beige: "f5f5dc",
+      bisque: "ffe4c4",
+      black: "000",
+      blanchedalmond: "ffebcd",
+      blue: "0000ff",
+      blueviolet: "8a2be2",
+      brown: "a52a2a",
+      burlywood: "deb887",
+      cadetblue: "5f9ea0",
+      chartreuse: "7fff00",
+      chocolate: "d2691e",
+      coral: "ff7f50",
+      cornflowerblue: "6495ed",
+      cornsilk: "fff8dc",
+      crimson: "dc143c",
+      cyan: "00ffff",
+      darkblue: "00008b",
+      darkcyan: "008b8b",
+      darkgoldenrod: "b8860b",
+      darkgray: "a9a9a9",
+      darkgreen: "006400",
+      darkgrey: "a9a9a9",
+      darkkhaki: "bdb76b",
+      darkmagenta: "8b008b",
+      darkolivegreen: "556b2f",
+      darkorange: "ff8c00",
+      darkorchid: "9932cc",
+      darkred: "8b0000",
+      darksalmon: "e9967a",
+      darkseagreen: "8fbc8f",
+      darkslateblue: "483d8b",
+      darkslategray: "2f4f4f",
+      darkslategrey: "2f4f4f",
+      darkturquoise: "00ced1",
+      darkviolet: "9400d3",
+      deeppink: "ff1493",
+      deepskyblue: "00bfff",
+      dimgray: "696969",
+      dimgrey: "696969",
+      dodgerblue: "1e90ff",
+      firebrick: "b22222",
+      floralwhite: "fffaf0",
+      forestgreen: "228b22",
+      fuchsia: "ff00ff",
+      gainsboro: "dcdcdc",
+      ghostwhite: "f8f8ff",
+      gold: "ffd700",
+      goldenrod: "daa520",
+      gray: "808080",
+      green: "008000",
+      greenyellow: "adff2f",
+      grey: "808080",
+      honeydew: "f0fff0",
+      hotpink: "ff69b4",
+      indianred: "cd5c5c",
+      indigo: "4b0082",
+      ivory: "fffff0",
+      khaki: "f0e68c",
+      lavender: "e6e6fa",
+      lavenderblush: "fff0f5",
+      lawngreen: "7cfc00",
+      lemonchiffon: "fffacd",
+      lightblue: "add8e6",
+      lightcoral: "f08080",
+      lightcyan: "e0ffff",
+      lightgoldenrodyellow: "fafad2",
+      lightgray: "d3d3d3",
+      lightgreen: "90ee90",
+      lightgrey: "d3d3d3",
+      lightpink: "ffb6c1",
+      lightsalmon: "ffa07a",
+      lightseagreen: "20b2aa",
+      lightskyblue: "87cefa",
+      lightslategray: "789",
+      lightslategrey: "789",
+      lightsteelblue: "b0c4de",
+      lightyellow: "ffffe0",
+      lime: "0f0",
+      limegreen: "32cd32",
+      linen: "faf0e6",
+      magenta: "f0f",
+      maroon: "800000",
+      mediumaquamarine: "66cdaa",
+      mediumblue: "0000cd",
+      mediumorchid: "ba55d3",
+      mediumpurple: "9370db",
+      mediumseagreen: "3cb371",
+      mediumslateblue: "7b68ee",
+      mediumspringgreen: "00fa9a",
+      mediumturquoise: "48d1cc",
+      mediumvioletred: "c71585",
+      midnightblue: "191970",
+      mintcream: "f5fffa",
+      mistyrose: "ffe4e1",
+      moccasin: "ffe4b5",
+      navajowhite: "ffdead",
+      navy: "000080",
+      oldlace: "fdf5e6",
+      olive: "808000",
+      olivedrab: "6b8e23",
+      orange: "ffa500",
+      orangered: "ff4500",
+      orchid: "da70d6",
+      palegoldenrod: "eee8aa",
+      palegreen: "98fb98",
+      paleturquoise: "afeeee",
+      palevioletred: "db7093",
+      papayawhip: "ffefd5",
+      peachpuff: "ffdab9",
+      peru: "cd853f",
+      pink: "ffc0cb",
+      plum: "dda0dd",
+      powderblue: "b0e0e6",
+      purple: "800080",
+      rebeccapurple: "639",
+      red: "f00",
+      rosybrown: "bc8f8f",
+      royalblue: "4169e1",
+      saddlebrown: "8b4513",
+      salmon: "fa8072",
+      sandybrown: "f4a460",
+      seagreen: "2e8b57",
+      seashell: "fff5ee",
+      sienna: "a0522d",
+      silver: "c0c0c0",
+      skyblue: "87ceeb",
+      slateblue: "6a5acd",
+      slategray: "708090",
+      slategrey: "708090",
+      snow: "fffafa",
+      springgreen: "00ff7f",
+      steelblue: "4682b4",
+      tan: "d2b48c",
+      teal: "008080",
+      thistle: "d8bfd8",
+      tomato: "ff6347",
+      turquoise: "40e0d0",
+      violet: "ee82ee",
+      wheat: "f5deb3",
+      white: "fff",
+      whitesmoke: "f5f5f5",
+      yellow: "ff0",
+      yellowgreen: "9acd32"
+    };
+    function nameToHex(color) {
+      if (typeof color !== "string") return color;
+      var normalizedColorName = color.toLowerCase();
+      return namedColorMap[normalizedColorName] ? "#" + namedColorMap[normalizedColorName] : color;
+    }
+    exports["default"] = nameToHex;
+    module.exports = exports.default;
+  })(_nameToHex, _nameToHex.exports);
+  return _nameToHex.exports;
+}
+var _errors = { exports: {} };
+var hasRequired_errors;
+function require_errors() {
+  if (hasRequired_errors) return _errors.exports;
+  hasRequired_errors = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    function _assertThisInitialized(self2) {
+      if (self2 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self2;
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      _setPrototypeOf(subClass, superClass);
+    }
+    function _wrapNativeSuper(Class) {
+      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+        if (typeof Class2 !== "function") {
+          throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+          if (_cache.has(Class2)) return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+        return _setPrototypeOf(Wrapper, Class2);
+      };
+      return _wrapNativeSuper(Class);
+    }
+    function _construct(t, e, r) {
+      if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+      var o = [null];
+      o.push.apply(o, e);
+      var p = new (t.bind.apply(t, o))();
+      return r && _setPrototypeOf(p, r.prototype), p;
+    }
+    function _isNativeReflectConstruct() {
+      try {
+        var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+      } catch (t2) {
+      }
+      return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+        return !!t;
+      })();
+    }
+    function _isNativeFunction(fn) {
+      try {
+        return Function.toString.call(fn).indexOf("[native code]") !== -1;
+      } catch (e) {
+        return typeof fn === "function";
+      }
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      };
+      return _getPrototypeOf(o);
+    }
+    var ERRORS = {
+      "1": "Passed invalid arguments to hsl, please pass multiple numbers e.g. hsl(360, 0.75, 0.4) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75 }).\n\n",
+      "2": "Passed invalid arguments to hsla, please pass multiple numbers e.g. hsla(360, 0.75, 0.4, 0.7) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75, alpha: 0.7 }).\n\n",
+      "3": "Passed an incorrect argument to a color function, please pass a string representation of a color.\n\n",
+      "4": "Couldn't generate valid rgb string from %s, it returned %s.\n\n",
+      "5": "Couldn't parse the color string. Please provide the color as a string in hex, rgb, rgba, hsl or hsla notation.\n\n",
+      "6": "Passed invalid arguments to rgb, please pass multiple numbers e.g. rgb(255, 205, 100) or an object e.g. rgb({ red: 255, green: 205, blue: 100 }).\n\n",
+      "7": "Passed invalid arguments to rgba, please pass multiple numbers e.g. rgb(255, 205, 100, 0.75) or an object e.g. rgb({ red: 255, green: 205, blue: 100, alpha: 0.75 }).\n\n",
+      "8": "Passed invalid argument to toColorString, please pass a RgbColor, RgbaColor, HslColor or HslaColor object.\n\n",
+      "9": "Please provide a number of steps to the modularScale helper.\n\n",
+      "10": "Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\n\n",
+      "11": 'Invalid value passed as base to modularScale, expected number or em string but got "%s"\n\n',
+      "12": 'Expected a string ending in "px" or a number passed as the first argument to %s(), got "%s" instead.\n\n',
+      "13": 'Expected a string ending in "px" or a number passed as the second argument to %s(), got "%s" instead.\n\n',
+      "14": 'Passed invalid pixel value ("%s") to %s(), please pass a value like "12px" or 12.\n\n',
+      "15": 'Passed invalid base value ("%s") to %s(), please pass a value like "12px" or 12.\n\n',
+      "16": "You must provide a template to this method.\n\n",
+      "17": "You passed an unsupported selector state to this method.\n\n",
+      "18": "minScreen and maxScreen must be provided as stringified numbers with the same units.\n\n",
+      "19": "fromSize and toSize must be provided as stringified numbers with the same units.\n\n",
+      "20": "expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\n\n",
+      "21": "expects the objects in the first argument array to have the properties `prop`, `fromSize`, and `toSize`.\n\n",
+      "22": "expects the first argument object to have the properties `prop`, `fromSize`, and `toSize`.\n\n",
+      "23": "fontFace expects a name of a font-family.\n\n",
+      "24": "fontFace expects either the path to the font file(s) or a name of a local copy.\n\n",
+      "25": "fontFace expects localFonts to be an array.\n\n",
+      "26": "fontFace expects fileFormats to be an array.\n\n",
+      "27": "radialGradient requries at least 2 color-stops to properly render.\n\n",
+      "28": "Please supply a filename to retinaImage() as the first argument.\n\n",
+      "29": "Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\n\n",
+      "30": "Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\n\n",
+      "31": "The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation\n\n",
+      "32": "To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s')\n\n",
+      "33": "The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation\n\n",
+      "34": "borderRadius expects a radius value as a string or number as the second argument.\n\n",
+      "35": 'borderRadius expects one of "top", "bottom", "left" or "right" as the first argument.\n\n',
+      "36": "Property must be a string value.\n\n",
+      "37": "Syntax Error at %s.\n\n",
+      "38": "Formula contains a function that needs parentheses at %s.\n\n",
+      "39": "Formula is missing closing parenthesis at %s.\n\n",
+      "40": "Formula has too many closing parentheses at %s.\n\n",
+      "41": "All values in a formula must have the same unit or be unitless.\n\n",
+      "42": "Please provide a number of steps to the modularScale helper.\n\n",
+      "43": "Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\n\n",
+      "44": "Invalid value passed as base to modularScale, expected number or em/rem string but got %s.\n\n",
+      "45": "Passed invalid argument to hslToColorString, please pass a HslColor or HslaColor object.\n\n",
+      "46": "Passed invalid argument to rgbToColorString, please pass a RgbColor or RgbaColor object.\n\n",
+      "47": "minScreen and maxScreen must be provided as stringified numbers with the same units.\n\n",
+      "48": "fromSize and toSize must be provided as stringified numbers with the same units.\n\n",
+      "49": "Expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\n\n",
+      "50": "Expects the objects in the first argument array to have the properties prop, fromSize, and toSize.\n\n",
+      "51": "Expects the first argument object to have the properties prop, fromSize, and toSize.\n\n",
+      "52": "fontFace expects either the path to the font file(s) or a name of a local copy.\n\n",
+      "53": "fontFace expects localFonts to be an array.\n\n",
+      "54": "fontFace expects fileFormats to be an array.\n\n",
+      "55": "fontFace expects a name of a font-family.\n\n",
+      "56": "linearGradient requries at least 2 color-stops to properly render.\n\n",
+      "57": "radialGradient requries at least 2 color-stops to properly render.\n\n",
+      "58": "Please supply a filename to retinaImage() as the first argument.\n\n",
+      "59": "Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\n\n",
+      "60": "Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\n\n",
+      "61": "Property must be a string value.\n\n",
+      "62": "borderRadius expects a radius value as a string or number as the second argument.\n\n",
+      "63": 'borderRadius expects one of "top", "bottom", "left" or "right" as the first argument.\n\n',
+      "64": "The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation.\n\n",
+      "65": "To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s').\n\n",
+      "66": "The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation.\n\n",
+      "67": "You must provide a template to this method.\n\n",
+      "68": "You passed an unsupported selector state to this method.\n\n",
+      "69": 'Expected a string ending in "px" or a number passed as the first argument to %s(), got %s instead.\n\n',
+      "70": 'Expected a string ending in "px" or a number passed as the second argument to %s(), got %s instead.\n\n',
+      "71": 'Passed invalid pixel value %s to %s(), please pass a value like "12px" or 12.\n\n',
+      "72": 'Passed invalid base value %s to %s(), please pass a value like "12px" or 12.\n\n',
+      "73": "Please provide a valid CSS variable.\n\n",
+      "74": "CSS variable not found and no default was provided.\n\n",
+      "75": "important requires a valid style object, got a %s instead.\n\n",
+      "76": "fromSize and toSize must be provided as stringified numbers with the same units as minScreen and maxScreen.\n\n",
+      "77": 'remToPx expects a value in "rem" but you provided it in "%s".\n\n',
+      "78": 'base must be set in "px" or "%" but you set it in "%s".\n'
+    };
+    function format() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var a = args[0];
+      var b = [];
+      var c;
+      for (c = 1; c < args.length; c += 1) {
+        b.push(args[c]);
+      }
+      b.forEach(function(d) {
+        a = a.replace(/%[a-z]/, d);
+      });
+      return a;
+    }
+    exports["default"] = /* @__PURE__ */ function(_Error) {
+      _inheritsLoose(PolishedError, _Error);
+      function PolishedError(code) {
+        var _this;
+        if (process.env.NODE_ENV === "production") {
+          _this = _Error.call(this, "An error occurred. See https://github.com/styled-components/polished/blob/main/src/internalHelpers/errors.md#" + code + " for more information.") || this;
+        } else {
+          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+          _this = _Error.call(this, format.apply(void 0, [ERRORS[code]].concat(args))) || this;
+        }
+        return _assertThisInitialized(_this);
+      }
+      return PolishedError;
+    }(/* @__PURE__ */ _wrapNativeSuper(Error));
+    module.exports = exports.default;
+  })(_errors, _errors.exports);
+  return _errors.exports;
+}
+var hasRequiredParseToRgb;
+function requireParseToRgb() {
+  if (hasRequiredParseToRgb) return parseToRgb.exports;
+  hasRequiredParseToRgb = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = parseToRgb2;
+    var _hslToRgb2 = _interopRequireDefault(/* @__PURE__ */ require_hslToRgb());
+    var _nameToHex2 = _interopRequireDefault(/* @__PURE__ */ require_nameToHex());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var hexRegex = /^#[a-fA-F0-9]{6}$/;
+    var hexRgbaRegex = /^#[a-fA-F0-9]{8}$/;
+    var reducedHexRegex = /^#[a-fA-F0-9]{3}$/;
+    var reducedRgbaHexRegex = /^#[a-fA-F0-9]{4}$/;
+    var rgbRegex = /^rgb\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*\)$/i;
+    var rgbaRegex = /^rgb(?:a)?\(\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,)?\s*(\d{1,3})\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+    var hslRegex = /^hsl\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*\)$/i;
+    var hslaRegex = /^hsl(?:a)?\(\s*(\d{0,3}[.]?[0-9]+(?:deg)?)\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,)?\s*(\d{1,3}[.]?[0-9]?)%\s*(?:,|\/)\s*([-+]?\d*[.]?\d+[%]?)\s*\)$/i;
+    function parseToRgb2(color) {
+      if (typeof color !== "string") {
+        throw new _errors2["default"](3);
+      }
+      var normalizedColor = (0, _nameToHex2["default"])(color);
+      if (normalizedColor.match(hexRegex)) {
+        return {
+          red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+          green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+          blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16)
+        };
+      }
+      if (normalizedColor.match(hexRgbaRegex)) {
+        var alpha = parseFloat((parseInt("" + normalizedColor[7] + normalizedColor[8], 16) / 255).toFixed(2));
+        return {
+          red: parseInt("" + normalizedColor[1] + normalizedColor[2], 16),
+          green: parseInt("" + normalizedColor[3] + normalizedColor[4], 16),
+          blue: parseInt("" + normalizedColor[5] + normalizedColor[6], 16),
+          alpha
+        };
+      }
+      if (normalizedColor.match(reducedHexRegex)) {
+        return {
+          red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+          green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+          blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16)
+        };
+      }
+      if (normalizedColor.match(reducedRgbaHexRegex)) {
+        var _alpha = parseFloat((parseInt("" + normalizedColor[4] + normalizedColor[4], 16) / 255).toFixed(2));
+        return {
+          red: parseInt("" + normalizedColor[1] + normalizedColor[1], 16),
+          green: parseInt("" + normalizedColor[2] + normalizedColor[2], 16),
+          blue: parseInt("" + normalizedColor[3] + normalizedColor[3], 16),
+          alpha: _alpha
+        };
+      }
+      var rgbMatched = rgbRegex.exec(normalizedColor);
+      if (rgbMatched) {
+        return {
+          red: parseInt("" + rgbMatched[1], 10),
+          green: parseInt("" + rgbMatched[2], 10),
+          blue: parseInt("" + rgbMatched[3], 10)
+        };
+      }
+      var rgbaMatched = rgbaRegex.exec(normalizedColor.substring(0, 50));
+      if (rgbaMatched) {
+        return {
+          red: parseInt("" + rgbaMatched[1], 10),
+          green: parseInt("" + rgbaMatched[2], 10),
+          blue: parseInt("" + rgbaMatched[3], 10),
+          alpha: parseFloat("" + rgbaMatched[4]) > 1 ? parseFloat("" + rgbaMatched[4]) / 100 : parseFloat("" + rgbaMatched[4])
+        };
+      }
+      var hslMatched = hslRegex.exec(normalizedColor);
+      if (hslMatched) {
+        var hue = parseInt("" + hslMatched[1], 10);
+        var saturation = parseInt("" + hslMatched[2], 10) / 100;
+        var lightness = parseInt("" + hslMatched[3], 10) / 100;
+        var rgbColorString = "rgb(" + (0, _hslToRgb2["default"])(hue, saturation, lightness) + ")";
+        var hslRgbMatched = rgbRegex.exec(rgbColorString);
+        if (!hslRgbMatched) {
+          throw new _errors2["default"](4, normalizedColor, rgbColorString);
+        }
+        return {
+          red: parseInt("" + hslRgbMatched[1], 10),
+          green: parseInt("" + hslRgbMatched[2], 10),
+          blue: parseInt("" + hslRgbMatched[3], 10)
+        };
+      }
+      var hslaMatched = hslaRegex.exec(normalizedColor.substring(0, 50));
+      if (hslaMatched) {
+        var _hue = parseInt("" + hslaMatched[1], 10);
+        var _saturation = parseInt("" + hslaMatched[2], 10) / 100;
+        var _lightness = parseInt("" + hslaMatched[3], 10) / 100;
+        var _rgbColorString = "rgb(" + (0, _hslToRgb2["default"])(_hue, _saturation, _lightness) + ")";
+        var _hslRgbMatched = rgbRegex.exec(_rgbColorString);
+        if (!_hslRgbMatched) {
+          throw new _errors2["default"](4, normalizedColor, _rgbColorString);
+        }
+        return {
+          red: parseInt("" + _hslRgbMatched[1], 10),
+          green: parseInt("" + _hslRgbMatched[2], 10),
+          blue: parseInt("" + _hslRgbMatched[3], 10),
+          alpha: parseFloat("" + hslaMatched[4]) > 1 ? parseFloat("" + hslaMatched[4]) / 100 : parseFloat("" + hslaMatched[4])
+        };
+      }
+      throw new _errors2["default"](5);
+    }
+    module.exports = exports.default;
+  })(parseToRgb, parseToRgb.exports);
+  return parseToRgb.exports;
+}
+var hasRequiredGetLuminance;
+function requireGetLuminance() {
+  if (hasRequiredGetLuminance) return getLuminance$1.exports;
+  hasRequiredGetLuminance = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = getLuminance2;
+    var _parseToRgb = _interopRequireDefault(/* @__PURE__ */ requireParseToRgb());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function getLuminance2(color) {
+      if (color === "transparent") return 0;
+      var rgbColor = (0, _parseToRgb["default"])(color);
+      var _Object$keys$map = Object.keys(rgbColor).map(function(key) {
+        var channel = rgbColor[key] / 255;
+        return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);
+      }), r = _Object$keys$map[0], g = _Object$keys$map[1], b = _Object$keys$map[2];
+      return parseFloat((0.2126 * r + 0.7152 * g + 0.0722 * b).toFixed(3));
+    }
+    module.exports = exports.default;
+  })(getLuminance$1, getLuminance$1.exports);
+  return getLuminance$1.exports;
+}
+var getLuminanceExports = /* @__PURE__ */ requireGetLuminance();
+const getLuminance = /* @__PURE__ */ getDefaultExportFromCjs(getLuminanceExports);
+var darken$1 = { exports: {} };
+var _curry = { exports: {} };
+var hasRequired_curry;
+function require_curry() {
+  if (hasRequired_curry) return _curry.exports;
+  hasRequired_curry = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = curry;
+    function curried(f, length, acc) {
+      return function fn() {
+        var combined = acc.concat(Array.prototype.slice.call(arguments));
+        return combined.length >= length ? f.apply(this, combined) : curried(f, length, combined);
+      };
+    }
+    function curry(f) {
+      return curried(f, f.length, []);
+    }
+    module.exports = exports.default;
+  })(_curry, _curry.exports);
+  return _curry.exports;
+}
+var _guard = { exports: {} };
+var hasRequired_guard;
+function require_guard() {
+  if (hasRequired_guard) return _guard.exports;
+  hasRequired_guard = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    function guard(lowerBoundary, upperBoundary, value) {
+      return Math.max(lowerBoundary, Math.min(upperBoundary, value));
+    }
+    exports["default"] = guard;
+    module.exports = exports.default;
+  })(_guard, _guard.exports);
+  return _guard.exports;
+}
+var parseToHsl = { exports: {} };
+var _rgbToHsl = { exports: {} };
+var hasRequired_rgbToHsl;
+function require_rgbToHsl() {
+  if (hasRequired_rgbToHsl) return _rgbToHsl.exports;
+  hasRequired_rgbToHsl = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    function rgbToHsl(color) {
+      var red = color.red / 255;
+      var green = color.green / 255;
+      var blue = color.blue / 255;
+      var max = Math.max(red, green, blue);
+      var min = Math.min(red, green, blue);
+      var lightness = (max + min) / 2;
+      if (max === min) {
+        if (color.alpha !== void 0) {
+          return {
+            hue: 0,
+            saturation: 0,
+            lightness,
+            alpha: color.alpha
+          };
+        } else {
+          return {
+            hue: 0,
+            saturation: 0,
+            lightness
+          };
+        }
+      }
+      var hue;
+      var delta = max - min;
+      var saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+      switch (max) {
+        case red:
+          hue = (green - blue) / delta + (green < blue ? 6 : 0);
+          break;
+        case green:
+          hue = (blue - red) / delta + 2;
+          break;
+        default:
+          hue = (red - green) / delta + 4;
+          break;
+      }
+      hue *= 60;
+      if (color.alpha !== void 0) {
+        return {
+          hue,
+          saturation,
+          lightness,
+          alpha: color.alpha
+        };
+      }
+      return {
+        hue,
+        saturation,
+        lightness
+      };
+    }
+    exports["default"] = rgbToHsl;
+    module.exports = exports.default;
+  })(_rgbToHsl, _rgbToHsl.exports);
+  return _rgbToHsl.exports;
+}
+var hasRequiredParseToHsl;
+function requireParseToHsl() {
+  if (hasRequiredParseToHsl) return parseToHsl.exports;
+  hasRequiredParseToHsl = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = parseToHsl2;
+    var _parseToRgb = _interopRequireDefault(/* @__PURE__ */ requireParseToRgb());
+    var _rgbToHsl2 = _interopRequireDefault(/* @__PURE__ */ require_rgbToHsl());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function parseToHsl2(color) {
+      return (0, _rgbToHsl2["default"])((0, _parseToRgb["default"])(color));
+    }
+    module.exports = exports.default;
+  })(parseToHsl, parseToHsl.exports);
+  return parseToHsl.exports;
+}
+var toColorString = { exports: {} };
+var hsl = { exports: {} };
+var _hslToHex = { exports: {} };
+var _reduceHexValue = { exports: {} };
+var hasRequired_reduceHexValue;
+function require_reduceHexValue() {
+  if (hasRequired_reduceHexValue) return _reduceHexValue.exports;
+  hasRequired_reduceHexValue = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var reduceHexValue = function reduceHexValue2(value) {
+      if (value.length === 7 && value[1] === value[2] && value[3] === value[4] && value[5] === value[6]) {
+        return "#" + value[1] + value[3] + value[5];
+      }
+      return value;
+    };
+    exports["default"] = reduceHexValue;
+    module.exports = exports.default;
+  })(_reduceHexValue, _reduceHexValue.exports);
+  return _reduceHexValue.exports;
+}
+var _numberToHex = { exports: {} };
+var hasRequired_numberToHex;
+function require_numberToHex() {
+  if (hasRequired_numberToHex) return _numberToHex.exports;
+  hasRequired_numberToHex = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    function numberToHex(value) {
+      var hex = value.toString(16);
+      return hex.length === 1 ? "0" + hex : hex;
+    }
+    exports["default"] = numberToHex;
+    module.exports = exports.default;
+  })(_numberToHex, _numberToHex.exports);
+  return _numberToHex.exports;
+}
+var hasRequired_hslToHex;
+function require_hslToHex() {
+  if (hasRequired_hslToHex) return _hslToHex.exports;
+  hasRequired_hslToHex = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _hslToRgb2 = _interopRequireDefault(/* @__PURE__ */ require_hslToRgb());
+    var _reduceHexValue2 = _interopRequireDefault(/* @__PURE__ */ require_reduceHexValue());
+    var _numberToHex2 = _interopRequireDefault(/* @__PURE__ */ require_numberToHex());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function colorToHex(color) {
+      return (0, _numberToHex2["default"])(Math.round(color * 255));
+    }
+    function convertToHex(red, green, blue) {
+      return (0, _reduceHexValue2["default"])("#" + colorToHex(red) + colorToHex(green) + colorToHex(blue));
+    }
+    function hslToHex(hue, saturation, lightness) {
+      return (0, _hslToRgb2["default"])(hue, saturation, lightness, convertToHex);
+    }
+    exports["default"] = hslToHex;
+    module.exports = exports.default;
+  })(_hslToHex, _hslToHex.exports);
+  return _hslToHex.exports;
+}
+var hasRequiredHsl;
+function requireHsl() {
+  if (hasRequiredHsl) return hsl.exports;
+  hasRequiredHsl = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = hsl2;
+    var _hslToHex2 = _interopRequireDefault(/* @__PURE__ */ require_hslToHex());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function hsl2(value, saturation, lightness) {
+      if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number") {
+        return (0, _hslToHex2["default"])(value, saturation, lightness);
+      } else if (typeof value === "object" && saturation === void 0 && lightness === void 0) {
+        return (0, _hslToHex2["default"])(value.hue, value.saturation, value.lightness);
+      }
+      throw new _errors2["default"](1);
+    }
+    module.exports = exports.default;
+  })(hsl, hsl.exports);
+  return hsl.exports;
+}
+var hsla = { exports: {} };
+var hasRequiredHsla;
+function requireHsla() {
+  if (hasRequiredHsla) return hsla.exports;
+  hasRequiredHsla = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = hsla2;
+    var _hslToHex2 = _interopRequireDefault(/* @__PURE__ */ require_hslToHex());
+    var _hslToRgb2 = _interopRequireDefault(/* @__PURE__ */ require_hslToRgb());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function hsla2(value, saturation, lightness, alpha) {
+      if (typeof value === "number" && typeof saturation === "number" && typeof lightness === "number" && typeof alpha === "number") {
+        return alpha >= 1 ? (0, _hslToHex2["default"])(value, saturation, lightness) : "rgba(" + (0, _hslToRgb2["default"])(value, saturation, lightness) + "," + alpha + ")";
+      } else if (typeof value === "object" && saturation === void 0 && lightness === void 0 && alpha === void 0) {
+        return value.alpha >= 1 ? (0, _hslToHex2["default"])(value.hue, value.saturation, value.lightness) : "rgba(" + (0, _hslToRgb2["default"])(value.hue, value.saturation, value.lightness) + "," + value.alpha + ")";
+      }
+      throw new _errors2["default"](2);
+    }
+    module.exports = exports.default;
+  })(hsla, hsla.exports);
+  return hsla.exports;
+}
+var rgb = { exports: {} };
+var hasRequiredRgb;
+function requireRgb() {
+  if (hasRequiredRgb) return rgb.exports;
+  hasRequiredRgb = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = rgb2;
+    var _reduceHexValue2 = _interopRequireDefault(/* @__PURE__ */ require_reduceHexValue());
+    var _numberToHex2 = _interopRequireDefault(/* @__PURE__ */ require_numberToHex());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function rgb2(value, green, blue) {
+      if (typeof value === "number" && typeof green === "number" && typeof blue === "number") {
+        return (0, _reduceHexValue2["default"])("#" + (0, _numberToHex2["default"])(value) + (0, _numberToHex2["default"])(green) + (0, _numberToHex2["default"])(blue));
+      } else if (typeof value === "object" && green === void 0 && blue === void 0) {
+        return (0, _reduceHexValue2["default"])("#" + (0, _numberToHex2["default"])(value.red) + (0, _numberToHex2["default"])(value.green) + (0, _numberToHex2["default"])(value.blue));
+      }
+      throw new _errors2["default"](6);
+    }
+    module.exports = exports.default;
+  })(rgb, rgb.exports);
+  return rgb.exports;
+}
+var rgba = { exports: {} };
+var hasRequiredRgba;
+function requireRgba() {
+  if (hasRequiredRgba) return rgba.exports;
+  hasRequiredRgba = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = rgba2;
+    var _parseToRgb = _interopRequireDefault(/* @__PURE__ */ requireParseToRgb());
+    var _rgb = _interopRequireDefault(/* @__PURE__ */ requireRgb());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function rgba2(firstValue, secondValue, thirdValue, fourthValue) {
+      if (typeof firstValue === "string" && typeof secondValue === "number") {
+        var rgbValue = (0, _parseToRgb["default"])(firstValue);
+        return "rgba(" + rgbValue.red + "," + rgbValue.green + "," + rgbValue.blue + "," + secondValue + ")";
+      } else if (typeof firstValue === "number" && typeof secondValue === "number" && typeof thirdValue === "number" && typeof fourthValue === "number") {
+        return fourthValue >= 1 ? (0, _rgb["default"])(firstValue, secondValue, thirdValue) : "rgba(" + firstValue + "," + secondValue + "," + thirdValue + "," + fourthValue + ")";
+      } else if (typeof firstValue === "object" && secondValue === void 0 && thirdValue === void 0 && fourthValue === void 0) {
+        return firstValue.alpha >= 1 ? (0, _rgb["default"])(firstValue.red, firstValue.green, firstValue.blue) : "rgba(" + firstValue.red + "," + firstValue.green + "," + firstValue.blue + "," + firstValue.alpha + ")";
+      }
+      throw new _errors2["default"](7);
+    }
+    module.exports = exports.default;
+  })(rgba, rgba.exports);
+  return rgba.exports;
+}
+var hasRequiredToColorString;
+function requireToColorString() {
+  if (hasRequiredToColorString) return toColorString.exports;
+  hasRequiredToColorString = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = toColorString2;
+    var _hsl = _interopRequireDefault(/* @__PURE__ */ requireHsl());
+    var _hsla = _interopRequireDefault(/* @__PURE__ */ requireHsla());
+    var _rgb = _interopRequireDefault(/* @__PURE__ */ requireRgb());
+    var _rgba = _interopRequireDefault(/* @__PURE__ */ requireRgba());
+    var _errors2 = _interopRequireDefault(/* @__PURE__ */ require_errors());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var isRgb = function isRgb2(color) {
+      return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+    };
+    var isRgba = function isRgba2(color) {
+      return typeof color.red === "number" && typeof color.green === "number" && typeof color.blue === "number" && typeof color.alpha === "number";
+    };
+    var isHsl = function isHsl2(color) {
+      return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && (typeof color.alpha !== "number" || typeof color.alpha === "undefined");
+    };
+    var isHsla = function isHsla2(color) {
+      return typeof color.hue === "number" && typeof color.saturation === "number" && typeof color.lightness === "number" && typeof color.alpha === "number";
+    };
+    function toColorString2(color) {
+      if (typeof color !== "object") throw new _errors2["default"](8);
+      if (isRgba(color)) return (0, _rgba["default"])(color);
+      if (isRgb(color)) return (0, _rgb["default"])(color);
+      if (isHsla(color)) return (0, _hsla["default"])(color);
+      if (isHsl(color)) return (0, _hsl["default"])(color);
+      throw new _errors2["default"](8);
+    }
+    module.exports = exports.default;
+  })(toColorString, toColorString.exports);
+  return toColorString.exports;
+}
+var hasRequiredDarken;
+function requireDarken() {
+  if (hasRequiredDarken) return darken$1.exports;
+  hasRequiredDarken = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _curry2 = _interopRequireDefault(/* @__PURE__ */ require_curry());
+    var _guard2 = _interopRequireDefault(/* @__PURE__ */ require_guard());
+    var _parseToHsl = _interopRequireDefault(/* @__PURE__ */ requireParseToHsl());
+    var _toColorString = _interopRequireDefault(/* @__PURE__ */ requireToColorString());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function darken2(amount, color) {
+      if (color === "transparent") return color;
+      var hslColor = (0, _parseToHsl["default"])(color);
+      return (0, _toColorString["default"])(_extends({}, hslColor, {
+        lightness: (0, _guard2["default"])(0, 1, hslColor.lightness - parseFloat(amount))
+      }));
+    }
+    var curriedDarken = (0, _curry2["default"])(darken2);
+    exports["default"] = curriedDarken;
+    module.exports = exports.default;
+  })(darken$1, darken$1.exports);
+  return darken$1.exports;
+}
+var darkenExports = /* @__PURE__ */ requireDarken();
+const darken = /* @__PURE__ */ getDefaultExportFromCjs(darkenExports);
+var lighten$1 = { exports: {} };
+var hasRequiredLighten;
+function requireLighten() {
+  if (hasRequiredLighten) return lighten$1.exports;
+  hasRequiredLighten = 1;
+  (function(module, exports) {
+    exports.__esModule = true;
+    exports["default"] = void 0;
+    var _curry2 = _interopRequireDefault(/* @__PURE__ */ require_curry());
+    var _guard2 = _interopRequireDefault(/* @__PURE__ */ require_guard());
+    var _parseToHsl = _interopRequireDefault(/* @__PURE__ */ requireParseToHsl());
+    var _toColorString = _interopRequireDefault(/* @__PURE__ */ requireToColorString());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _extends() {
+      _extends = Object.assign ? Object.assign.bind() : function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function lighten2(amount, color) {
+      if (color === "transparent") return color;
+      var hslColor = (0, _parseToHsl["default"])(color);
+      return (0, _toColorString["default"])(_extends({}, hslColor, {
+        lightness: (0, _guard2["default"])(0, 1, hslColor.lightness + parseFloat(amount))
+      }));
+    }
+    var curriedLighten = (0, _curry2["default"])(lighten2);
+    exports["default"] = curriedLighten;
+    module.exports = exports.default;
+  })(lighten$1, lighten$1.exports);
+  return lighten$1.exports;
+}
+var lightenExports = /* @__PURE__ */ requireLighten();
+const lighten = /* @__PURE__ */ getDefaultExportFromCjs(lightenExports);
+function insertStyles(primaryColor = "#000", foreground = "FFF") {
+  const style = document.createElement("style");
+  style.attributes.setNamedItem(document.createAttribute("data-widget-styles"));
+  const isLightButtonColor = getLuminance(primaryColor) > 0.5;
+  style.textContent = `
+    ${styles}
+    .${TRIGGER_BUTTON_CLASS} { background: ${primaryColor}; }
+    .${TRIGGER_BUTTON_CLASS}:hover {
+      background: ${isLightButtonColor ? darken(0.05, primaryColor) : lighten(0.05, primaryColor)};
+    }
+    .trigger-button-icon { color: ${foreground}; }
+  `;
+  document.head.appendChild(style);
+}
+function insertStylesIfNeeded(config) {
+  if (!document.querySelector("style[data-widget-styles]")) {
+    const buttonColor = config?.theme?.inputButtonBgColor || "#007bff";
+    const iconColor = config?.theme?.textBaseColor || "#ffffff";
+    insertStyles(buttonColor, iconColor);
+  }
+}
+function initColorSchemeListener(iframe, signal) {
+  const updateIframeBodyClass = (isDarkMode) => {
+    iframe.contentWindow?.postMessage(
+      { type: "UPDATE_BODY_CLASS", isDarkMode },
+      "*"
+    );
+  };
+  const checkAndUpdateDarkMode = () => {
+    const isDarkMode = document.body.classList.contains("dark");
+    updateIframeBodyClass(isDarkMode);
+  };
+  const observeBodyClassChanges = () => {
+    const observer = new MutationObserver(checkAndUpdateDarkMode);
+    observer.observe(document.body, {
+      attributes: true,
+      attributeFilter: ["class"]
+    });
+    signal.addEventListener("abort", () => observer.disconnect());
+  };
+  checkAndUpdateDarkMode();
+  observeBodyClassChanges();
+}
+function observeColorSchemeChanges(iframe, signal) {
+  const updateIframeBodyClass = (isMobile) => {
+    const message = { type: "UPDATE_BODY_CLASS", isMobile };
+    iframe.contentWindow?.postMessage(message, "*");
+    if (isMobile) {
+      if (IframeStateManager.isWidgetOpen) {
+        IframeStateManager.hideTriggerButton();
+      } else {
+        IframeStateManager.showTriggerButton();
+      }
+    }
+  };
+  let resizeTimeout;
+  const checkAndUpdateIsMobile = () => {
+    const isMobile = document.body.clientWidth <= MOBILE_BREAKPOINT;
+    updateIframeBodyClass(isMobile);
+  };
+  const debouncedCheckAndUpdateIsMobile = () => {
+    if (resizeTimeout) {
+      clearTimeout(resizeTimeout);
+    }
+    resizeTimeout = window.setTimeout(checkAndUpdateIsMobile, 300);
+  };
+  const observeBodyResize = () => {
+    const resizeObserver = new ResizeObserver(debouncedCheckAndUpdateIsMobile);
+    resizeObserver.observe(document.body);
+    signal.addEventListener("abort", () => resizeObserver.disconnect());
+  };
+  checkAndUpdateIsMobile();
+  observeBodyResize();
+}
+function base64Encode(text) {
+  const encoder = new TextEncoder();
+  const uint8Array = encoder.encode(text);
+  if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    const binaryString = Array.from(
+      uint8Array,
+      (byte) => String.fromCharCode(byte)
+    ).join("");
+    return btoa(binaryString);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(uint8Array).toString("base64");
+  }
+  throw new Error("[utils.base64Encode]: Unsupported environment");
+}
+const base64Decode = (text) => {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    const binaryString = atob(text);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(text, "base64").toString("utf-8");
+  }
+  throw new Error("[utils.base64Decode]: Unsupported environment");
+};
+const initializedWidgets = /* @__PURE__ */ new Set();
+function isWidgetInitialized(widgetKey) {
+  return initializedWidgets.has(widgetKey);
+}
+function isButtonExisting(widgetKey) {
+  return !!document.getElementById(`trigger-button-${widgetKey}`);
+}
+function createWidgetWithButton(widgetKey, widgetUrl, {
+  isButtonHidden,
+  triggerButtonIcon
+}) {
+  const fragment = document.createDocumentFragment();
+  if (!isButtonHidden) {
+    const { button, icon } = createTriggerButton(widgetKey, triggerButtonIcon);
+    fragment.appendChild(button);
+    IframeStateManager.initialize({ button, icon });
+  } else {
+    IframeStateManager.initialize({ isButtonHidden });
+  }
+  const { iframeContainer, iframe } = createIframeContainer(widgetUrl);
+  fragment.appendChild(iframeContainer);
+  return { fragment, iframe };
+}
+function handleInitializationError(apiHost, error, widgetKey) {
+  sendBrainfishWidgetError(apiHost, error, error.message, widgetKey);
+}
+const initIframeTrigger = (options, config) => {
+  const apiHost = getApiHost(options.overrides);
+  const widgetHost = getWidgetHost(options.overrides);
+  const { theme, settings } = config;
+  const encodedRules = base64Encode(
+    JSON.stringify(options.overrides?.redirectRules)
+  );
+  const widgetUrl = `${widgetHost}/?widgetKey=${options.widgetKey}#${new URLSearchParams({
+    theme: base64Encode(JSON.stringify(theme)),
+    settings: base64Encode(JSON.stringify(settings)),
+    redirectRules: encodedRules
+  }).toString()}`;
+  const isButtonHidden = settings?.hideTriggerButton;
+  const triggerButtonIcon = settings?.triggerButtonIcon;
+  try {
+    if (isWidgetInitialized(options.widgetKey)) return void 0;
+    if (isButtonExisting(options.widgetKey)) return void 0;
+    insertStylesIfNeeded(config);
+    const { fragment, iframe } = createWidgetWithButton(
+      options.widgetKey,
+      widgetUrl,
+      {
+        isButtonHidden: isButtonHidden || false,
+        triggerButtonIcon: triggerButtonIcon || ""
+      }
+    );
+    const controller = new AbortController();
+    const { signal } = controller;
+    iframe.onload = () => {
+      setTimeout(() => {
+        initColorSchemeListener(iframe, signal);
+        initMessageListener({
+          widgetHost,
+          apiHost,
+          widgetKey: options.widgetKey,
+          signal
+        });
+        observeColorSchemeChanges(iframe, signal);
+      }, 0);
+    };
+    document.body.appendChild(fragment);
+    initializedWidgets.add(options.widgetKey);
+    const cleanup = () => {
+      controller.abort();
+      window.removeEventListener("beforeunload", cleanup);
+    };
+    window.addEventListener("beforeunload", cleanup);
+    return void 0;
+  } catch (error) {
+    handleInitializationError(apiHost, error, options.widgetKey);
+  }
+  return void 0;
+};
+var HandOffType = /* @__PURE__ */ ((HandOffType2) => {
+  HandOffType2["FRESHCHAT"] = "freshchat";
+  HandOffType2["INTERCOM"] = "intercom";
+  HandOffType2["ZENDESK"] = "zendesk";
+  HandOffType2["HELPSCOUT"] = "helpscout";
+  return HandOffType2;
+})(HandOffType || {});
+const detectHandoff = (config) => {
+  const usesFreshChat = !!window.fcWidget;
+  if (usesFreshChat) {
+    return HandOffType.FRESHCHAT;
+  }
+  return null;
+};
+const initFreshChat = async () => {
+  if (!window.fcWidget) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  window.fcWidget.hide();
+  window.fcWidget.on("widget:closed", () => {
+    window.fcWidget.hide();
+  });
+};
+const initHandOffs = async (config) => {
+  if (config.widgetType === WidgetType.Popup) {
+    const handoffType = detectHandoff();
+    if (handoffType && handoffType === HandOffType.FRESHCHAT) {
+      await initFreshChat();
+    }
+  }
+};
+const scriptElementId = "brainfish-nudges";
+const loadNudgeWidgetScript = async (apiHost, widgetKey) => {
+  if (document.getElementById(scriptElementId)) {
+    return;
+  }
+  const script = document.createElement("script");
+  script.id = scriptElementId;
+  script.src = `https://cdn.jsdelivr.net/npm/@brainfish-ai/nudge-widget@latest/dist/index.js`;
+  script.type = "module";
+  script.async = true;
+  script.crossOrigin = "anonymous";
+  script.onerror = () => {
+    sendBrainfishWidgetError(
+      apiHost,
+      new Error(`Failed to load script: ${script.src}`),
+      `Failed to load script: ${script.src}`,
+      widgetKey
+    );
+  };
+  document.head.appendChild(script);
+};
+const initNudgeWidget = async (apiHost, widgetKey) => {
+  try {
+    await loadNudgeWidgetScript(apiHost, widgetKey);
+  } catch (error) {
+    sendBrainfishWidgetError(
+      apiHost,
+      error,
+      "Failed to initialize Nudge widget",
+      widgetKey
+    );
+  }
+};
+let globalBrainfish = null;
+function getBrainfishInstance() {
+  if (typeof window !== "undefined" && window.Brainfish) {
+    return window.Brainfish;
+  }
+  if (!globalBrainfish) {
+    globalBrainfish = createBrainfishQueue();
+    if (typeof window !== "undefined") {
+      window.Brainfish = globalBrainfish;
+    }
+  }
+  return globalBrainfish;
+}
+const Brainfish = getBrainfishInstance();
+let initializationPromise = null;
+async function initializeBrainfish(options, config, apiHost, analyticsApiHost) {
+  const enableRecording = options.overrides?.enableRecording || config?.settings?.enableRecording || false;
+  const requestedVersion = options.overrides?.version || config?.version;
+  const initPromises = [];
+  if (requestedVersion?.startsWith("2.")) {
+    initIframeTrigger(options, config);
+  } else {
+    initPromises.push(initSearchWidget(options, config));
+  }
+  initPromises.push(
+    initBrainfishAnalytics(
+      options.widgetKey,
+      config.trackingToken || "",
+      apiHost,
+      analyticsApiHost,
+      enableRecording,
+      config?.settings?.recordingBlocklist || [],
+      config?.settings?._allowLocalhostRecording,
+      config?.settings?._allowScreenRecording
+    )
+    // Even if this fails, it won't block the widget
+  );
+  initPromises.push(initNudgeWidget(apiHost, options.widgetKey));
+  const [widgetPromise] = await Promise.allSettled(initPromises);
+  if (widgetPromise && widgetPromise.status === "fulfilled" && widgetPromise.value) {
+    Brainfish._setRealBrainfish(widgetPromise.value);
+  }
+}
+Brainfish.Widgets.isReady = false;
+Brainfish.Widgets.identify = (userData) => {
+  window.BrainfishAnalytics("identify", userData);
+};
+Brainfish.Widgets.setSignedAttributes = (jwt) => {
+  try {
+    jwtDecode(jwt);
+  } catch (error) {
+    console.error("[Brainfish] Invalid JWT provided to setSignedAttributes:", error);
+    return;
+  }
+  const iframe = document.querySelector(
+    "#bf-iframe-container .trigger-iframe"
+  );
+  if (iframe) {
+    const sendMessage = () => {
+      if (iframe.contentWindow) {
+        iframe.contentWindow.postMessage(
+          {
+            type: "SET_SIGNED_ATTRIBUTES",
+            jwt
+          },
+          "*"
+        );
+      }
+    };
+    if (iframe.contentWindow) {
+      sendMessage();
+    }
+    iframe.addEventListener("load", sendMessage);
+  }
+};
+Brainfish.Widgets.init = async (options) => {
+  createQueues();
+  const apiHost = getApiHost(options.overrides);
+  const analyticsApiHost = getAnalyticsApiHost(options.overrides);
+  let config;
+  if (options.config) {
+    config = JSON.parse(base64Decode(options.config));
+  } else {
+    const { config: fetchedConfig } = await getConfigByKey({
+      widgetKey: options.widgetKey,
+      apiHost
+    });
+    config = fetchedConfig;
+  }
+  if (!initializationPromise) {
+    initializationPromise = initializeBrainfish(
+      options,
+      config,
+      apiHost,
+      analyticsApiHost
+    );
+  }
+  await initializationPromise;
+  await initHandOffs(config);
+  Brainfish.Widgets.isReady = true;
+  window.dispatchEvent(new Event("onBrainfishReady"));
+};
+const BrainfishAnalytics = (...args) => {
+  if (typeof window !== "undefined" && window.BrainfishAnalytics) {
+    window.BrainfishAnalytics(...args);
+  }
+};
+export {
+  BrainfishAnalytics,
+  Brainfish as default
+};
+//# sourceMappingURL=web.es.js.map