@lichen-ai/chatkit-web-shared 0.4.0

package/dist/index.js

@@ -0,0 +1,817 @@
+class EventEmitter {
+  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) {
+    const data = args[0];
+    this.callbacks.get(event)?.forEach((callback) => callback(data));
+  }
+  off(event, callback) {
+    if (!callback) {
+      this.callbacks.delete(event);
+    } else {
+      this.callbacks.get(event)?.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, _a) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["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 _a2;
+      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 = (_a2 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a2 !== void 0 ? _a2 : 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 {
+  status;
+  statusText;
+  metadata;
+  constructor(message, res, metadata) {
+    super(message);
+    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;
+  }
+}
+class FrameSafeHttpError {
+  [FRAME_SAFE_ERROR_KEY] = "HttpError";
+  message;
+  stack;
+  status;
+  statusText;
+  metadata;
+  constructor(message, res, 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
+    );
+  }
+}
+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) => {
+      onopen?.(res);
+      if (res.ok && res.headers.get("content-type")?.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;
+    }
+  });
+};
+function safeRandomUUID() {
+  const cryptoRef = globalThis.crypto;
+  if (typeof cryptoRef?.randomUUID === "function") {
+    return cryptoRef.randomUUID();
+  }
+  if (typeof cryptoRef?.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    cryptoRef.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("").replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+  }
+  return `ck_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+let IntegrationError$1 = class IntegrationError extends Error {
+  _name;
+  constructor(message) {
+    super(message);
+    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;
+  }
+};
+class FrameSafeIntegrationError {
+  [FRAME_SAFE_ERROR_KEY] = "IntegrationError";
+  message;
+  stack;
+  constructor(message) {
+    this.message = message;
+    this.stack = new Error(message).stack;
+  }
+}
+class BaseMessenger {
+  targetOrigin;
+  target;
+  commandHandlers;
+  _fetch;
+  constructor({
+    handlers,
+    target,
+    targetOrigin,
+    fetch = window.fetch
+  }) {
+    this.commandHandlers = handlers;
+    this.target = target;
+    this.targetOrigin = targetOrigin;
+    this._fetch = ((...args) => fetch(...args));
+  }
+  emitter = new EventEmitter();
+  handlers = /* @__PURE__ */ new Map();
+  fetchEventSourceHandlers = /* @__PURE__ */ new Map();
+  setTargetOrigin(targetOrigin) {
+    this.targetOrigin = targetOrigin;
+  }
+  abortControllers = /* @__PURE__ */ new Map();
+  sendMessage(data, transfer) {
+    const message = {
+      __xpaiChatKit: true,
+      ...data
+    };
+    this.target()?.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 = safeRandomUUID();
+      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", () => {
+          this.sendMessage({
+            type: "abortSignal",
+            nonce,
+            reason: params.signal?.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 = safeRandomUUID();
+      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 });
+    });
+  }
+  commands = new Proxy(
+    {},
+    {
+      get: (_, command) => {
+        return (data, transfer) => {
+          return new Promise((resolve, reject) => {
+            const nonce = safeRandomUUID();
+            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
+            );
+          });
+        };
+      }
+    }
+  );
+  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();
+  }
+  handleMessage = async (event) => {
+    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": {
+        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 this.commandHandlers[data.command]?.(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;
+        }
+        this.fetchEventSourceHandlers.get(data.nonce)?.onmessage?.(data.message);
+        break;
+      }
+      case "abortSignal": {
+        const controller = this.abortControllers.get(data.nonce);
+        if (controller) {
+          controller.abort(data.reason);
+          this.abortControllers.delete(data.nonce);
+        }
+        break;
+      }
+    }
+  };
+}
+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