@nexvio-ai/widget-js 0.1.0

package/dist/react.cjs

@@ -0,0 +1,1550 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  NexvioChatbot: () => NexvioChatbot,
+  NexvioWidget: () => NexvioWidget,
+  useNexvioChatbot: () => useNexvioChatbot,
+  useNexvioWidget: () => useNexvioWidget
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/NexvioChatbot.tsx
+var React = __toESM(require("react"), 1);
+
+// src/react/useNexvioChatbot.ts
+var import_react2 = require("react");
+
+// src/utils/debug.ts
+function debugEnabled() {
+  try {
+    return typeof window !== "undefined" && window.__NEXVIO_WIDGET_DEBUG === true;
+  } catch {
+    return false;
+  }
+}
+function log(...args) {
+  if (debugEnabled()) console.log(...args);
+}
+function warn(...args) {
+  if (debugEnabled()) console.warn(...args);
+}
+function debug(...args) {
+  if (debugEnabled()) console.debug(...args);
+}
+
+// src/utils/EventEmitter.ts
+var _listeners;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
+  }
+  on(event, listener) {
+    if (!__privateGet(this, _listeners).has(event)) {
+      __privateGet(this, _listeners).set(event, /* @__PURE__ */ new Set());
+    }
+    __privateGet(this, _listeners).get(event)?.add(listener);
+  }
+  once(event, listener) {
+    const onceListener = (payload) => {
+      this.off(event, onceListener);
+      listener(payload);
+    };
+    this.on(event, onceListener);
+  }
+  emit(event, payload) {
+    __privateGet(this, _listeners).get(event)?.forEach((listener) => listener(payload));
+  }
+  off(event, listener) {
+    if (!listener) {
+      __privateGet(this, _listeners).delete(event);
+      return;
+    }
+    __privateGet(this, _listeners).get(event)?.delete(listener);
+  }
+  clear() {
+    __privateGet(this, _listeners).clear();
+  }
+};
+_listeners = new WeakMap();
+
+// src/utils/serializeError.ts
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  if (typeof error === "object" && error !== null) {
+    const obj = error;
+    return {
+      name: typeof obj.name === "string" ? obj.name : "Error",
+      message: typeof obj.message === "string" ? obj.message : "Unknown error",
+      stack: typeof obj.stack === "string" ? obj.stack : void 0,
+      metadata: Object.fromEntries(Object.entries(obj).filter(([key]) => !["name", "message", "stack"].includes(key)))
+    };
+  }
+  return {
+    name: "Error",
+    message: String(error)
+  };
+}
+function deserializeError(serialized) {
+  const error = new Error(serialized.message);
+  error.name = serialized.name;
+  if (serialized.stack) {
+    error.stack = serialized.stack;
+  }
+  return error;
+}
+
+// src/messenger/BaseMessenger.ts
+var MESSAGE_TOKEN = "__nexvioWidget";
+var DEFAULT_COMMAND_CAPABILITY = () => true;
+var _target, _targetOrigin, _handlers, _fetch, _events, _canReceiveCommand, _pending, _abortControllers, _BaseMessenger_instances, sendMessage_fn, sendCommand_fn, _handleMessage, isWidgetMessage_fn;
+var BaseMessenger = class {
+  constructor(config) {
+    __privateAdd(this, _BaseMessenger_instances);
+    __privateAdd(this, _target);
+    __privateAdd(this, _targetOrigin);
+    __privateAdd(this, _handlers);
+    __privateAdd(this, _fetch);
+    __privateAdd(this, _events, new EventEmitter());
+    __privateAdd(this, _canReceiveCommand);
+    __privateAdd(this, _pending, /* @__PURE__ */ new Map());
+    __privateAdd(this, _abortControllers, /* @__PURE__ */ new Map());
+    this.commands = new Proxy(
+      {},
+      {
+        get: (_, command) => {
+          return (payload, transfer) => {
+            return __privateMethod(this, _BaseMessenger_instances, sendCommand_fn).call(this, command, payload, transfer);
+          };
+        }
+      }
+    );
+    __privateAdd(this, _handleMessage, async (event) => {
+      debug("[NexvioWidget][Messenger] window.message", {
+        origin: event.origin,
+        hasToken: !!(event.data && typeof event.data === "object" && event.data[MESSAGE_TOKEN] === true)
+      });
+      if (!__privateMethod(this, _BaseMessenger_instances, isWidgetMessage_fn).call(this, event)) {
+        return;
+      }
+      const data = event.data;
+      switch (data.type) {
+        case "event": {
+          log("[NexvioWidget][Messenger] <- event", { event: data.event, payload: data.payload });
+          __privateGet(this, _events).emit(data.event, data.payload);
+          break;
+        }
+        case "response": {
+          const handler = __privateGet(this, _pending).get(data.nonce);
+          if (!handler) {
+            warn("[NexvioWidget][Messenger] missing pending handler for response", data.nonce);
+            return;
+          }
+          __privateGet(this, _pending).delete(data.nonce);
+          if (data.error) {
+            handler.reject(deserializeError(data.error));
+          } else {
+            handler.resolve(data.payload);
+          }
+          break;
+        }
+        case "command": {
+          if (!__privateGet(this, _canReceiveCommand).call(this, data.command)) {
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, {
+              type: "response",
+              nonce: data.nonce,
+              error: serializeError(new Error(`Command "${data.command}" is not supported by the host`))
+            });
+            return;
+          }
+          const commandCapitalized = `on${data.command.charAt(0).toUpperCase()}${data.command.slice(1)}`;
+          const handler = __privateGet(this, _handlers)[commandCapitalized];
+          if (!handler) {
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, {
+              type: "response",
+              nonce: data.nonce,
+              error: serializeError(new Error(`Command handler "${data.command}" not implemented by host`))
+            });
+            return;
+          }
+          try {
+            log("[NexvioWidget][Messenger] <- command", { command: data.command, payload: data.payload });
+            const result = await handler(data.payload);
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, { type: "response", nonce: data.nonce, payload: result });
+          } catch (error) {
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, {
+              type: "response",
+              nonce: data.nonce,
+              error: serializeError(error)
+            });
+          }
+          break;
+        }
+        case "fetch": {
+          log("[NexvioWidget][Messenger] <- fetch", { url: data.url });
+          const controller = new AbortController();
+          __privateGet(this, _abortControllers).set(data.nonce, controller);
+          try {
+            const response = await __privateGet(this, _fetch).call(this, data.url, {
+              ...data.init,
+              signal: controller.signal
+            });
+            const contentType = response.headers.get("content-type") ?? "";
+            let payload;
+            if (contentType.includes("application/json")) {
+              payload = await response.json();
+            } else {
+              payload = await response.text();
+            }
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, {
+              type: "response",
+              nonce: data.nonce,
+              payload: {
+                ok: response.ok,
+                status: response.status,
+                statusText: response.statusText,
+                headers: Object.fromEntries(response.headers.entries()),
+                body: payload
+              }
+            });
+          } catch (error) {
+            __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, {
+              type: "response",
+              nonce: data.nonce,
+              error: serializeError(error)
+            });
+          } finally {
+            __privateGet(this, _abortControllers).delete(data.nonce);
+          }
+          break;
+        }
+        case "abort": {
+          const controller = __privateGet(this, _abortControllers).get(data.nonce);
+          controller?.abort(data.reason);
+          __privateGet(this, _abortControllers).delete(data.nonce);
+          break;
+        }
+        default:
+          break;
+      }
+    });
+    __privateSet(this, _target, config.target);
+    __privateSet(this, _targetOrigin, config.targetOrigin);
+    __privateSet(this, _handlers, config.handlers);
+    __privateSet(this, _fetch, config.fetch ?? fetch.bind(globalThis));
+    __privateSet(this, _canReceiveCommand, config.canReceiveCommand ?? DEFAULT_COMMAND_CAPABILITY);
+  }
+  connect() {
+    log("[NexvioWidget][Messenger] connect", { targetOrigin: __privateGet(this, _targetOrigin) });
+    window.addEventListener("message", __privateGet(this, _handleMessage));
+  }
+  disconnect() {
+    log("[NexvioWidget][Messenger] disconnect");
+    window.removeEventListener("message", __privateGet(this, _handleMessage));
+    __privateGet(this, _events).clear();
+    __privateGet(this, _pending).clear();
+    __privateGet(this, _abortControllers).forEach((controller) => controller.abort());
+    __privateGet(this, _abortControllers).clear();
+  }
+  on(event, listener) {
+    __privateGet(this, _events).on(event, listener);
+  }
+  off(event, listener) {
+    __privateGet(this, _events).off(event, listener);
+  }
+};
+_target = new WeakMap();
+_targetOrigin = new WeakMap();
+_handlers = new WeakMap();
+_fetch = new WeakMap();
+_events = new WeakMap();
+_canReceiveCommand = new WeakMap();
+_pending = new WeakMap();
+_abortControllers = new WeakMap();
+_BaseMessenger_instances = new WeakSet();
+sendMessage_fn = function(message, transfer) {
+  const target = __privateGet(this, _target).call(this);
+  if (!target) {
+    throw new Error("Widget frame not ready");
+  }
+  const payload = { ...message, [MESSAGE_TOKEN]: true };
+  try {
+    debug("[NexvioWidget][Messenger] postMessage", {
+      type: message.type,
+      command: message.command,
+      targetOrigin: __privateGet(this, _targetOrigin)
+    });
+    target.postMessage(payload, __privateGet(this, _targetOrigin), transfer);
+  } catch (error) {
+    const shouldRetryWithAnyOrigin = __privateGet(this, _targetOrigin) !== "*" && error instanceof DOMException && (error.name === "SecurityError" || /target origin provided/i.test(error.message));
+    if (shouldRetryWithAnyOrigin) {
+      warn('[NexvioWidget][Messenger] SecurityError posting to targetOrigin. Retrying with "*"');
+      target.postMessage(payload, "*", transfer);
+      return;
+    }
+    throw error;
+  }
+};
+sendCommand_fn = async function(command, payload, transfer) {
+  const nonce = crypto.randomUUID();
+  return new Promise((resolve, reject) => {
+    __privateGet(this, _pending).set(nonce, { resolve, reject, stack: new Error().stack ?? "" });
+    try {
+      __privateMethod(this, _BaseMessenger_instances, sendMessage_fn).call(this, { type: "command", command, payload, nonce }, transfer);
+    } catch (error) {
+      __privateGet(this, _pending).delete(nonce);
+      reject(error);
+    }
+  });
+};
+_handleMessage = new WeakMap();
+isWidgetMessage_fn = function(event) {
+  if (!event.data || typeof event.data !== "object" || event.data[MESSAGE_TOKEN] !== true) {
+    return false;
+  }
+  const targetWin = __privateGet(this, _target).call(this);
+  if (targetWin && event.source && event.source !== targetWin) {
+    debug("[NexvioWidget][Messenger] drop message: source mismatch");
+    return false;
+  }
+  if (event.origin !== __privateGet(this, _targetOrigin)) {
+    if (targetWin && event.source === targetWin) {
+      warn("[NexvioWidget][Messenger] learning targetOrigin from first message", {
+        from: __privateGet(this, _targetOrigin),
+        to: event.origin
+      });
+      __privateSet(this, _targetOrigin, event.origin);
+    } else {
+      debug("[NexvioWidget][Messenger] drop message: origin mismatch", {
+        expected: __privateGet(this, _targetOrigin),
+        got: event.origin
+      });
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/messenger/WidgetFrameMessenger.ts
+var WidgetFrameMessenger = class extends BaseMessenger {
+  constructor(config) {
+    super({
+      target: config.target,
+      targetOrigin: config.targetOrigin,
+      handlers: config.handlers,
+      fetch: config.fetch,
+      canReceiveCommand: () => true
+    });
+  }
+};
+
+// src/utils/base64.ts
+function toBase64(input) {
+  if (typeof globalThis.btoa === "function") {
+    return globalThis.btoa(input);
+  }
+  const buffer = globalThis.Buffer;
+  if (buffer) {
+    return buffer.from(input, "binary").toString("base64");
+  }
+  throw new Error("No base64 encoder available in this environment");
+}
+function encodeBase64(value) {
+  if (value === void 0) {
+    throw new TypeError("encodeBase64: `undefined` cannot be serialized. Pass null instead.");
+  }
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return toBase64(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/utils/stripFunctions.ts
+function stripFunctions(input, cloneMap = /* @__PURE__ */ new WeakMap()) {
+  if (typeof input !== "object" || input === null) {
+    return input;
+  }
+  if (cloneMap.has(input)) {
+    return cloneMap.get(input);
+  }
+  if (Array.isArray(input)) {
+    const arrClone = [];
+    cloneMap.set(input, arrClone);
+    for (const item of input) {
+      arrClone.push(stripFunctions(item, cloneMap));
+    }
+    return arrClone;
+  }
+  const clone = {};
+  cloneMap.set(input, clone);
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "function") {
+      continue;
+    }
+    clone[key] = stripFunctions(value, cloneMap);
+  }
+  return clone;
+}
+
+// src/utils/zod-to-json-schema.ts
+function zodToJsonSchema(schema) {
+  if (!schema || !schema._def) {
+    return { type: "object", properties: {}, additionalProperties: false };
+  }
+  const def = schema._def;
+  const typeName = def.typeName;
+  if (typeName === "ZodObject") {
+    const shape = def.shape();
+    const properties = {};
+    const required = [];
+    for (const key in shape) {
+      const fieldSchema = shape[key];
+      properties[key] = zodToJsonSchema(fieldSchema);
+      if (fieldSchema._def.typeName !== "ZodOptional") {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0,
+      additionalProperties: false
+    };
+  }
+  if (typeName === "ZodString") {
+    const result = { type: "string" };
+    if (def.description) {
+      result.description = def.description;
+    }
+    return result;
+  }
+  if (typeName === "ZodNumber") {
+    const result = { type: "number" };
+    if (def.description) {
+      result.description = def.description;
+    }
+    return result;
+  }
+  if (typeName === "ZodBoolean") {
+    const result = { type: "boolean" };
+    if (def.description) {
+      result.description = def.description;
+    }
+    return result;
+  }
+  if (typeName === "ZodArray") {
+    const result = {
+      type: "array",
+      items: zodToJsonSchema(def.type)
+    };
+    if (def.description) {
+      result.description = def.description;
+    }
+    return result;
+  }
+  if (typeName === "ZodEnum") {
+    const result = {
+      type: "string",
+      enum: def.values
+    };
+    if (def.description) {
+      result.description = def.description;
+    }
+    return result;
+  }
+  if (typeName === "ZodOptional") {
+    return zodToJsonSchema(def.innerType);
+  }
+  if (typeName === "ZodNullable") {
+    const innerSchema = zodToJsonSchema(def.innerType);
+    return {
+      ...innerSchema,
+      nullable: true
+    };
+  }
+  if (typeName === "ZodLiteral") {
+    return {
+      type: typeof def.value,
+      enum: [def.value]
+    };
+  }
+  if (typeName === "ZodUnion") {
+    const options = def.options;
+    if (options && options.length > 0) {
+      return {
+        anyOf: options.map((opt) => zodToJsonSchema(opt))
+      };
+    }
+  }
+  return { type: "object", additionalProperties: true };
+}
+
+// src/NexvioWidgetElement.ts
+var DEFAULT_WIDGET_URL = "https://chatwidget.app";
+var WIDGET_VERSION = "0.1.0";
+var styleContent = `
+  :host {
+    display: block;
+    position: relative;
+    width: 100%;
+    height: 100%;
+  }
+  .nx-wrapper {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    transition: opacity 160ms ease-in-out;
+  }
+  :host([data-loaded='true']) .nx-wrapper {
+    opacity: 1;
+  }
+  .nx-frame {
+    border: none;
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    inset: 0;
+    background: transparent;
+  }
+`;
+var BaseHTMLElement = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+var _shadowRootRef, _frame, _wrapper, _options, _sanitized, _messenger, _loadedResolve, _loaded, _targetOrigin2, _initialized, _frameReady, _pendingOptions, _NexvioWidgetElement_instances, sanitizeOptions_fn, ensureStructure_fn, initializeFrame_fn, _handleFrameLoad, ensureMessenger_fn, buildFrameUrl_fn, updateDataAttributes_fn, handleFrameEvent_fn, handleClientAction_fn, handleExecuteClientTool_fn, dispatchReady_fn, dispatchError_fn, dispatchEvent_fn, handleResize_fn, flushOptionsIfReady_fn;
+var NexvioWidgetElement = class extends BaseHTMLElement {
+  constructor() {
+    super();
+    __privateAdd(this, _NexvioWidgetElement_instances);
+    __privateAdd(this, _shadowRootRef, null);
+    __privateAdd(this, _frame);
+    __privateAdd(this, _wrapper);
+    __privateAdd(this, _options);
+    __privateAdd(this, _sanitized);
+    __privateAdd(this, _messenger);
+    __privateAdd(this, _loadedResolve);
+    __privateAdd(this, _loaded);
+    __privateAdd(this, _targetOrigin2);
+    __privateAdd(this, _initialized, false);
+    __privateAdd(this, _frameReady, false);
+    __privateAdd(this, _pendingOptions);
+    __privateAdd(this, _handleFrameLoad, () => {
+      var _a;
+      debug("[NexvioWidget] frame load event");
+      this.dataset.loaded = "true";
+      (_a = __privateGet(this, _loadedResolve)) == null ? void 0 : _a.call(this);
+      __privateMethod(this, _NexvioWidgetElement_instances, flushOptionsIfReady_fn).call(this);
+    });
+    if (typeof window !== "undefined" && typeof this.attachShadow === "function") {
+      __privateSet(this, _shadowRootRef, this.attachShadow({ mode: "open" }));
+    }
+    log("[NexvioWidget] element: constructed");
+    __privateSet(this, _loaded, new Promise((resolve) => {
+      __privateSet(this, _loadedResolve, resolve);
+    }));
+  }
+  connectedCallback() {
+    log("[NexvioWidget] element: connectedCallback");
+    __privateMethod(this, _NexvioWidgetElement_instances, ensureStructure_fn).call(this);
+    if (__privateGet(this, _sanitized) && !__privateGet(this, _initialized)) {
+      __privateMethod(this, _NexvioWidgetElement_instances, initializeFrame_fn).call(this);
+    }
+  }
+  disconnectedCallback() {
+    log("[NexvioWidget] element: disconnectedCallback");
+    __privateGet(this, _messenger)?.disconnect();
+  }
+  setOptions(options) {
+    log("[NexvioWidget] setOptions: received", options);
+    const sanitized = __privateMethod(this, _NexvioWidgetElement_instances, sanitizeOptions_fn).call(this, options);
+    const previous = __privateGet(this, _sanitized);
+    const baseUrl = sanitized.host?.baseUrl ?? DEFAULT_WIDGET_URL;
+    debug("[NexvioWidget] setOptions: sanitized", sanitized);
+    __privateMethod(this, _NexvioWidgetElement_instances, ensureMessenger_fn).call(this, new URL(baseUrl).origin, options.fetch);
+    __privateSet(this, _options, options);
+    __privateSet(this, _sanitized, sanitized);
+    __privateSet(this, _pendingOptions, sanitized);
+    const requiresReload = !__privateGet(this, _initialized) || !previous || previous.publicKey !== sanitized.publicKey || (previous.host?.baseUrl ?? DEFAULT_WIDGET_URL) !== (sanitized.host?.baseUrl ?? DEFAULT_WIDGET_URL) || // Reload if clientTools changed (added, removed, or modified)
+    JSON.stringify(previous.clientTools) !== JSON.stringify(sanitized.clientTools);
+    debug("[NexvioWidget] setOptions: requiresReload", {
+      requiresReload,
+      reasons: {
+        notInitialized: !__privateGet(this, _initialized),
+        noPrevious: !previous,
+        publicKeyChanged: previous && previous.publicKey !== sanitized.publicKey,
+        baseUrlChanged: previous && (previous.host?.baseUrl ?? DEFAULT_WIDGET_URL) !== (sanitized.host?.baseUrl ?? DEFAULT_WIDGET_URL),
+        clientToolsChanged: previous && JSON.stringify(previous.clientTools) !== JSON.stringify(sanitized.clientTools)
+      }
+    });
+    __privateMethod(this, _NexvioWidgetElement_instances, updateDataAttributes_fn).call(this, sanitized);
+    if (requiresReload) {
+      __privateMethod(this, _NexvioWidgetElement_instances, initializeFrame_fn).call(this, true);
+      return;
+    }
+    __privateMethod(this, _NexvioWidgetElement_instances, flushOptionsIfReady_fn).call(this);
+  }
+  async focusInput() {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.focusInput();
+  }
+  async refresh() {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.refresh();
+  }
+  async setVisitor(visitor) {
+    await __privateGet(this, _loaded);
+    await __privateGet(this, _messenger)?.commands.updateVisitor(visitor);
+  }
+  async reload() {
+    if (!__privateGet(this, _sanitized)) return;
+    __privateSet(this, _initialized, false);
+    __privateMethod(this, _NexvioWidgetElement_instances, initializeFrame_fn).call(this, true);
+  }
+  get options() {
+    return __privateGet(this, _options);
+  }
+};
+_shadowRootRef = new WeakMap();
+_frame = new WeakMap();
+_wrapper = new WeakMap();
+_options = new WeakMap();
+_sanitized = new WeakMap();
+_messenger = new WeakMap();
+_loadedResolve = new WeakMap();
+_loaded = new WeakMap();
+_targetOrigin2 = new WeakMap();
+_initialized = new WeakMap();
+_frameReady = new WeakMap();
+_pendingOptions = new WeakMap();
+_NexvioWidgetElement_instances = new WeakSet();
+sanitizeOptions_fn = function(options) {
+  if (!options || typeof options.publicKey !== "string" || options.publicKey.trim().length === 0) {
+    throw new Error("Nexvio widget requires a non-empty `publicKey`.");
+  }
+  const hostBase = options.host?.baseUrl ?? DEFAULT_WIDGET_URL;
+  let validatedHost;
+  try {
+    validatedHost = new URL(hostBase);
+  } catch (error) {
+    throw new Error(`Invalid host baseUrl provided to Nexvio widget: ${error}`);
+  }
+  const sanitized = stripFunctions({
+    publicKey: options.publicKey.trim(),
+    appearance: options.appearance,
+    messageActions: options.messageActions,
+    metadata: options.metadata,
+    context: options.context,
+    startScreen: options.startScreen,
+    host: {
+      baseUrl: validatedHost.toString().replace(/\/$/, ""),
+      query: options.host?.query
+    }
+  });
+  if (options.client?.tools && Array.isArray(options.client.tools)) {
+    log("[NexvioWidget] sanitizeOptions: converting client tools", options.client.tools);
+    sanitized.clientTools = options.client.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: zodToJsonSchema(tool.parameters)
+    }));
+    log("[NexvioWidget] sanitizeOptions: sanitized clientTools", sanitized.clientTools);
+  } else {
+    log("[NexvioWidget] sanitizeOptions: no client tools found", {
+      hasClient: !!options.client,
+      hasTools: !!options.client?.tools
+    });
+  }
+  return sanitized;
+};
+ensureStructure_fn = function() {
+  if (__privateGet(this, _wrapper)) return;
+  if (!__privateGet(this, _shadowRootRef)) return;
+  const style = document.createElement("style");
+  style.textContent = styleContent;
+  const wrapper = document.createElement("div");
+  wrapper.className = "nx-wrapper";
+  const frame = document.createElement("iframe");
+  frame.className = "nx-frame";
+  frame.setAttribute("allow", "clipboard-read; clipboard-write");
+  frame.setAttribute("referrerpolicy", "strict-origin-when-cross-origin");
+  frame.name = "nexvio-widget";
+  frame.tabIndex = -1;
+  wrapper.appendChild(frame);
+  __privateGet(this, _shadowRootRef).append(style, wrapper);
+  __privateSet(this, _frame, frame);
+  __privateSet(this, _wrapper, wrapper);
+};
+initializeFrame_fn = function(forceReload = false) {
+  if (!__privateGet(this, _frame) || !__privateGet(this, _sanitized)) return;
+  if (__privateGet(this, _initialized) && !forceReload) return;
+  __privateSet(this, _initialized, true);
+  __privateSet(this, _frameReady, false);
+  this.dataset.loaded = "false";
+  __privateSet(this, _loaded, new Promise((resolve) => {
+    __privateSet(this, _loadedResolve, resolve);
+  }));
+  const frameUrl = __privateMethod(this, _NexvioWidgetElement_instances, buildFrameUrl_fn).call(this, __privateGet(this, _sanitized));
+  debug("[NexvioWidget] initializeFrame", { forceReload, frameUrl: frameUrl.toString() });
+  __privateGet(this, _frame).addEventListener("load", __privateGet(this, _handleFrameLoad), { once: true });
+  __privateGet(this, _frame).src = frameUrl.toString();
+  __privateMethod(this, _NexvioWidgetElement_instances, updateDataAttributes_fn).call(this, __privateGet(this, _sanitized));
+};
+_handleFrameLoad = new WeakMap();
+ensureMessenger_fn = function(origin, customFetch) {
+  if (__privateGet(this, _messenger) && __privateGet(this, _targetOrigin2) === origin) {
+    debug("[NexvioWidget] messenger: reuse", { origin });
+    return;
+  }
+  __privateGet(this, _messenger)?.disconnect();
+  __privateSet(this, _targetOrigin2, origin);
+  log("[NexvioWidget] messenger: create", { origin });
+  __privateSet(this, _messenger, new WidgetFrameMessenger({
+    target: () => __privateGet(this, _frame)?.contentWindow ?? null,
+    targetOrigin: origin,
+    fetch: customFetch,
+    handlers: {
+      onEmitEvent: (payload) => __privateMethod(this, _NexvioWidgetElement_instances, handleFrameEvent_fn).call(this, payload),
+      onRequestClientAction: (payload) => __privateMethod(this, _NexvioWidgetElement_instances, handleClientAction_fn).call(this, payload),
+      onExecuteClientTool: (payload) => __privateMethod(this, _NexvioWidgetElement_instances, handleExecuteClientTool_fn).call(this, payload)
+    }
+  }));
+  __privateGet(this, _messenger).connect();
+  __privateGet(this, _messenger).on("widget.ready", (payload) => __privateMethod(this, _NexvioWidgetElement_instances, dispatchReady_fn).call(this, payload));
+  __privateGet(this, _messenger).on("widget.error", (payload) => __privateMethod(this, _NexvioWidgetElement_instances, dispatchError_fn).call(this, payload));
+  __privateGet(this, _messenger).on("widget.event", (payload) => __privateMethod(this, _NexvioWidgetElement_instances, dispatchEvent_fn).call(this, payload));
+  __privateGet(this, _messenger).on("widget.resize", (payload) => __privateMethod(this, _NexvioWidgetElement_instances, handleResize_fn).call(this, payload));
+};
+buildFrameUrl_fn = function(options) {
+  const base = options.host?.baseUrl ?? DEFAULT_WIDGET_URL;
+  const trimmedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+  const url = new URL(`${trimmedBase}/${encodeURIComponent(options.publicKey)}`);
+  url.searchParams.set("embed", "1");
+  const query = options.host?.query ?? {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) continue;
+    url.searchParams.set(key, String(value));
+  }
+  const payload = stripFunctions({
+    appearance: options.appearance,
+    metadata: options.metadata,
+    context: options.context,
+    startScreen: options.startScreen,
+    version: WIDGET_VERSION,
+    clientTools: options.clientTools
+  });
+  log("[NexvioWidget] buildFrameUrl: payload with clientTools", payload);
+  if (Object.values(payload).some((value) => value !== void 0)) {
+    url.hash = encodeBase64(payload);
+  }
+  debug("[NexvioWidget] buildFrameUrl", { url: url.toString() });
+  return url;
+};
+updateDataAttributes_fn = function(options) {
+  const colorScheme = typeof options.appearance?.colorScheme === "string" ? options.appearance.colorScheme : void 0;
+  if (colorScheme) {
+    this.dataset.colorScheme = colorScheme;
+  } else {
+    delete this.dataset.colorScheme;
+  }
+};
+handleFrameEvent_fn = function({ name, detail }) {
+  log("[NexvioWidget] event", { name, detail });
+  const event = { name, detail };
+  __privateGet(this, _options)?.onEvent?.(event);
+  this.dispatchEvent(
+    new CustomEvent("nexvio.event", {
+      detail: event,
+      bubbles: true,
+      composed: true
+    })
+  );
+  this.dispatchEvent(
+    new CustomEvent(`nexvio.${name}`, {
+      detail,
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+handleClientAction_fn = async function({
+  action,
+  data
+}) {
+  const handler = __privateGet(this, _options)?.clientActions?.[action];
+  if (!handler) {
+    throw new Error(`No client action handler registered for "${action}"`);
+  }
+  return handler(data);
+};
+handleExecuteClientTool_fn = async function({
+  toolName,
+  toolArgs
+}) {
+  log("[NexvioWidget] executeClientTool", { toolName, toolArgs });
+  const tool = __privateGet(this, _options)?.client?.tools?.find((t) => t.name === toolName);
+  if (!tool) {
+    throw new Error(`No client tool registered with name "${toolName}"`);
+  }
+  try {
+    const validated = tool.parameters.parse(toolArgs);
+    const result = await Promise.resolve(tool.execute(validated));
+    log("[NexvioWidget] executeClientTool: success", { toolName, result });
+    return result;
+  } catch (error) {
+    console.error("[NexvioWidget] executeClientTool: error", { toolName, error });
+    throw new Error(`Tool execution failed for "${toolName}": ${error.message}`);
+  }
+};
+dispatchReady_fn = function(payload) {
+  log("[NexvioWidget] ready", payload);
+  __privateSet(this, _frameReady, true);
+  __privateMethod(this, _NexvioWidgetElement_instances, flushOptionsIfReady_fn).call(this);
+  this.dispatchEvent(
+    new CustomEvent("nexvio.ready", {
+      detail: payload,
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+dispatchError_fn = function(payload) {
+  const error = new Error(payload.message);
+  if (payload.stack) {
+    error.stack = payload.stack;
+  }
+  log("[NexvioWidget] error", payload);
+  this.dispatchEvent(
+    new CustomEvent("nexvio.error", {
+      detail: { error },
+      bubbles: true,
+      composed: true
+    })
+  );
+};
+dispatchEvent_fn = function(payload) {
+  __privateMethod(this, _NexvioWidgetElement_instances, handleFrameEvent_fn).call(this, payload);
+};
+handleResize_fn = function(payload) {
+  if (typeof payload?.height === "number") {
+    this.style.setProperty("--nexvio-widget-height", `${payload.height}px`);
+  }
+};
+flushOptionsIfReady_fn = function() {
+  if (!__privateGet(this, _frameReady)) return;
+  if (!__privateGet(this, _pendingOptions)) return;
+  const options = __privateGet(this, _pendingOptions);
+  __privateSet(this, _pendingOptions, void 0);
+  if (!__privateGet(this, _messenger)) return;
+  debug("[NexvioWidget] flushOptionsIfReady: syncing options to frame");
+  void __privateGet(this, _messenger).commands.setOptions(options).catch((error) => {
+    console.error("Failed to sync widget options:", error);
+  });
+};
+function registerNexvioWidget(tagName = "nexvio-chat-widget") {
+  if (typeof customElements === "undefined") return;
+  if (!customElements.get(tagName)) {
+    customElements.define(tagName, NexvioWidgetElement);
+  }
+}
+
+// src/NexvioChatbotElement.ts
+var styleContent2 = `
+  :host {
+    --chatbot-button-size: 60px;
+    --chatbot-button-bg: #3B82F6;
+    --chatbot-button-color: white;
+    --chatbot-widget-width: 420px;
+    --chatbot-widget-height: 600px;
+    --chatbot-widget-gap: 20px;
+    
+    position: fixed;
+    bottom: var(--chatbot-widget-gap);
+    right: var(--chatbot-widget-gap);
+    z-index: 999999;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  }
+
+  .nx-chatbot-button {
+    width: var(--chatbot-button-size);
+    height: var(--chatbot-button-size);
+    border-radius: 50%;
+    background: var(--chatbot-button-bg);
+    color: var(--chatbot-button-color);
+    border: none;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+    position: relative;
+    overflow: hidden;
+  }
+
+  .nx-chatbot-button:hover {
+    transform: scale(1.05);
+    box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2);
+  }
+
+  .nx-chatbot-button:active {
+    transform: scale(0.95);
+  }
+
+  .nx-chatbot-button svg {
+    width: 28px;
+    height: 28px;
+    transition: transform 0.3s ease, opacity 0.3s ease;
+  }
+
+  .nx-chatbot-button.open svg.icon-chat {
+    transform: rotate(90deg) scale(0);
+    opacity: 0;
+  }
+
+  .nx-chatbot-button svg.icon-close {
+    position: absolute;
+    transform: rotate(-90deg) scale(0);
+    opacity: 0;
+  }
+
+  .nx-chatbot-button.open svg.icon-close {
+    transform: rotate(0deg) scale(1);
+    opacity: 1;
+  }
+
+  .nx-chatbot-widget-container {
+    position: absolute;
+    bottom: calc(var(--chatbot-button-size) + 16px);
+    right: 0;
+    width: var(--chatbot-widget-width);
+    height: var(--chatbot-widget-height);
+    max-height: calc(100vh - var(--chatbot-button-size) - var(--chatbot-widget-gap) - 32px);
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12);
+    overflow: hidden;
+    transform-origin: bottom right;
+    transform: scale(0.8);
+    opacity: 0;
+    pointer-events: none;
+    transition: transform 0.3s cubic-bezier(0.34, 1.56, 0.64, 1), 
+                opacity 0.3s ease;
+  }
+
+  .nx-chatbot-widget-container.open {
+    transform: scale(1);
+    opacity: 1;
+    pointer-events: auto;
+  }
+
+  .nx-chatbot-widget-container nexvio-chat-widget {
+    display: block;
+    width: 100%;
+    height: 100%;
+  }
+
+  .nx-chatbot-badge {
+    position: absolute;
+    top: -4px;
+    right: -4px;
+    min-width: 20px;
+    height: 20px;
+    padding: 0 6px;
+    background: #EF4444;
+    color: white;
+    border-radius: 10px;
+    font-size: 11px;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+    transform: scale(0);
+    transition: transform 0.2s ease;
+  }
+
+  .nx-chatbot-badge.visible {
+    transform: scale(1);
+  }
+
+  @media (max-width: 768px) {
+    :host {
+      bottom: 16px;
+      right: 16px;
+      --chatbot-widget-gap: 16px;
+    }
+
+    .nx-chatbot-widget-container {
+      position: fixed;
+      bottom: 0;
+      right: 0;
+      left: 0;
+      top: 0;
+      width: 100%;
+      height: 100%;
+      max-width: 100%;
+      max-height: 100%;
+      border-radius: 0;
+    }
+
+    .nx-chatbot-widget-container.open {
+      transform: scale(1);
+    }
+  }
+`;
+var BaseHTMLElement2 = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+var _shadowRootRef2, _button, _widgetContainer, _widget, _badge, _isOpen, _options2, _initialized2, _NexvioChatbotElement_instances, ensureStructure_fn2, initialize_fn, updateWidget_fn, updateStyles_fn, updateBadge_fn;
+var NexvioChatbotElement = class extends BaseHTMLElement2 {
+  constructor() {
+    super();
+    __privateAdd(this, _NexvioChatbotElement_instances);
+    __privateAdd(this, _shadowRootRef2, null);
+    __privateAdd(this, _button);
+    __privateAdd(this, _widgetContainer);
+    __privateAdd(this, _widget);
+    __privateAdd(this, _badge);
+    __privateAdd(this, _isOpen, false);
+    __privateAdd(this, _options2);
+    __privateAdd(this, _initialized2, false);
+    if (typeof window !== "undefined" && typeof this.attachShadow === "function") {
+      __privateSet(this, _shadowRootRef2, this.attachShadow({ mode: "open" }));
+    }
+    log("[NexvioChatbot] element: constructed");
+  }
+  connectedCallback() {
+    log("[NexvioChatbot] element: connectedCallback");
+    __privateMethod(this, _NexvioChatbotElement_instances, ensureStructure_fn2).call(this);
+    if (__privateGet(this, _options2) && !__privateGet(this, _initialized2)) {
+      __privateMethod(this, _NexvioChatbotElement_instances, initialize_fn).call(this);
+    }
+  }
+  disconnectedCallback() {
+    log("[NexvioChatbot] element: disconnectedCallback");
+  }
+  setOptions(options) {
+    log("[NexvioChatbot] setOptions:", options);
+    __privateSet(this, _options2, options);
+    __privateMethod(this, _NexvioChatbotElement_instances, ensureStructure_fn2).call(this);
+    if (!__privateGet(this, _initialized2)) {
+      __privateMethod(this, _NexvioChatbotElement_instances, initialize_fn).call(this);
+    } else {
+      __privateMethod(this, _NexvioChatbotElement_instances, updateWidget_fn).call(this);
+    }
+    __privateMethod(this, _NexvioChatbotElement_instances, updateStyles_fn).call(this);
+    __privateMethod(this, _NexvioChatbotElement_instances, updateBadge_fn).call(this);
+  }
+  open() {
+    if (__privateGet(this, _isOpen)) return;
+    __privateSet(this, _isOpen, true);
+    __privateGet(this, _button)?.classList.add("open");
+    __privateGet(this, _widgetContainer)?.classList.add("open");
+    this.dispatchEvent(new CustomEvent("chatbot.opened", { bubbles: true, composed: true }));
+  }
+  close() {
+    if (!__privateGet(this, _isOpen)) return;
+    __privateSet(this, _isOpen, false);
+    __privateGet(this, _button)?.classList.remove("open");
+    __privateGet(this, _widgetContainer)?.classList.remove("open");
+    this.dispatchEvent(new CustomEvent("chatbot.closed", { bubbles: true, composed: true }));
+  }
+  toggle() {
+    if (__privateGet(this, _isOpen)) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+  get isOpen() {
+    return __privateGet(this, _isOpen);
+  }
+  get widget() {
+    return __privateGet(this, _widget);
+  }
+  get options() {
+    return __privateGet(this, _options2);
+  }
+};
+_shadowRootRef2 = new WeakMap();
+_button = new WeakMap();
+_widgetContainer = new WeakMap();
+_widget = new WeakMap();
+_badge = new WeakMap();
+_isOpen = new WeakMap();
+_options2 = new WeakMap();
+_initialized2 = new WeakMap();
+_NexvioChatbotElement_instances = new WeakSet();
+ensureStructure_fn2 = function() {
+  if (__privateGet(this, _button) && __privateGet(this, _widgetContainer)) return;
+  if (!__privateGet(this, _shadowRootRef2)) return;
+  if (typeof window !== "undefined" && typeof customElements !== "undefined") {
+    registerNexvioWidget();
+  }
+  const style = document.createElement("style");
+  style.textContent = styleContent2;
+  const button = document.createElement("button");
+  button.className = "nx-chatbot-button";
+  button.setAttribute("aria-label", "Open chat");
+  button.innerHTML = `
+      <svg class="icon-chat" xmlns="http://www.w3.org/2000/svg" 
+     viewBox="0 0 24 24" fill="none" stroke="currentColor" 
+     stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M6 4h12a3 3 0 0 1 3 3v7a3 3 0 0 1-3 3H9l-4 3v-3H6a3 3 0 0 1-3-3V7a3 3 0 0 1 3-3z"/>
+      </svg>
+      <svg class="icon-close" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M18 6L6 18M6 6l12 12"></path>
+      </svg>
+    `;
+  const badge = document.createElement("span");
+  badge.className = "nx-chatbot-badge";
+  button.appendChild(badge);
+  const widgetContainer = document.createElement("div");
+  widgetContainer.className = "nx-chatbot-widget-container";
+  const widget = document.createElement("nexvio-chat-widget");
+  widgetContainer.appendChild(widget);
+  __privateGet(this, _shadowRootRef2).append(style, button, widgetContainer);
+  __privateSet(this, _button, button);
+  __privateSet(this, _widgetContainer, widgetContainer);
+  __privateSet(this, _widget, widget);
+  __privateSet(this, _badge, badge);
+  button.addEventListener("click", () => this.toggle());
+  widget.addEventListener("nexvio.event", ((event) => {
+    this.dispatchEvent(
+      new CustomEvent("nexvio.event", {
+        detail: event.detail,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }));
+};
+initialize_fn = function() {
+  if (__privateGet(this, _initialized2) || !__privateGet(this, _options2) || !__privateGet(this, _widget)) return;
+  __privateSet(this, _initialized2, true);
+  const widgetOptions = { ...__privateGet(this, _options2) };
+  delete widgetOptions.position;
+  delete widgetOptions.defaultOpen;
+  delete widgetOptions.buttonColor;
+  delete widgetOptions.badge;
+  delete widgetOptions.buttonIcon;
+  delete widgetOptions.gap;
+  const setWidgetOptions = () => {
+    if (__privateGet(this, _widget) && typeof __privateGet(this, _widget).setOptions === "function") {
+      __privateGet(this, _widget).setOptions(widgetOptions);
+      if (__privateGet(this, _options2)?.defaultOpen) {
+        setTimeout(() => this.open(), 100);
+      }
+      debug("[NexvioChatbot] initialized");
+    } else if (typeof window !== "undefined" && typeof customElements !== "undefined") {
+      customElements.whenDefined("nexvio-chat-widget").then(() => {
+        if (__privateGet(this, _widget) && typeof __privateGet(this, _widget).setOptions === "function") {
+          __privateGet(this, _widget).setOptions(widgetOptions);
+          if (__privateGet(this, _options2)?.defaultOpen) {
+            setTimeout(() => this.open(), 100);
+          }
+          debug("[NexvioChatbot] initialized");
+        }
+      }).catch(() => {
+        console.error("[NexvioChatbot] Failed to initialize widget element");
+      });
+    }
+  };
+  setWidgetOptions();
+};
+updateWidget_fn = function() {
+  if (!__privateGet(this, _widget) || !__privateGet(this, _options2)) return;
+  const widgetOptions = { ...__privateGet(this, _options2) };
+  delete widgetOptions.position;
+  delete widgetOptions.defaultOpen;
+  delete widgetOptions.buttonColor;
+  delete widgetOptions.badge;
+  delete widgetOptions.buttonIcon;
+  delete widgetOptions.gap;
+  if (typeof __privateGet(this, _widget).setOptions === "function") {
+    __privateGet(this, _widget).setOptions(widgetOptions);
+  } else if (typeof window !== "undefined" && typeof customElements !== "undefined") {
+    customElements.whenDefined("nexvio-chat-widget").then(() => {
+      if (__privateGet(this, _widget) && typeof __privateGet(this, _widget).setOptions === "function") {
+        __privateGet(this, _widget).setOptions(widgetOptions);
+      }
+    }).catch(() => {
+      console.error("[NexvioChatbot] Failed to update widget element");
+    });
+  }
+};
+updateStyles_fn = function() {
+  if (!__privateGet(this, _options2)) return;
+  const host = __privateGet(this, _shadowRootRef2)?.host;
+  if (!host) return;
+  if (__privateGet(this, _options2).buttonColor) {
+    host.style.setProperty("--chatbot-button-bg", __privateGet(this, _options2).buttonColor);
+  }
+  if (__privateGet(this, _options2).gap !== void 0) {
+    host.style.setProperty("--chatbot-widget-gap", `${__privateGet(this, _options2).gap}px`);
+  }
+  if (__privateGet(this, _options2).position) {
+    const positions = {
+      "bottom-right": {
+        bottom: "var(--chatbot-widget-gap)",
+        right: "var(--chatbot-widget-gap)",
+        top: "auto",
+        left: "auto"
+      },
+      "bottom-left": {
+        bottom: "var(--chatbot-widget-gap)",
+        left: "var(--chatbot-widget-gap)",
+        top: "auto",
+        right: "auto"
+      },
+      "top-right": {
+        top: "var(--chatbot-widget-gap)",
+        right: "var(--chatbot-widget-gap)",
+        bottom: "auto",
+        left: "auto"
+      },
+      "top-left": {
+        top: "var(--chatbot-widget-gap)",
+        left: "var(--chatbot-widget-gap)",
+        bottom: "auto",
+        right: "auto"
+      }
+    };
+    const pos = positions[__privateGet(this, _options2).position];
+    Object.entries(pos).forEach(([key, value]) => {
+      host.style.setProperty(key, value);
+    });
+  }
+  if (__privateGet(this, _options2).buttonIcon && __privateGet(this, _button)) {
+    const chatIcon = __privateGet(this, _button).querySelector(".icon-chat");
+    if (chatIcon) {
+      chatIcon.innerHTML = __privateGet(this, _options2).buttonIcon;
+    }
+  }
+};
+updateBadge_fn = function() {
+  if (!__privateGet(this, _badge) || !__privateGet(this, _options2)) return;
+  const badgeValue = __privateGet(this, _options2).badge;
+  if (typeof badgeValue === "number" && badgeValue > 0) {
+    __privateGet(this, _badge).textContent = badgeValue > 99 ? "99+" : String(badgeValue);
+    __privateGet(this, _badge).classList.add("visible");
+  } else if (badgeValue === true) {
+    __privateGet(this, _badge).textContent = "";
+    __privateGet(this, _badge).classList.add("visible");
+  } else {
+    __privateGet(this, _badge).classList.remove("visible");
+  }
+};
+function registerNexvioChatbot(tagName = "nexvio-chat-bot") {
+  if (typeof customElements === "undefined") return;
+  if (!customElements.get(tagName)) {
+    customElements.define(tagName, NexvioChatbotElement);
+  }
+}
+
+// src/react/useStableOptions.ts
+var import_react = require("react");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function toRecord(value) {
+  return value;
+}
+function deepEqualIgnoringFunctions(a, b, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Object.is(a, b)) return true;
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) {
+      if (!deepEqualIgnoringFunctions(a[i], b[i], seen)) return false;
+    }
+    return true;
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  if (seen.get(a) === b) return true;
+  seen.set(a, b);
+  const recordA = toRecord(a);
+  const recordB = toRecord(b);
+  const keysA = Object.keys(recordA);
+  const keysB = Object.keys(recordB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!(key in recordB)) return false;
+    const valueA = recordA[key];
+    const valueB = recordB[key];
+    if (typeof valueA === "function" && typeof valueB === "function") {
+      continue;
+    }
+    if (!deepEqualIgnoringFunctions(valueA, valueB, seen)) return false;
+  }
+  return true;
+}
+function useStableOptions(options) {
+  const cacheRef = (0, import_react.useRef)();
+  const latestRef = (0, import_react.useRef)(options);
+  latestRef.current = options;
+  return (0, import_react.useMemo)(() => {
+    const cache = cacheRef.current;
+    if (!cache || !deepEqualIgnoringFunctions(cache.snapshot, options)) {
+      const shaped = wrapFunctionsWithLatestReferences(options, latestRef);
+      cacheRef.current = { snapshot: options, shaped };
+      return shaped;
+    }
+    return cache.shaped;
+  }, [options]);
+}
+function wrapFunctionsWithLatestReferences(obj, latestRef) {
+  const path = [];
+  const getByPath = (target, keys) => keys.reduce((acc, key) => acc == null ? acc : acc[key], target);
+  const visit = (value) => {
+    if (typeof value === "function") {
+      const key = path[path.length - 1];
+      const parentPath = path.slice(0, -1);
+      return (...args) => {
+        const latestParent = getByPath(latestRef.current, parentPath);
+        const latestFn = latestParent?.[key];
+        if (typeof latestFn === "function") {
+          return latestFn.apply(latestParent, args);
+        }
+        return void 0;
+      };
+    }
+    if (Array.isArray(value)) {
+      const base = path.length;
+      const result = new Array(value.length);
+      for (let i = 0; i < value.length; i += 1) {
+        path[base] = i;
+        result[i] = visit(value[i]);
+      }
+      path.length = base;
+      return result;
+    }
+    if (isPlainObject(value)) {
+      const base = path.length;
+      const record = toRecord(value);
+      const result = {};
+      for (const key of Object.keys(record)) {
+        path[base] = key;
+        result[key] = visit(record[key]);
+      }
+      path.length = base;
+      return result;
+    }
+    return value;
+  };
+  return visit(optionsShallowClone(obj));
+}
+function optionsShallowClone(obj) {
+  const record = toRecord(obj);
+  const clone = {};
+  for (const [key, value] of Object.entries(record)) {
+    clone[key] = value;
+  }
+  return clone;
+}
+
+// src/react/useNexvioChatbot.ts
+function useNexvioChatbot(options) {
+  const elementRef = (0, import_react2.useRef)(null);
+  const stableOptions = useStableOptions(options);
+  (0, import_react2.useEffect)(() => {
+    registerNexvioChatbot();
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const element = elementRef.current;
+    if (!element) return;
+    if (typeof element.setOptions === "function") {
+      element.setOptions(stableOptions);
+      return;
+    }
+    if (typeof window !== "undefined") {
+      const tagName = element.tagName.toLowerCase();
+      customElements.whenDefined(tagName).then(() => {
+        if (elementRef.current === element) {
+          const definedElement = element;
+          definedElement.setOptions?.(stableOptions);
+        }
+      }).catch(() => {
+      });
+    }
+  }, [stableOptions]);
+  const setElement = (0, import_react2.useCallback)(
+    (element) => {
+      elementRef.current = element;
+      if (!element || !stableOptions) {
+        return;
+      }
+      if (typeof element.setOptions === "function") {
+        element.setOptions(stableOptions);
+        return;
+      }
+      if (typeof window !== "undefined") {
+        const tagName = element.tagName.toLowerCase();
+        customElements.whenDefined(tagName).then(() => {
+          if (elementRef.current === element) {
+            const definedElement = element;
+            definedElement.setOptions?.(stableOptions);
+          }
+        }).catch(() => {
+        });
+      }
+    },
+    [stableOptions]
+  );
+  return { ref: elementRef, setElement };
+}
+
+// src/react/NexvioChatbot.tsx
+var NexvioChatbot = React.forwardRef(function NexvioChatbot2({ options, tagName = "nexvio-chat-bot", ...htmlProps }, forwardedRef) {
+  const { setElement } = useNexvioChatbot(options);
+  const handleRef = React.useCallback(
+    (value) => {
+      const element = value ?? null;
+      if (forwardedRef) {
+        if (typeof forwardedRef === "function") {
+          forwardedRef(element);
+        } else {
+          ;
+          forwardedRef.current = element;
+        }
+      }
+      setElement(element);
+    },
+    [forwardedRef, setElement]
+  );
+  return React.createElement(tagName, {
+    ...htmlProps,
+    ref: handleRef
+  });
+});
+
+// src/react/NexvioWidget.tsx
+var React2 = __toESM(require("react"), 1);
+
+// src/react/useNexvioWidget.ts
+var import_react3 = require("react");
+function useNexvioWidget(options) {
+  const elementRef = (0, import_react3.useRef)(null);
+  const stableOptions = useStableOptions(options);
+  (0, import_react3.useEffect)(() => {
+    registerNexvioWidget();
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    const element = elementRef.current;
+    if (!element) return;
+    if (typeof element.setOptions === "function") {
+      element.setOptions(stableOptions);
+      return;
+    }
+    if (typeof window !== "undefined") {
+      const tagName = element.tagName.toLowerCase();
+      customElements.whenDefined(tagName).then(() => {
+        if (elementRef.current === element) {
+          const definedElement = element;
+          definedElement.setOptions?.(stableOptions);
+        }
+      }).catch(() => {
+      });
+    }
+  }, [stableOptions]);
+  const setElement = (0, import_react3.useCallback)(
+    (element) => {
+      elementRef.current = element;
+      if (!element || !stableOptions) {
+        return;
+      }
+      if (typeof element.setOptions === "function") {
+        element.setOptions(stableOptions);
+        return;
+      }
+      if (typeof window !== "undefined") {
+        const tagName = element.tagName.toLowerCase();
+        customElements.whenDefined(tagName).then(() => {
+          if (elementRef.current === element) {
+            const definedElement = element;
+            definedElement.setOptions?.(stableOptions);
+          }
+        }).catch(() => {
+        });
+      }
+    },
+    [stableOptions]
+  );
+  return { ref: elementRef, setElement };
+}
+
+// src/react/NexvioWidget.tsx
+var NexvioWidget = React2.forwardRef(function NexvioWidget2({ options, tagName = "nexvio-chat-widget", ...htmlProps }, forwardedRef) {
+  const { setElement } = useNexvioWidget(options);
+  const handleRef = React2.useCallback(
+    (value) => {
+      const element = value ?? null;
+      if (forwardedRef) {
+        if (typeof forwardedRef === "function") {
+          forwardedRef(element);
+        } else {
+          ;
+          forwardedRef.current = element;
+        }
+      }
+      setElement(element);
+    },
+    [forwardedRef, setElement]
+  );
+  return React2.createElement(tagName, {
+    ...htmlProps,
+    ref: handleRef
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NexvioChatbot,
+  NexvioWidget,
+  useNexvioChatbot,
+  useNexvioWidget
+});
+//# sourceMappingURL=react.cjs.map