@xpert-ai/chatkit-web-shared 0.0.1

package/dist/index.js

@@ -0,0 +1,819 @@
+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);
+var _a, _b;
+class EventEmitter {
+  constructor() {
+    __publicField(this, "callbacks", /* @__PURE__ */ new Map());
+  }
+  on(event, callback) {
+    if (!this.callbacks.has(event)) {
+      this.callbacks.set(event, /* @__PURE__ */ new Set());
+    }
+    this.callbacks.get(event).add(callback);
+  }
+  emit(event, ...args) {
+    var _a2;
+    const data = args[0];
+    (_a2 = this.callbacks.get(event)) == null ? void 0 : _a2.forEach((callback) => callback(data));
+  }
+  off(event, callback) {
+    var _a2;
+    if (!callback) {
+      this.callbacks.delete(event);
+    } else {
+      (_a2 = this.callbacks.get(event)) == null ? void 0 : _a2.delete(callback);
+    }
+  }
+  allOff() {
+    this.callbacks.clear();
+  }
+}
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const EventStreamContentType = "text/event-stream";
+const DefaultRetryInterval = 1e3;
+const LastEventId = "last-event-id";
+function fetchEventSource(input, _a2) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a2, rest = __rest(_a2, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (!document.hidden) {
+        create();
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+      resolve();
+    });
+    const fetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a3;
+      curRequestController = new AbortController();
+      try {
+        const response = await fetch(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a3 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a3 !== void 0 ? _a3 : retryInterval;
+            window.clearTimeout(retryTimer);
+            retryTimer = window.setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
+const FRAME_SAFE_ERROR_KEY = "__chatkit_error__";
+class HttpError extends Error {
+  constructor(message, res, metadata) {
+    super(message);
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    __publicField(this, "metadata");
+    this.name = "HttpError";
+    this.statusText = res.statusText;
+    this.status = res.status;
+    this.metadata = metadata;
+  }
+  static fromPossibleFrameSafeError(error) {
+    if (error instanceof HttpError) {
+      return error;
+    }
+    if (error && typeof error === "object" && FRAME_SAFE_ERROR_KEY in error && error[FRAME_SAFE_ERROR_KEY] === "HttpError") {
+      const safeError = error;
+      const parsedError = new HttpError(
+        safeError.message,
+        {
+          status: safeError.status,
+          statusText: safeError.statusText
+        },
+        safeError.metadata
+      );
+      parsedError.stack = safeError.stack;
+      return parsedError;
+    }
+    return null;
+  }
+}
+_a = FRAME_SAFE_ERROR_KEY;
+const _FrameSafeHttpError = class _FrameSafeHttpError {
+  constructor(message, res, metadata) {
+    __publicField(this, _a, "HttpError");
+    __publicField(this, "message");
+    __publicField(this, "stack");
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    __publicField(this, "metadata");
+    this.message = message;
+    this.stack = new Error(message).stack;
+    this.status = res.status;
+    this.statusText = res.statusText;
+    this.metadata = metadata;
+  }
+  static fromHttpError(error) {
+    return new _FrameSafeHttpError(
+      error.message,
+      {
+        status: error.status,
+        statusText: error.statusText
+      },
+      error.metadata
+    );
+  }
+};
+let FrameSafeHttpError = _FrameSafeHttpError;
+const BASE_RETRY_DELAY_MS = 1e3;
+const MAX_RETRY_DELAY_MS = 1e4;
+const MAX_RETRY_ATTEMPTS = 5;
+const nextDelay = (attempt, maxRetryDelay = MAX_RETRY_DELAY_MS, baseDelayMs = BASE_RETRY_DELAY_MS) => {
+  const max = Math.min(maxRetryDelay, baseDelayMs * 2 ** attempt);
+  return Math.floor(max * (0.5 + Math.random() * 0.5));
+};
+class RetryableError extends Error {
+  constructor(cause) {
+    super();
+    this.cause = cause;
+  }
+}
+const fetchEventSourceWithRetry = async (url, params) => {
+  let retryAttempt = 0;
+  const { onopen, ...restParams } = params;
+  await fetchEventSource(url, {
+    ...restParams,
+    onopen: async (res) => {
+      var _a2;
+      onopen == null ? void 0 : onopen(res);
+      if (res.ok && ((_a2 = res.headers.get("content-type")) == null ? void 0 : _a2.startsWith("text/event-stream"))) {
+        retryAttempt = 0;
+        return;
+      }
+      const httpError = new FrameSafeHttpError(`Streaming failed: ${res.statusText}`, res);
+      if (res.status >= 400 && res.status < 500) {
+        throw httpError;
+      } else {
+        throw new RetryableError(httpError);
+      }
+    },
+    onerror: (error) => {
+      if (error instanceof RetryableError) {
+        if (retryAttempt >= MAX_RETRY_ATTEMPTS) {
+          throw error.cause;
+        }
+        retryAttempt += 1;
+        return nextDelay(retryAttempt);
+      }
+      throw error;
+    }
+  });
+};
+let IntegrationError$1 = class IntegrationError extends Error {
+  constructor(message) {
+    super(message);
+    __publicField(this, "_name");
+    this.name = "IntegrationError";
+    this._name = this.name;
+  }
+  static fromPossibleFrameSafeError(error) {
+    if (error && typeof error === "object" && FRAME_SAFE_ERROR_KEY in error && error[FRAME_SAFE_ERROR_KEY] === "IntegrationError") {
+      const safeError = error;
+      const parsedError = new IntegrationError(safeError.message);
+      parsedError.stack = safeError.stack;
+      return parsedError;
+    }
+    return null;
+  }
+};
+_b = FRAME_SAFE_ERROR_KEY;
+class FrameSafeIntegrationError {
+  constructor(message) {
+    __publicField(this, _b, "IntegrationError");
+    __publicField(this, "message");
+    __publicField(this, "stack");
+    this.message = message;
+    this.stack = new Error(message).stack;
+  }
+}
+class BaseMessenger {
+  constructor({
+    handlers,
+    target,
+    targetOrigin,
+    fetch = window.fetch
+  }) {
+    __publicField(this, "targetOrigin");
+    __publicField(this, "target");
+    __publicField(this, "commandHandlers");
+    __publicField(this, "_fetch");
+    __publicField(this, "emitter", new EventEmitter());
+    __publicField(this, "handlers", /* @__PURE__ */ new Map());
+    __publicField(this, "fetchEventSourceHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "abortControllers", /* @__PURE__ */ new Map());
+    __publicField(this, "commands", new Proxy(
+      {},
+      {
+        get: (_, command) => {
+          return (data, transfer) => {
+            return new Promise((resolve, reject) => {
+              const nonce = crypto.randomUUID();
+              this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+              this.sendMessage(
+                {
+                  type: "command",
+                  nonce,
+                  command: `on${command.charAt(0).toUpperCase()}${command.slice(1)}`,
+                  data
+                },
+                transfer
+              );
+            });
+          };
+        }
+      }
+    ));
+    __publicField(this, "handleMessage", async (event) => {
+      var _a2, _b2, _c, _d;
+      console.log("Received message", event.data, event.origin, this.targetOrigin, event.source, this.target());
+      if (!event.data || event.data.__xpaiChatKit !== true || event.origin !== this.targetOrigin || event.source !== this.target()) {
+        return;
+      }
+      const data = event.data;
+      switch (data.type) {
+        case "event": {
+          this.emitter.emit(data.event, data.data);
+          break;
+        }
+        case "fetch": {
+          try {
+            if (data.formData) {
+              const formData = new FormData();
+              for (const [key, value] of Object.entries(data.formData)) {
+                formData.append(key, value);
+              }
+              data.params.body = formData;
+            }
+            const controller = new AbortController();
+            this.abortControllers.set(data.nonce, controller);
+            data.params.signal = controller.signal;
+            const res = await this._fetch(data.url, data.params);
+            if (!res.ok) {
+              const message = await res.json().then((json2) => json2.message || res.statusText).catch(() => res.statusText);
+              throw new FrameSafeHttpError(message, res);
+            }
+            const json = await res.json().catch(() => ({}));
+            this.sendMessage({
+              type: "response",
+              response: json,
+              nonce: data.nonce
+            });
+          } catch (error) {
+            this.sendMessage({
+              type: "response",
+              error,
+              nonce: data.nonce
+            });
+          }
+          break;
+        }
+        case "fetchEventSource": {
+          try {
+            const controller = new AbortController();
+            this.abortControllers.set(data.nonce, controller);
+            await fetchEventSourceWithRetry(data.url, {
+              ...data.params,
+              signal: controller.signal,
+              fetch: this._fetch,
+              onmessage: (message) => {
+                this.sendMessage({
+                  type: "fetchEventSourceMessage",
+                  message,
+                  nonce: data.nonce
+                });
+              }
+            });
+            this.sendMessage({
+              type: "response",
+              response: void 0,
+              nonce: data.nonce
+            });
+          } catch (error) {
+            this.sendMessage({
+              type: "response",
+              error,
+              nonce: data.nonce
+            });
+          }
+          break;
+        }
+        case "command": {
+          console.log("Received command", data.command, data.data);
+          if (!this.canReceiveCommand(data.command)) {
+            this.sendMessage({
+              type: "response",
+              error: new FrameSafeIntegrationError(`Command ${data.command} not supported`),
+              nonce: data.nonce
+            });
+            return;
+          }
+          try {
+            const response = await ((_b2 = (_a2 = this.commandHandlers)[data.command]) == null ? void 0 : _b2.call(_a2, data.data));
+            this.sendMessage({
+              type: "response",
+              response,
+              nonce: data.nonce
+            });
+          } catch (error) {
+            this.sendMessage({
+              type: "response",
+              error,
+              nonce: data.nonce
+            });
+          }
+          break;
+        }
+        case "response": {
+          const handler = this.handlers.get(data.nonce);
+          if (!handler) {
+            console.error("No handler found for nonce", data.nonce);
+            return;
+          }
+          if (data.error) {
+            const integrationError = IntegrationError$1.fromPossibleFrameSafeError(data.error);
+            const httpError = HttpError.fromPossibleFrameSafeError(data.error);
+            if (integrationError) {
+              integrationError.stack = handler.stack;
+              handler.reject(integrationError);
+            } else if (httpError) {
+              handler.reject(httpError);
+            } else {
+              handler.reject(data.error);
+            }
+          } else {
+            handler.resolve(data.response);
+          }
+          this.handlers.delete(data.nonce);
+          break;
+        }
+        case "fetchEventSourceMessage": {
+          const handler = this.fetchEventSourceHandlers.get(data.nonce);
+          if (!handler) {
+            console.error("No handler found for nonce", data.nonce);
+            return;
+          }
+          (_d = (_c = this.fetchEventSourceHandlers.get(data.nonce)) == null ? void 0 : _c.onmessage) == null ? void 0 : _d.call(_c, data.message);
+          break;
+        }
+        case "abortSignal": {
+          const controller = this.abortControllers.get(data.nonce);
+          if (controller) {
+            controller.abort(data.reason);
+            this.abortControllers.delete(data.nonce);
+          }
+          break;
+        }
+      }
+    });
+    this.commandHandlers = handlers;
+    this.target = target;
+    this.targetOrigin = targetOrigin;
+    this._fetch = (...args) => fetch(...args);
+  }
+  sendMessage(data, transfer) {
+    var _a2;
+    const message = {
+      __xpaiChatKit: true,
+      ...data
+    };
+    (_a2 = this.target()) == null ? void 0 : _a2.postMessage(message, this.targetOrigin, transfer);
+  }
+  connect() {
+    window.addEventListener("message", this.handleMessage);
+  }
+  disconnect() {
+    window.removeEventListener("message", this.handleMessage);
+  }
+  fetch(url, params) {
+    return new Promise((resolve, reject) => {
+      const nonce = crypto.randomUUID();
+      this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+      let formData;
+      if (params.body instanceof FormData) {
+        formData = {};
+        for (const [key, value] of params.body.entries()) {
+          formData[key] = value;
+        }
+        params.body = void 0;
+      }
+      if (params.signal) {
+        params.signal.addEventListener("abort", () => {
+          var _a2;
+          this.sendMessage({
+            type: "abortSignal",
+            nonce,
+            reason: (_a2 = params.signal) == null ? void 0 : _a2.reason
+          });
+        });
+        params.signal = void 0;
+      }
+      this.sendMessage({ type: "fetch", nonce, params, formData, url });
+    });
+  }
+  // Supporting onopen would require a good way for us to serialize the Response object
+  // across the iframe boundary, which is not trivial and also not really necessary.
+  fetchEventSource(url, params) {
+    return new Promise((resolve, reject) => {
+      const { onmessage, signal, ...rest } = params;
+      const nonce = crypto.randomUUID();
+      this.handlers.set(nonce, { resolve, reject, stack: new Error().stack || "" });
+      this.fetchEventSourceHandlers.set(nonce, {
+        onmessage
+      });
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          this.sendMessage({
+            type: "abortSignal",
+            nonce,
+            reason: signal.reason
+          });
+        });
+      }
+      this.sendMessage({ type: "fetchEventSource", nonce, params: rest, url });
+    });
+  }
+  emit(...[event, data, transfer]) {
+    this.sendMessage(
+      {
+        type: "event",
+        event,
+        data
+      },
+      transfer
+    );
+  }
+  on(...[event, callback]) {
+    this.emitter.on(event, callback);
+  }
+  destroy() {
+    window.removeEventListener("message", this.handleMessage);
+    this.emitter.allOff();
+    this.handlers.clear();
+  }
+}
+const toUrlBase64 = (bin) => btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+const fromUrlBase64 = (b64) => atob(b64.replace(/-/g, "+").replace(/_/g, "/"));
+const encodeBase64 = (value) => {
+  if (value === void 0) {
+    throw new TypeError(
+      "encodeBase64: `undefined` cannot be encoded to valid JSON. Pass null instead."
+    );
+  }
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return toUrlBase64(bin);
+};
+const decodeBase64 = (b64) => {
+  const bin = fromUrlBase64(b64);
+  const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  const json = new TextDecoder().decode(bytes);
+  return JSON.parse(json);
+};
+class IntegrationError2 extends Error {
+}
+function fromPossibleFrameSafeError(err) {
+  return err.message;
+}
+const BASE_CAPABILITY_ALLOWLIST = [
+  // commands
+  "command.setOptions",
+  "command.sendUserMessage",
+  "command.setComposerValue",
+  "command.setThreadId",
+  "command.focusComposer",
+  "command.fetchUpdates",
+  "command.sendCustomAction",
+  "command.showHistory",
+  "command.hideHistory",
+  // events
+  "event.ready",
+  "event.error",
+  "event.log",
+  "event.response.start",
+  "event.response.end",
+  "event.response.stop",
+  "event.thread.change",
+  "event.tool.change",
+  "event.thread.load.start",
+  "event.thread.load.end",
+  "event.deeplink",
+  "event.effect",
+  // errors
+  "error.StreamError",
+  "error.StreamEventParsingError",
+  "error.WidgetItemError",
+  "error.InitialThreadLoadError",
+  "error.FileAttachmentError",
+  "error.HistoryViewError",
+  "error.FatalAppError",
+  "error.IntegrationError",
+  "error.EntitySearchError",
+  "error.DomainVerificationRequestError",
+  // backend
+  "backend.threads.get_by_id",
+  "backend.threads.list",
+  "backend.threads.update",
+  "backend.threads.delete",
+  "backend.threads.create",
+  "backend.threads.add_user_message",
+  "backend.threads.add_client_tool_output",
+  "backend.threads.retry_after_item",
+  "backend.threads.custom_action",
+  "backend.attachments.create",
+  "backend.attachments.get_preview",
+  "backend.attachments.delete",
+  "backend.items.list",
+  "backend.items.feedback",
+  // thread item types
+  "thread.item.generated_image",
+  "thread.item.user_message",
+  "thread.item.assistant_message",
+  "thread.item.client_tool_call",
+  "thread.item.widget",
+  "thread.item.task",
+  "thread.item.workflow",
+  "thread.item.end_of_turn",
+  "thread.item.image_generation",
+  // widgets
+  "widget.Basic",
+  "widget.Card",
+  "widget.ListView",
+  "widget.ListViewItem",
+  "widget.Badge",
+  "widget.Box",
+  "widget.Row",
+  "widget.Col",
+  "widget.Button",
+  "widget.Caption",
+  "widget.Chart",
+  "widget.Checkbox",
+  "widget.DatePicker",
+  "widget.Divider",
+  "widget.Form",
+  "widget.Icon",
+  "widget.Image",
+  "widget.Input",
+  "widget.Label",
+  "widget.Markdown",
+  "widget.RadioGroup",
+  "widget.Select",
+  "widget.Spacer",
+  "widget.Text",
+  "widget.Textarea",
+  "widget.Title",
+  "widget.Transition"
+];
+const BASE_CAPABILITY_DENYLIST = [
+  // --- commands
+  "command.shareThread",
+  "command.setTrainingOptOut",
+  // --- events
+  "event.thread.restore",
+  "event.message.share",
+  "event.image.download",
+  "event.history.open",
+  "event.history.close",
+  "event.log.chatgpt",
+  // --- errors
+  // These errors considered internal and are not exposed to the user by default.
+  "error.HttpError",
+  "error.NetworkError",
+  "error.UnhandledError",
+  "error.UnhandledPromiseRejectionError",
+  "error.StreamEventHandlingError",
+  "error.StreamStopError",
+  "error.ThreadRenderingError",
+  "error.IntlError",
+  "error.AppError",
+  // --- backend
+  "backend.threads.stop",
+  "backend.threads.share",
+  "backend.threads.create_from_shared",
+  "backend.threads.init",
+  "backend.attachments.process",
+  // widgets
+  "widget.CardCarousel",
+  "widget.Favicon",
+  "widget.CardLinkItem",
+  "widget.Map"
+];
+const PROFILE_TO_RULES = {
+  "chatkit": {
+    allow: [...BASE_CAPABILITY_ALLOWLIST, "thread.item.image_generation"],
+    deny: BASE_CAPABILITY_DENYLIST
+  }
+};
+const getCapabilities = (profile) => {
+  const rules = PROFILE_TO_RULES[profile];
+  const effective = new Set(rules.allow);
+  for (const capability of rules.deny ?? []) {
+    effective.delete(capability);
+  }
+  const commands = /* @__PURE__ */ new Set();
+  const events = /* @__PURE__ */ new Set();
+  const backend = /* @__PURE__ */ new Set();
+  const threadItems = /* @__PURE__ */ new Set();
+  const errors = /* @__PURE__ */ new Set();
+  const widgets = /* @__PURE__ */ new Set();
+  for (const capability of effective) {
+    if (capability.startsWith("command.")) {
+      commands.add(capability.slice("command.".length));
+      continue;
+    }
+    if (capability.startsWith("event.")) {
+      events.add(capability.slice("event.".length));
+      continue;
+    }
+    if (capability.startsWith("backend.")) {
+      backend.add(capability.slice("backend.".length));
+      continue;
+    }
+    if (capability.startsWith("thread.item.")) {
+      threadItems.add(capability.slice("thread.item.".length));
+    }
+    if (capability.startsWith("error.")) {
+      errors.add(capability.slice("error.".length));
+      continue;
+    }
+    if (capability.startsWith("widget.")) {
+      widgets.add(capability.slice("widget.".length));
+      continue;
+    }
+  }
+  return { commands, events, backend, threadItems, errors, widgets };
+};
+export {
+  BASE_CAPABILITY_ALLOWLIST,
+  BASE_CAPABILITY_DENYLIST,
+  BaseMessenger,
+  IntegrationError2 as IntegrationError,
+  PROFILE_TO_RULES,
+  decodeBase64,
+  encodeBase64,
+  fromPossibleFrameSafeError,
+  getCapabilities
+};
+//# sourceMappingURL=index.js.map