stream-chat-react 14.0.0-beta.3 → 14.0.0-beta.4

package/dist/es/WithAudioPlayback.89700cb5.mjs

@@ -0,0 +1,4654 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import React, { useContext, createContext, useCallback, useMemo, forwardRef, useRef, useEffect, createElement, useState, useReducer, useLayoutEffect } from "react";
+import { flip, shift, size, useFloating, autoUpdate, autoPlacement, offset } from "@floating-ui/react";
+import { StateStore, MessageComposer, FixedSizeQueueCache, ErrorFromResponse, localMessageToNewMessagePayload } from "stream-chat";
+import throttle from "lodash.throttle";
+import { useSyncExternalStore } from "use-sync-external-store/shim";
+import clsx from "clsx";
+import debounce from "lodash.debounce";
+import Dayjs from "dayjs";
+import * as linkify from "linkifyjs";
+import { nanoid } from "nanoid";
+import deepequal from "react-fast-compare";
+import emojiRegex from "emoji-regex";
+const ChannelActionContext = React.createContext(void 0);
+const ChannelActionProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(ChannelActionContext.Provider, { value, children });
+const useChannelActionContext = (componentName) => {
+  const contextValue = useContext(ChannelActionContext);
+  if (!contextValue) {
+    console.warn(
+      `The useChannelActionContext hook was called outside of the ChannelActionContext provider. Make sure this hook is called within a child of the Channel component. The errored call is located in the ${componentName} component.`
+    );
+    return {};
+  }
+  return contextValue;
+};
+const ChannelListContext = createContext(
+  void 0
+);
+const ChannelListContextProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(ChannelListContext.Provider, { value, children });
+const useChannelListContext = () => {
+  const contextValue = useContext(ChannelListContext);
+  if (!contextValue) {
+    return {};
+  }
+  return contextValue;
+};
+const ChannelStateContext = React.createContext(void 0);
+const ChannelStateProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(ChannelStateContext.Provider, { value, children });
+let remainingWarningCount = 1;
+const useChannelStateContext = (componentName) => {
+  const contextValue = useContext(ChannelStateContext);
+  if (!contextValue) {
+    if (componentName && remainingWarningCount > 0) {
+      console.warn(
+        `The useChannelStateContext hook was called outside of the ChannelStateContext provider. Make sure this hook is called within a child of the Channel component. The errored call is located in the ${componentName} component.`
+      );
+      remainingWarningCount -= 1;
+    }
+    return {};
+  }
+  return contextValue;
+};
+const ChatContext = React.createContext(void 0);
+const ChatProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+const useChatContext = (componentName) => {
+  const contextValue = useContext(ChatContext);
+  if (!contextValue) {
+    console.warn(
+      `The useChatContext hook was called outside of the ChatContext provider. Make sure this hook is called within a child of the Chat component. The errored call is located in the ${componentName} component.`
+    );
+    return {};
+  }
+  return contextValue;
+};
+const ComponentContext = React.createContext({});
+const ComponentProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(ComponentContext.Provider, { value, children });
+const useComponentContext = (_componentName) => useContext(ComponentContext);
+const noop = () => {
+};
+function useStateStore(store, selector) {
+  const wrappedSubscription = useCallback(
+    (onStoreChange) => {
+      const unsubscribe = store?.subscribeWithSelector(selector, onStoreChange);
+      return unsubscribe ?? noop;
+    },
+    [store, selector]
+  );
+  const wrappedSnapshot = useMemo(() => {
+    let cachedTuple;
+    return () => {
+      const currentValue = store?.getLatestValue();
+      if (!currentValue) return void 0;
+      if (cachedTuple && cachedTuple[0] === currentValue) {
+        return cachedTuple[1];
+      }
+      const newlySelected = selector(currentValue);
+      if (cachedTuple) {
+        let selectededAreEqualToCached = true;
+        for (const key in cachedTuple[1]) {
+          if (cachedTuple[1][key] === newlySelected[key]) continue;
+          selectededAreEqualToCached = false;
+          break;
+        }
+        if (selectededAreEqualToCached) return cachedTuple[1];
+      }
+      cachedTuple = [currentValue, newlySelected];
+      return cachedTuple[1];
+    };
+  }, [store, selector]);
+  const state = useSyncExternalStore(wrappedSubscription, wrappedSnapshot);
+  return state;
+}
+const MessageComposerContext = createContext(void 0);
+const MessageComposerContextProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(
+  MessageComposerContext.Provider,
+  {
+    value,
+    children
+  }
+);
+const useMessageComposerContext = (componentName) => {
+  const contextValue = useContext(MessageComposerContext);
+  if (!contextValue) {
+    return {};
+  }
+  return contextValue;
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var calendar$2 = { exports: {} };
+var calendar$1 = calendar$2.exports;
+var hasRequiredCalendar;
+function requireCalendar() {
+  if (hasRequiredCalendar) return calendar$2.exports;
+  hasRequiredCalendar = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(calendar$1, function() {
+      return function(e, t, a) {
+        var n = "h:mm A", d = { lastDay: "[Yesterday at] " + n, sameDay: "[Today at] " + n, nextDay: "[Tomorrow at] " + n, nextWeek: "dddd [at] " + n, lastWeek: "[Last] dddd [at] " + n, sameElse: "MM/DD/YYYY" };
+        t.prototype.calendar = function(e2, t2) {
+          var n2 = t2 || this.$locale().calendar || d, s = a(e2 || void 0).startOf("d"), o = this.diff(s, "d", true), i = o < -6 ? "sameElse" : o < -1 ? "lastWeek" : o < 0 ? "lastDay" : o < 1 ? "sameDay" : o < 2 ? "nextDay" : o < 7 ? "nextWeek" : "sameElse", f = n2[i] || d[i];
+          return "function" == typeof f ? f.call(this, a()) : this.format(f);
+        };
+      };
+    });
+  })(calendar$2);
+  return calendar$2.exports;
+}
+var calendarExports = requireCalendar();
+const calendar = /* @__PURE__ */ getDefaultExportFromCjs(calendarExports);
+var localizedFormat$1 = { exports: {} };
+var localizedFormat = localizedFormat$1.exports;
+var hasRequiredLocalizedFormat;
+function requireLocalizedFormat() {
+  if (hasRequiredLocalizedFormat) return localizedFormat$1.exports;
+  hasRequiredLocalizedFormat = 1;
+  (function(module, exports$1) {
+    !(function(e, t) {
+      module.exports = t();
+    })(localizedFormat, function() {
+      var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" };
+      return function(t, n, o) {
+        var r = n.prototype, M = r.format;
+        o.en.formats = e, r.format = function(t2) {
+          void 0 === t2 && (t2 = "YYYY-MM-DDTHH:mm:ssZ");
+          var n2 = this.$locale().formats, o2 = (function(t3, n3) {
+            return t3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t4, o3, r2) {
+              var M2 = r2 && r2.toUpperCase();
+              return o3 || n3[r2] || e[r2] || n3[M2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t5, n4) {
+                return t5 || n4.slice(1);
+              });
+            });
+          })(t2, void 0 === n2 ? {} : n2);
+          return M.call(this, o2);
+        };
+      };
+    });
+  })(localizedFormat$1);
+  return localizedFormat$1.exports;
+}
+var localizedFormatExports = requireLocalizedFormat();
+const LocalizedFormat = /* @__PURE__ */ getDefaultExportFromCjs(localizedFormatExports);
+const isNumberOrString = (output) => typeof output === "string" || typeof output === "number";
+const isDayOrMoment = (output) => !!output?.isSame;
+const isDate = (output) => output !== null && typeof output === "object" && typeof output.getTime === "function";
+const DEFAULT_RELATIVE_COMPACT_MAX_DAYS = 6;
+const DEFAULT_RELATIVE_COMPACT_MAX_WEEKS = 3;
+function getRelativeCompactDateString(messageCreatedAt, t, tDateTimeParser, maxDays = DEFAULT_RELATIVE_COMPACT_MAX_DAYS, maxWeeks = DEFAULT_RELATIVE_COMPACT_MAX_WEEKS) {
+  const then = tDateTimeParser(messageCreatedAt);
+  if (!isDayOrMoment(then)) return null;
+  const now = tDateTimeParser((/* @__PURE__ */ new Date()).toISOString());
+  if (!isDayOrMoment(now)) return null;
+  const diffDays = now.startOf("day").diff(then.startOf("day"), "day");
+  if (diffDays < 0) {
+    return then.format("DD/MM/YY");
+  }
+  if (diffDays === 0) return t("timestamp/relativeToday");
+  if (diffDays === 1) return t("timestamp/relativeYesterday");
+  if (diffDays >= 2 && diffDays <= maxDays)
+    return t("timestamp/relativeDaysAgo", { count: diffDays });
+  if (maxWeeks > 0) {
+    const maxDaysForWeeks = maxWeeks * 7;
+    if (diffDays >= 7 && diffDays <= maxDaysForWeeks) {
+      const weeks = Math.ceil(diffDays / 7);
+      return t("timestamp/relativeWeeksAgo", { count: weeks });
+    }
+  }
+  return then.format("DD/MM/YY");
+}
+function getDateString({
+  calendar: calendar2,
+  calendarFormats,
+  format,
+  formatDate,
+  messageCreatedAt,
+  relativeCompact,
+  relativeCompactMaxDays,
+  relativeCompactMaxWeeks,
+  t,
+  tDateTimeParser,
+  timestampTranslationKey
+}) {
+  if (!messageCreatedAt || typeof messageCreatedAt === "string" && !Date.parse(messageCreatedAt)) {
+    return null;
+  }
+  if (typeof formatDate === "function") {
+    return formatDate(new Date(messageCreatedAt));
+  }
+  if (relativeCompact && t && tDateTimeParser) {
+    const maxDays = typeof relativeCompactMaxDays === "number" ? relativeCompactMaxDays : typeof relativeCompactMaxDays === "string" ? parseInt(relativeCompactMaxDays, 10) : DEFAULT_RELATIVE_COMPACT_MAX_DAYS;
+    const maxWeeks = typeof relativeCompactMaxWeeks === "number" ? relativeCompactMaxWeeks : typeof relativeCompactMaxWeeks === "string" ? parseInt(relativeCompactMaxWeeks, 10) : DEFAULT_RELATIVE_COMPACT_MAX_WEEKS;
+    const result = getRelativeCompactDateString(
+      messageCreatedAt,
+      t,
+      tDateTimeParser,
+      Number.isNaN(maxDays) ? DEFAULT_RELATIVE_COMPACT_MAX_DAYS : maxDays,
+      Number.isNaN(maxWeeks) ? DEFAULT_RELATIVE_COMPACT_MAX_WEEKS : maxWeeks
+    );
+    if (result) return result;
+  }
+  if (t && timestampTranslationKey) {
+    const options = {};
+    if (typeof calendar2 !== "undefined" && calendar2 !== null) options.calendar = calendar2;
+    if (typeof calendarFormats !== "undefined" && calendarFormats !== null)
+      options.calendarFormats = calendarFormats;
+    if (typeof format !== "undefined" && format !== null) options.format = format;
+    const translatedTimestamp = t(timestampTranslationKey, {
+      ...options,
+      timestamp: new Date(messageCreatedAt)
+    });
+    const translationKeyFound = timestampTranslationKey !== translatedTimestamp;
+    if (translationKeyFound) return translatedTimestamp;
+  }
+  if (!tDateTimeParser) {
+    return null;
+  }
+  const parsedTime = tDateTimeParser(messageCreatedAt);
+  if (isDayOrMoment(parsedTime)) {
+    return calendar2 && parsedTime.calendar ? parsedTime.calendar(void 0, calendarFormats || void 0) : parsedTime.format(format || void 0);
+  }
+  if (isDate(parsedTime)) {
+    return parsedTime.toDateString();
+  }
+  if (isNumberOrString(parsedTime)) {
+    return parsedTime;
+  }
+  return null;
+}
+const predefinedFormatters = {
+  durationFormatter: (streamI18n) => (value, _, { format, withSuffix }) => {
+    if (format && Dayjs.isDayjs(streamI18n.DateTimeParser)) {
+      return streamI18n.DateTimeParser.duration(value).format(
+        format
+      );
+    }
+    return streamI18n.DateTimeParser.duration(value).humanize(!!withSuffix);
+  },
+  timestampFormatter: (streamI18n) => (value, _, {
+    calendarFormats,
+    ...options
+  }) => {
+    let parsedCalendarFormats;
+    try {
+      if (!options.calendar) {
+        parsedCalendarFormats = {};
+      } else if (typeof calendarFormats === "string") {
+        parsedCalendarFormats = JSON.parse(calendarFormats);
+      } else if (typeof calendarFormats === "object") {
+        parsedCalendarFormats = calendarFormats;
+      }
+    } catch (e) {
+      console.error("[TIMESTAMP FORMATTER]", e);
+    }
+    const result = getDateString({
+      ...options,
+      calendarFormats: parsedCalendarFormats,
+      messageCreatedAt: value,
+      t: streamI18n.t,
+      tDateTimeParser: streamI18n.tDateTimeParser
+    });
+    if (!result || typeof result === "number") {
+      return JSON.stringify(value);
+    }
+    return result;
+  }
+};
+const defaultTranslatorFunction = ((key) => key);
+const defaultDateTimeParser = (input) => Dayjs(input);
+const isLanguageSupported = (language) => {
+  const translations = [
+    "de",
+    "en",
+    "es",
+    "fr",
+    "hi",
+    "it",
+    "ja",
+    "ko",
+    "nl",
+    "pt",
+    "ru",
+    "tr"
+  ];
+  return translations.some((translation) => language === translation);
+};
+Dayjs.extend(calendar);
+Dayjs.extend(LocalizedFormat);
+const TranslationContext = React.createContext({
+  t: defaultTranslatorFunction,
+  tDateTimeParser: defaultDateTimeParser,
+  userLanguage: "en"
+});
+const TranslationProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(TranslationContext.Provider, { value, children });
+const useTranslationContext = (componentName) => {
+  const contextValue = useContext(TranslationContext);
+  if (!contextValue) {
+    console.warn(
+      `The useTranslationContext hook was called outside of the TranslationContext provider. Make sure this hook is called within a child of the Chat component. The errored call is located in the ${componentName} component.`
+    );
+    return {};
+  }
+  return contextValue;
+};
+const TypingContext = React.createContext(
+  void 0
+);
+const TypingProvider = ({
+  children,
+  value
+}) => /* @__PURE__ */ jsx(TypingContext.Provider, { value, children });
+const useTypingContext = (componentName) => {
+  const contextValue = useContext(TypingContext);
+  if (!contextValue) {
+    console.warn(
+      `The useTypingContext hook was called outside of the TypingContext provider. Make sure this hook is called within a child of the Channel component. The errored call is located in the ${componentName} component.`
+    );
+    return {};
+  }
+  return contextValue;
+};
+const DEFAULT_PLAYBACK_RATES = [1, 1.5, 2];
+const isSeekable = (audioElement) => !(audioElement.duration === Infinity || isNaN(audioElement.duration));
+const defaultRegisterAudioPlayerError = ({
+  error
+} = {}) => {
+  if (!error) return;
+  console.error("[AUDIO PLAYER]", error);
+};
+const elementIsPlaying = (audioElement) => audioElement && !(audioElement.paused || audioElement.ended);
+class AudioPlayer {
+  constructor({
+    durationSeconds,
+    fileSize,
+    id,
+    mimeType,
+    playbackRates: customPlaybackRates,
+    plugins,
+    pool,
+    src,
+    title,
+    waveformData
+  }) {
+    this._plugins = /* @__PURE__ */ new Map();
+    this.playTimeout = void 0;
+    this.unsubscribeEventListeners = null;
+    this._disposed = false;
+    this._metadataProbe = null;
+    this._restoringPosition = false;
+    this._removalTimeout = void 0;
+    this.setDurationSeconds = (durationSeconds2) => {
+      this._data.durationSeconds = durationSeconds2;
+      this.state.partialNext({ durationSeconds: durationSeconds2 });
+    };
+    this.setPlaybackStartSafetyTimeout = () => {
+      clearTimeout(this.playTimeout);
+      this.playTimeout = setTimeout(() => {
+        if (!this.elementRef) return;
+        try {
+          this.elementRef.pause();
+          this.state.partialNext({ isPlaying: false });
+        } catch (e) {
+          this.registerError({ errCode: "failed-to-start" });
+        }
+      }, 2e3);
+    };
+    this.updateDurationFromElement = (element) => {
+      const duration = element.duration;
+      if (typeof duration !== "number" || isNaN(duration) || !isFinite(duration) || duration <= 0) {
+        return;
+      }
+      this.setDurationSeconds(duration);
+    };
+    this.clearMetadataProbe = () => {
+      const probe = this._metadataProbe;
+      this._metadataProbe = null;
+      this._metadataProbePromise = void 0;
+      if (!probe) return;
+      try {
+        probe.pause();
+      } catch {
+      }
+      probe.removeAttribute("src");
+      try {
+        probe.load();
+      } catch {
+      }
+    };
+    this.preloadMetadata = () => {
+      if (this._disposed || this.durationSeconds != null || !this.src || this._metadataProbePromise || typeof document === "undefined") {
+        return;
+      }
+      const probe = document.createElement("audio");
+      probe.preload = "metadata";
+      this._metadataProbe = probe;
+      this._metadataProbePromise = new Promise((resolve) => {
+        const cleanup = () => {
+          probe.removeEventListener("loadedmetadata", handleLoadedMetadata);
+          probe.removeEventListener("error", handleError);
+          if (this._metadataProbe === probe) {
+            this.clearMetadataProbe();
+          } else {
+            this._metadataProbePromise = void 0;
+          }
+          resolve();
+        };
+        const handleLoadedMetadata = () => {
+          this.updateDurationFromElement(probe);
+          cleanup();
+        };
+        const handleError = () => {
+          cleanup();
+        };
+        probe.addEventListener("loadedmetadata", handleLoadedMetadata, { once: true });
+        probe.addEventListener("error", handleError, { once: true });
+        probe.src = this.src;
+        try {
+          probe.load();
+        } catch {
+          cleanup();
+        }
+      });
+    };
+    this.clearPlaybackStartSafetyTimeout = () => {
+      if (!this.elementRef) return;
+      clearTimeout(this.playTimeout);
+      this.playTimeout = void 0;
+    };
+    this.clearPendingLoadedMeta = () => {
+      const pending = this._pendingLoadedMeta;
+      if (pending?.element && pending.onLoaded) {
+        pending.element.removeEventListener("loadedmetadata", pending.onLoaded);
+      }
+      this._pendingLoadedMeta = void 0;
+    };
+    this.restoreSavedPosition = (elementRef) => {
+      const saved = this.secondsElapsed;
+      if (!saved || saved <= 0) return;
+      const apply = () => {
+        const duration = elementRef.duration;
+        const clamped = typeof duration === "number" && !isNaN(duration) && isFinite(duration) ? Math.min(saved, duration) : saved;
+        try {
+          if (elementRef.currentTime === clamped) return;
+          elementRef.currentTime = clamped;
+          this.setSecondsElapsed(clamped);
+        } catch {
+        }
+      };
+      if (elementRef.readyState < 1) {
+        this.clearPendingLoadedMeta();
+        this._restoringPosition = true;
+        const onLoaded = () => {
+          if (this._pendingLoadedMeta?.onLoaded !== onLoaded) return;
+          this._pendingLoadedMeta = void 0;
+          if (this.elementRef !== elementRef) {
+            this._restoringPosition = false;
+            return;
+          }
+          apply();
+          this._restoringPosition = false;
+        };
+        elementRef.addEventListener("loadedmetadata", onLoaded, { once: true });
+        this._pendingLoadedMeta = { element: elementRef, onLoaded };
+      } else {
+        this._restoringPosition = true;
+        apply();
+        this._restoringPosition = false;
+      }
+    };
+    this.elementIsReady = () => {
+      if (this._elementIsReadyPromise) return this._elementIsReadyPromise;
+      this._elementIsReadyPromise = new Promise((resolve) => {
+        if (!this.elementRef) return resolve(false);
+        const element = this.elementRef;
+        const handleLoaded = () => {
+          element.removeEventListener("loadedmetadata", handleLoaded);
+          resolve(element.readyState > 0);
+        };
+        element.addEventListener("loadedmetadata", handleLoaded);
+      });
+      return this._elementIsReadyPromise;
+    };
+    this.setRef = (elementRef) => {
+      if (elementIsPlaying(this.elementRef)) {
+        this.releaseElement({ resetState: false });
+      }
+      this.clearPendingLoadedMeta();
+      this.clearMetadataProbe();
+      this._restoringPosition = false;
+      this._elementIsReadyPromise = void 0;
+      this.state.partialNext({ elementRef });
+      if (elementRef) {
+        this.registerSubscriptions();
+      }
+    };
+    this.setSecondsElapsed = (secondsElapsed) => {
+      const duration = this.elementRef?.duration ?? this.durationSeconds;
+      this.state.partialNext({
+        progressPercent: duration && secondsElapsed ? secondsElapsed / duration * 100 : 0,
+        secondsElapsed
+      });
+    };
+    this.canPlayMimeType = (mimeType2) => {
+      if (!mimeType2) return false;
+      if (this.elementRef) return !!this.elementRef.canPlayType(mimeType2);
+      return !!new Audio().canPlayType(mimeType2);
+    };
+    this.play = async (params) => {
+      if (this._disposed) return;
+      const elementRef = this.ensureElementRef();
+      if (elementIsPlaying(this.elementRef)) {
+        if (this.isPlaying) return;
+        this.state.partialNext({ isPlaying: true });
+        return;
+      }
+      const { currentPlaybackRate, playbackRates: playbackRates2 } = {
+        currentPlaybackRate: this.currentPlaybackRate,
+        playbackRates: this.playbackRates,
+        ...params
+      };
+      if (!this.canPlayRecord) {
+        this.registerError({ errCode: "not-playable" });
+        return;
+      }
+      this.restoreSavedPosition(elementRef);
+      elementRef.playbackRate = currentPlaybackRate ?? this.currentPlaybackRate;
+      this.setPlaybackStartSafetyTimeout();
+      try {
+        await elementRef.play();
+        this.state.partialNext({
+          currentPlaybackRate,
+          isPlaying: true,
+          playbackRates: playbackRates2
+        });
+        this._pool.setActiveAudioPlayer(this);
+      } catch (e) {
+        this.registerError({ error: e });
+        this.state.partialNext({ isPlaying: false });
+      } finally {
+        this.clearPlaybackStartSafetyTimeout();
+      }
+    };
+    this.pause = () => {
+      if (!elementIsPlaying(this.elementRef)) return;
+      this.clearPlaybackStartSafetyTimeout();
+      this.elementRef.pause();
+      this.state.partialNext({ isPlaying: false });
+    };
+    this.stop = () => {
+      this.pause();
+      this.state.partialNext({ isPlaying: false });
+      this.setSecondsElapsed(0);
+      if (this.elementRef) this.elementRef.currentTime = 0;
+    };
+    this.togglePlay = async () => this.isPlaying ? this.pause() : await this.play();
+    this.increasePlaybackRate = () => {
+      let currentPlaybackRateIndex = this.state.getLatestValue().playbackRates.findIndex((rate) => rate === this.currentPlaybackRate);
+      if (currentPlaybackRateIndex === -1) {
+        currentPlaybackRateIndex = 0;
+      }
+      const nextIndex = currentPlaybackRateIndex === this.playbackRates.length - 1 ? 0 : currentPlaybackRateIndex + 1;
+      const currentPlaybackRate = this.playbackRates[nextIndex];
+      this.state.partialNext({ currentPlaybackRate });
+      if (this.elementRef) {
+        this.elementRef.playbackRate = currentPlaybackRate;
+      }
+    };
+    this.seek = throttle(async ({ clientX, currentTarget }) => {
+      let element = this.elementRef;
+      if (!this.elementRef) {
+        element = this.ensureElementRef();
+        const isReady = await this.elementIsReady();
+        if (!isReady) return;
+      }
+      if (!currentTarget || !element) return;
+      if (!isSeekable(element)) {
+        this.registerError({ errCode: "seek-not-supported" });
+        return;
+      }
+      const { width, x } = currentTarget.getBoundingClientRect();
+      const ratio = (clientX - x) / width;
+      if (ratio > 1 || ratio < 0) return;
+      const currentTime = ratio * element.duration;
+      this.setSecondsElapsed(currentTime);
+      element.currentTime = currentTime;
+    }, 16);
+    this.registerError = (params) => {
+      defaultRegisterAudioPlayerError(params);
+      this.plugins.forEach(({ onError }) => onError?.({ player: this, ...params }));
+    };
+    this.requestRemoval = () => {
+      this._disposed = true;
+      this.cancelScheduledRemoval();
+      this.clearPendingLoadedMeta();
+      this.clearMetadataProbe();
+      this._restoringPosition = false;
+      this.releaseElement({ resetState: true });
+      this.unsubscribeEventListeners?.();
+      this.unsubscribeEventListeners = null;
+      this.plugins.forEach(({ onRemove }) => onRemove?.({ player: this }));
+      this._pool.deregister(this.id);
+    };
+    this.cancelScheduledRemoval = () => {
+      clearTimeout(this._removalTimeout);
+      this._removalTimeout = void 0;
+    };
+    this.scheduleRemoval = (ms = 0) => {
+      this.cancelScheduledRemoval();
+      this._removalTimeout = setTimeout(() => {
+        if (this.disposed) return;
+        this.requestRemoval();
+      }, ms);
+    };
+    this.releaseElementForHandoff = () => {
+      if (!this.elementRef) return;
+      this.releaseElement({ resetState: false });
+      this.unsubscribeEventListeners?.();
+      this.unsubscribeEventListeners = null;
+    };
+    this.registerSubscriptions = () => {
+      this.unsubscribeEventListeners?.();
+      const audioElement = this.elementRef;
+      if (!audioElement) return;
+      const handleEnded = () => {
+        if (audioElement) {
+          this.updateDurationFromElement(audioElement);
+        }
+        this.stop();
+      };
+      const handleError = (e) => {
+        const audio = e.currentTarget;
+        const state = { isPlaying: false };
+        if (!audio?.error?.code) {
+          this.state.partialNext(state);
+          return;
+        }
+        if (audio.error.code === 4) {
+          state.canPlayRecord = false;
+          this.state.partialNext(state);
+        }
+        const errorMsg = [
+          void 0,
+          "MEDIA_ERR_ABORTED: fetch aborted by user",
+          "MEDIA_ERR_NETWORK: network failed while fetching",
+          "MEDIA_ERR_DECODE: audio fetched but couldn’t decode",
+          "MEDIA_ERR_SRC_NOT_SUPPORTED: source not supported"
+        ][audio?.error?.code];
+        if (!errorMsg) return;
+        defaultRegisterAudioPlayerError({ error: new Error(errorMsg + ` (${audio.src})`) });
+      };
+      const handleTimeupdate = () => {
+        const t = audioElement?.currentTime ?? 0;
+        if (this._restoringPosition && t === 0) return;
+        if (!this.isPlaying && t === 0 && this.secondsElapsed > 0) return;
+        this.setSecondsElapsed(t);
+      };
+      const handleLoadedMetadata = () => {
+        if (audioElement) {
+          this.updateDurationFromElement(audioElement);
+        }
+      };
+      audioElement.addEventListener("ended", handleEnded);
+      audioElement.addEventListener("error", handleError);
+      audioElement.addEventListener("loadedmetadata", handleLoadedMetadata);
+      audioElement.addEventListener("timeupdate", handleTimeupdate);
+      this.unsubscribeEventListeners = () => {
+        audioElement.pause();
+        audioElement.removeEventListener("ended", handleEnded);
+        audioElement.removeEventListener("error", handleError);
+        audioElement.removeEventListener("loadedmetadata", handleLoadedMetadata);
+        audioElement.removeEventListener("timeupdate", handleTimeupdate);
+      };
+    };
+    this._data = {
+      durationSeconds,
+      fileSize,
+      id,
+      mimeType,
+      src,
+      title,
+      waveformData
+    };
+    this._pool = pool;
+    this.setPlugins(() => plugins ?? []);
+    const playbackRates = customPlaybackRates?.length ? customPlaybackRates : DEFAULT_PLAYBACK_RATES;
+    const canPlayRecord = mimeType ? !!new Audio().canPlayType(mimeType) : true;
+    this.state = new StateStore({
+      canPlayRecord,
+      currentPlaybackRate: playbackRates[0],
+      durationSeconds,
+      elementRef: null,
+      isPlaying: false,
+      playbackError: null,
+      playbackRates,
+      progressPercent: 0,
+      secondsElapsed: 0
+    });
+    this.plugins.forEach((p) => p.onInit?.({ player: this }));
+    this.preloadMetadata();
+  }
+  get plugins() {
+    return Array.from(this._plugins.values());
+  }
+  get canPlayRecord() {
+    return this.state.getLatestValue().canPlayRecord;
+  }
+  get elementRef() {
+    return this.state.getLatestValue().elementRef;
+  }
+  get isPlaying() {
+    return this.state.getLatestValue().isPlaying;
+  }
+  get currentPlaybackRate() {
+    return this.state.getLatestValue().currentPlaybackRate;
+  }
+  get playbackRates() {
+    return this.state.getLatestValue().playbackRates;
+  }
+  get durationSeconds() {
+    return this.state.getLatestValue().durationSeconds;
+  }
+  get fileSize() {
+    return this._data.fileSize;
+  }
+  get id() {
+    return this._data.id;
+  }
+  get src() {
+    return this._data.src;
+  }
+  get mimeType() {
+    return this._data.mimeType;
+  }
+  get title() {
+    return this._data.title;
+  }
+  get waveformData() {
+    return this._data.waveformData;
+  }
+  get secondsElapsed() {
+    return this.state.getLatestValue().secondsElapsed;
+  }
+  get progressPercent() {
+    return this.state.getLatestValue().progressPercent;
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  ensureElementRef() {
+    if (this._disposed) {
+      throw new Error("AudioPlayer is disposed");
+    }
+    if (!this.elementRef) {
+      const el = this._pool.acquireElement({
+        ownerId: this.id,
+        src: this.src
+      });
+      this.setRef(el);
+    }
+    return this.elementRef;
+  }
+  setDescriptor(descriptor) {
+    const previousSrc = this.src;
+    this._data = { ...this._data, ...descriptor };
+    if (descriptor.src !== previousSrc && this.elementRef) {
+      this.elementRef.src = descriptor.src;
+    }
+    if (descriptor.src && descriptor.src !== previousSrc) {
+      this.clearMetadataProbe();
+      if (descriptor.durationSeconds == null) {
+        this.setDurationSeconds(void 0);
+        this.preloadMetadata();
+      } else {
+        this.setDurationSeconds(descriptor.durationSeconds);
+      }
+      return;
+    }
+    if (descriptor.durationSeconds != null) {
+      this.setDurationSeconds(descriptor.durationSeconds);
+    }
+  }
+  releaseElement({ resetState }) {
+    this.clearPendingLoadedMeta();
+    this.clearMetadataProbe();
+    this._restoringPosition = false;
+    if (resetState) {
+      this.stop();
+    } else {
+      this.state.partialNext({ isPlaying: false });
+      if (this.elementRef) {
+        try {
+          this.elementRef.pause();
+        } catch {
+        }
+      }
+    }
+    if (this.elementRef) {
+      this._pool.releaseElement(this.id);
+      this.setRef(null);
+    }
+  }
+  setPlugins(setter) {
+    this._plugins = setter(this.plugins).reduce((acc, plugin) => {
+      if (plugin.id) {
+        acc.set(plugin.id, plugin);
+      }
+      return acc;
+    }, /* @__PURE__ */ new Map());
+  }
+}
+class AudioPlayerPool {
+  constructor(config) {
+    this.state = new StateStore({
+      activeAudioPlayer: null
+    });
+    this.pool = /* @__PURE__ */ new Map();
+    this.audios = /* @__PURE__ */ new Map();
+    this.sharedAudio = null;
+    this.sharedOwnerId = null;
+    this.getOrAdd = (params) => {
+      const { playbackRates, plugins, ...descriptor } = params;
+      let player = this.pool.get(params.id);
+      if (player) {
+        if (!player.disposed) {
+          player.setDescriptor(descriptor);
+          return player;
+        }
+        this.deregister(params.id);
+      }
+      player = new AudioPlayer({
+        playbackRates,
+        plugins,
+        ...descriptor,
+        pool: this
+      });
+      this.pool.set(params.id, player);
+      return player;
+    };
+    this.acquireElement = ({ ownerId, src }) => {
+      if (!this.allowConcurrentPlayback) {
+        if (!this.sharedAudio) {
+          this.sharedAudio = new Audio();
+        }
+        if (this.sharedOwnerId && this.sharedOwnerId !== ownerId) {
+          const previous = this.pool.get(this.sharedOwnerId);
+          previous?.pause();
+          previous?.releaseElementForHandoff();
+        }
+        this.sharedOwnerId = ownerId;
+        if (this.sharedAudio.src !== src) {
+          this.sharedAudio.src = src;
+        }
+        return this.sharedAudio;
+      }
+      let audio = this.audios.get(ownerId);
+      if (!audio) {
+        audio = new Audio();
+        this.audios.set(ownerId, audio);
+      }
+      if (audio.src !== src) {
+        audio.src = src;
+      }
+      return audio;
+    };
+    this.releaseElement = (ownerId) => {
+      if (!this.allowConcurrentPlayback) {
+        if (this.sharedOwnerId !== ownerId) return;
+        const el2 = this.sharedAudio;
+        if (el2) {
+          try {
+            el2.pause();
+          } catch {
+          }
+          el2.removeAttribute("src");
+          el2.load();
+        }
+        this.sharedOwnerId = null;
+        return;
+      }
+      const el = this.audios.get(ownerId);
+      if (!el) return;
+      try {
+        el.pause();
+      } catch {
+      }
+      el.removeAttribute("src");
+      el.load();
+      this.audios.delete(ownerId);
+    };
+    this.setActiveAudioPlayer = (activeAudioPlayer) => {
+      if (this.allowConcurrentPlayback) return;
+      this.state.partialNext({ activeAudioPlayer });
+    };
+    this.remove = (id) => {
+      const player = this.pool.get(id);
+      if (!player) return;
+      player.requestRemoval();
+    };
+    this.clear = () => {
+      this.players.forEach((player) => {
+        this.remove(player.id);
+      });
+    };
+    this.registerSubscriptions = () => {
+      this.players.forEach((p) => {
+        if (p.elementRef) {
+          p.registerSubscriptions();
+        }
+      });
+    };
+    this.allowConcurrentPlayback = !!config?.allowConcurrentPlayback;
+  }
+  get players() {
+    return Array.from(this.pool.values());
+  }
+  get activeAudioPlayer() {
+    return this.state.getLatestValue().activeAudioPlayer;
+  }
+  /** Removes the AudioPlayer instance from the pool of players */
+  deregister(id) {
+    if (this.pool.has(id)) {
+      this.pool.delete(id);
+    }
+    if (this.activeAudioPlayer?.id === id) {
+      this.setActiveAudioPlayer(null);
+    }
+  }
+}
+const NOTIFICATION_TARGET_PANELS = [
+  "channel",
+  "thread",
+  "channel-list",
+  "thread-list"
+];
+const isNotificationTargetPanel = (value) => typeof value === "string" && NOTIFICATION_TARGET_PANELS.includes(value);
+const getNotificationTargetPanel = (notification) => {
+  const targetTag = notification.tags?.find((tag) => tag.startsWith("target:"));
+  if (targetTag) {
+    const candidate = targetTag.slice("target:".length);
+    if (isNotificationTargetPanel(candidate)) return candidate;
+  }
+  const panel = notification.origin.context?.panel;
+  return isNotificationTargetPanel(panel) ? panel : void 0;
+};
+const getNotificationTargetTag = (panel) => `target:${panel}`;
+const addNotificationTargetTag = (panel, tags) => {
+  if (!panel) return tags ?? [];
+  return Array.from(/* @__PURE__ */ new Set([getNotificationTargetTag(panel), ...tags ?? []]));
+};
+const isNotificationForPanel = (notification, panel, options) => {
+  const fallbackPanel = options?.fallbackPanel ?? "channel";
+  const resolvedPanel = getNotificationTargetPanel(notification) ?? fallbackPanel;
+  return resolvedPanel === panel;
+};
+const audioPlayerNotificationsPluginFactory = ({
+  client,
+  panel = "channel",
+  t
+}) => {
+  const errors = {
+    "failed-to-start": new Error(t("Failed to play the recording")),
+    "not-playable": new Error(
+      t("Recording format is not supported and cannot be reproduced")
+    ),
+    "seek-not-supported": new Error(t("Cannot seek in the recording"))
+  };
+  return {
+    id: "AudioPlayerNotificationsPlugin",
+    onError: ({ errCode, error: e }) => {
+      const error = (errCode && errors[errCode]) ?? e ?? new Error(t("Error reproducing the recording"));
+      client?.notifications.addError({
+        message: error.message,
+        options: {
+          originalError: error,
+          tags: addNotificationTargetTag(panel),
+          type: "browser:audio:playback:error"
+        },
+        origin: {
+          emitter: "AudioPlayer"
+        }
+      });
+    }
+  };
+};
+const variantToClass = {
+  danger: "str-chat__button--destructive",
+  primary: "str-chat__button--primary",
+  secondary: "str-chat__button--secondary"
+};
+const appearanceToClass = {
+  ghost: "str-chat__button--ghost",
+  outline: "str-chat__button--outline",
+  solid: "str-chat__button--solid"
+};
+const sizeToClass = {
+  lg: "str-chat__button--size-lg",
+  md: "str-chat__button--size-md",
+  sm: "str-chat__button--size-sm",
+  xs: "str-chat__button--size-xs"
+};
+const Button = forwardRef(function Button2({ appearance, children, circular, className, inverseTheme, size: size2, variant, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      ...props,
+      className: clsx(
+        "str-chat__button",
+        variant != null && variantToClass[variant],
+        appearance != null && appearanceToClass[appearance],
+        circular && "str-chat__button--circular",
+        inverseTheme && "str-chat__theme-inverse",
+        size2 != null && sizeToClass[size2],
+        className
+      ),
+      children: /* @__PURE__ */ jsx("div", { className: "str-chat__button__content", children })
+    }
+  );
+});
+const BaseIcon = ({ className, ...props }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    viewBox: "0 0 20 20",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    className: clsx("str-chat__icon", className)
+  }
+);
+function toIconClass(name) {
+  return "str-chat__icon--" + name.replace(/^Icon/, "").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Za-z])(\d)/g, "$1-$2").replace(/(\d)([A-Za-z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+function createIcon(name, content, defaultProps) {
+  const iconClass = toIconClass(name);
+  const Icon = ({ className, ...props }) => /* @__PURE__ */ jsx(BaseIcon, { ...defaultProps, ...props, className: clsx(iconClass, className), children: content });
+  Icon.displayName = name;
+  return Icon;
+}
+const IconLeave = createIcon(
+  "IconLeave",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M8.75 3.125H3.75V16.875H8.75M8.75 10H17.5M17.5 10L14.375 6.875M17.5 10L14.375 13.125",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconArrowDown = createIcon(
+  "IconArrowDown",
+  /* @__PURE__ */ jsx("path", { d: "M7.39973 2.5C7.39973 2.16863 7.66895 1.90039 8.00032 1.90039C8.33154 1.90057 8.59993 2.16874 8.59993 2.5V12.0518L11.7425 8.90918C11.9768 8.67487 12.3568 8.67487 12.5911 8.90918C12.8253 9.14351 12.8254 9.52355 12.5911 9.75781L8.42415 13.9238C8.3117 14.0363 8.15933 14.0995 8.00032 14.0996C7.84119 14.0996 7.68804 14.0363 7.57552 13.9238L3.4095 9.75781C3.17519 9.5235 3.17519 9.14349 3.4095 8.90918C3.64377 8.67508 4.02288 8.67508 4.25716 8.90918L7.39973 12.0518V2.5Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconArrowDownCircle = createIcon(
+  "IconArrowDownCircle",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.5 10.625L10 13.125M10 13.125L12.5 10.625M10 13.125V6.875M17.5 10C17.5 14.1421 14.1421 17.5 10 17.5C5.85786 17.5 2.5 14.1421 2.5 10C2.5 5.85786 5.85786 2.5 10 2.5C14.1421 2.5 17.5 5.85786 17.5 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconArrowLeft = createIcon(
+  "IconArrowLeft",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M16.875 10H3.125M3.125 10L8.75 4.375M3.125 10L8.75 15.625",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconArrowRight = createIcon(
+  "IconArrowRight",
+  /* @__PURE__ */ jsx("path", { d: "M8.90918 3.4095C9.14349 3.17519 9.5235 3.17519 9.75781 3.4095L13.9238 7.57552C14.0363 7.68804 14.0996 7.84119 14.0996 8.00032C14.0995 8.15933 14.0363 8.3117 13.9238 8.42415L9.75781 12.5911C9.52355 12.8254 9.14351 12.8253 8.90918 12.5911C8.67487 12.3568 8.67487 11.9768 8.90918 11.7425L12.0518 8.59993H2.5C2.16874 8.59993 1.90057 8.33154 1.90039 8.00032C1.90039 7.66895 2.16863 7.39973 2.5 7.39973H12.0518L8.90918 4.25716C8.67508 4.02288 8.67508 3.64377 8.90918 3.4095Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconArrowUpRight = createIcon(
+  "IconArrowUpRight",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M5 15L15 5M15 5H6.875M15 5V13.125",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconRetry = createIcon(
+  "IconRetry",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M14.3751 8.12481H18.1251M18.1251 8.12481V4.37481M18.1251 8.12481L14.8618 5.13809C13.9063 4.18263 12.6904 3.52991 11.3661 3.26151C10.0418 2.9931 8.66771 3.12091 7.41561 3.62896C6.1635 4.137 5.08887 5.00276 4.32599 6.11806C3.5631 7.23336 3.1458 8.54875 3.12621 9.89986C3.10662 11.251 3.48562 12.5779 4.21585 13.7148C4.94609 14.8518 5.99517 15.7483 7.23202 16.2925C8.46887 16.8366 9.83865 17.0042 11.1702 16.7743C12.5018 16.5444 13.736 15.9272 14.7188 14.9998",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconRefresh = createIcon(
+  "IconRefresh",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M13.125 7.49978H16.875M16.875 7.49978V3.74978M16.875 7.49978L14.6656 5.29041C13.3861 4.01095 11.6538 3.2875 9.84437 3.27697C8.03494 3.26644 6.29431 3.96968 5 5.23416M6.875 12.4998H3.125M3.125 12.4998V16.2498M3.125 12.4998L5.33437 14.7092C6.61388 15.9886 8.34621 16.7121 10.1556 16.7226C11.9651 16.7331 13.7057 16.0299 15 14.7654",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconReply = createIcon(
+  "IconReply",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M17.5812 15.525C16.2953 14.1555 12.9195 11.25 8.12265 11.25V15L1.87265 8.75L8.12265 2.5V6.25C12.2476 6.25 17.5359 10.1914 18.1226 15.2766C18.1308 15.3424 18.1177 15.4091 18.0854 15.4671C18.0531 15.525 18.0031 15.5712 17.9428 15.5988C17.8825 15.6265 17.815 15.6343 17.75 15.621C17.685 15.6077 17.6259 15.5741 17.5812 15.525Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconArrowUp = createIcon(
+  "IconArrowUp",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M10 16.875V3.125M10 3.125L4.375 8.75M10 3.125L15.625 8.75",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconBell = createIcon(
+  "IconBell",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.50015 15C7.50015 15.663 7.76354 16.2989 8.23238 16.7678C8.70122 17.2366 9.33711 17.5 10.0001 17.5C10.6632 17.5 11.2991 17.2366 11.7679 16.7678C12.2368 16.2989 12.5001 15.663 12.5001 15M4.37515 8.125C4.37515 6.63316 4.96778 5.20242 6.02267 4.14752C7.07756 3.09263 8.5083 2.5 10.0001 2.5C11.492 2.5 12.9227 3.09263 13.9776 4.14752C15.0325 5.20242 15.6251 6.63316 15.6251 8.125C15.6251 10.9234 16.2736 13.1719 16.7892 14.0625C16.844 14.1574 16.8728 14.2649 16.8729 14.3745C16.873 14.484 16.8444 14.5916 16.7898 14.6865C16.7352 14.7815 16.6566 14.8604 16.5619 14.9154C16.4672 14.9705 16.3597 14.9996 16.2501 15H3.75015C3.64076 14.9993 3.53345 14.97 3.43896 14.9149C3.34448 14.8597 3.26611 14.7808 3.2117 14.6859C3.15729 14.591 3.12874 14.4835 3.12891 14.3741C3.12907 14.2647 3.15795 14.1572 3.21265 14.0625C3.72749 13.1719 4.37515 10.9227 4.37515 8.125Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconBellOff = createIcon(
+  "IconBellOff",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.75015 3.12492L10.0001 9.99992C10.0001 9.99992 13.8094 14.1901 16.2501 16.8749M7.50015 14.9999C7.50015 15.663 7.76354 16.2988 8.23238 16.7677C8.70122 17.2365 9.33711 17.4999 10.0001 17.4999C10.6632 17.4999 11.2991 17.2365 11.7679 16.7677C12.2368 16.2988 12.5001 15.663 12.5001 14.9999M7.22515 3.23117C8.0809 2.74583 9.04899 2.49341 10.0328 2.49912C11.0166 2.50482 11.9817 2.76845 12.8317 3.26369C13.6818 3.75893 14.3871 4.46846 14.8773 5.32147C15.3674 6.17447 15.6253 7.14111 15.6251 8.12492C15.6251 10.3984 16.0533 12.3093 16.49 13.4218M14.5455 14.9999H3.75015C3.64076 14.9993 3.53345 14.9699 3.43896 14.9148C3.34448 14.8597 3.26611 14.7807 3.2117 14.6858C3.15729 14.5909 3.12874 14.4834 3.12891 14.374C3.12907 14.2646 3.15795 14.1572 3.21265 14.0624C3.72749 13.1718 4.37515 10.9226 4.37515 8.12492C4.37327 6.97806 4.72371 5.85829 5.37905 4.91711",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconSave = createIcon(
+  "IconSave",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15 17.5L10 14.375L5 17.5V3.75C5 3.58424 5.06585 3.42527 5.18306 3.30806C5.30027 3.19085 5.45924 3.125 5.625 3.125H14.375C14.5408 3.125 14.6997 3.19085 14.8169 3.30806C14.9342 3.42527 15 3.58424 15 3.75V17.5Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconUnsave = createIcon(
+  "IconUnsave",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M5 6.49074V17.5L10 14.375L15 17.5V16M5.125 3.125H14.375C14.5408 3.125 14.6997 3.19085 14.8169 3.30806C14.9342 3.42527 15 3.58424 15 3.75V13M5.125 3.125L3.5 1.5M5.125 3.125L15 13M15 13L17.5 15.5",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMessageBubbles = createIcon(
+  "IconMessageBubbles",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M12.8076 6.25836C13.7525 6.30974 14.6692 6.59868 15.4728 7.09845C16.2764 7.59821 16.941 8.29265 17.4049 9.11746C17.8688 9.94227 18.1172 10.8708 18.1269 11.8171C18.1367 12.7634 17.9075 13.6968 17.4607 14.531L18.0982 16.6998C18.1298 16.8075 18.1319 16.9217 18.1041 17.0304C18.0764 17.1392 18.0198 17.2385 17.9405 17.3178C17.8611 17.3972 17.7618 17.4537 17.6531 17.4815C17.5443 17.5092 17.4301 17.5072 17.3224 17.4756L15.156 16.8357C14.4404 17.2184 13.6504 17.4419 12.8404 17.4907C12.0303 17.5396 11.2192 17.4127 10.4628 17.1188C9.70632 16.8249 9.02237 16.3708 8.45781 15.7878C7.89325 15.2049 7.46143 14.5067 7.19195 13.7412M2.53882 10.781C1.90215 9.59158 1.71418 8.21294 2.00918 6.89647C2.30419 5.58 3.06253 4.41341 4.14591 3.60942C5.22929 2.80543 6.56555 2.4176 7.91103 2.51665C9.2565 2.6157 10.5216 3.19503 11.4755 4.149C12.4295 5.10297 13.0088 6.36803 13.1079 7.7135C13.2069 9.05898 12.8191 10.3952 12.0151 11.4786C11.2111 12.562 10.0445 13.3203 8.72806 13.6153C7.41159 13.9104 6.03295 13.7224 4.84351 13.0857L2.67476 13.7232C2.56707 13.7548 2.45285 13.7569 2.3441 13.7291C2.23535 13.7014 2.13608 13.6448 2.05671 13.5655C1.97735 13.4861 1.92082 13.3868 1.89307 13.2781C1.86531 13.1693 1.86735 13.0551 1.89898 12.9474L2.53882 10.781Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMessageBubble = createIcon(
+  "IconMessageBubble",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M6.24431 16.4932C7.81972 17.405 9.67297 17.7127 11.4585 17.359C13.2441 17.0053 14.84 16.0143 15.9489 14.5708C17.0578 13.1273 17.6038 11.3298 17.4852 9.51341C17.3667 7.69704 16.5916 5.98577 15.3045 4.69866C14.0174 3.41156 12.3061 2.63646 10.4897 2.51789C8.67333 2.39932 6.87582 2.94537 5.43231 4.05422C3.9888 5.16308 2.99781 6.75906 2.64412 8.54461C2.29042 10.3302 2.59815 12.1834 3.50993 13.7588L2.53259 16.6768C2.49586 16.7869 2.49053 16.9051 2.5172 17.0181C2.54386 17.131 2.60146 17.2344 2.68355 17.3165C2.76563 17.3985 2.86895 17.4561 2.98194 17.4828C3.09492 17.5095 3.21309 17.5041 3.32321 17.4674L6.24431 16.4932Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMessageBubbleFill = createIcon(
+  "IconMessageBubbleFill",
+  /* @__PURE__ */ jsx("path", { d: "M18.125 10.0001C18.1253 11.4028 17.7624 12.7818 17.0717 14.0027C16.381 15.2236 15.3859 16.2449 14.1834 16.9671C12.9808 17.6894 11.6118 18.088 10.2095 18.1242C8.80719 18.1603 7.41942 17.8328 6.18125 17.1735L3.52109 18.0602C3.30085 18.1337 3.0645 18.1444 2.83854 18.091C2.61257 18.0377 2.40593 17.9225 2.24176 17.7583C2.07759 17.5942 1.96239 17.3875 1.90906 17.1615C1.85573 16.9356 1.86639 16.6992 1.93984 16.479L2.82656 13.8188C2.24699 12.7292 1.92328 11.5218 1.88 10.2883C1.83672 9.0549 2.075 7.8278 2.57677 6.70019C3.07854 5.57258 3.8306 4.57411 4.77587 3.78055C5.72114 2.98699 6.83478 2.41921 8.03224 2.1203C9.22971 1.82139 10.4795 1.79922 11.6868 2.05545C12.8942 2.31169 14.0272 2.8396 15.0001 3.59912C15.9729 4.35865 16.7599 5.32981 17.3014 6.43891C17.8428 7.548 18.1245 8.76588 18.125 10.0001Z" })
+);
+const IconBubble3ChatMessage = createIcon(
+  "IconBubble3ChatMessage",
+  /* @__PURE__ */ jsx("path", { d: "M13.5667 8.00031C13.5667 4.92603 11.0745 2.4331 8.00031 2.43292C4.92592 2.43292 2.43292 4.92592 2.43292 8.00031C2.43297 8.84133 2.61967 9.63756 2.95245 10.3509C3.07245 10.6082 3.11534 10.9117 3.0423 11.2122L2.50323 13.4319C2.49184 13.4799 2.53435 13.5227 2.58234 13.512L4.89679 12.9925C5.18423 12.9279 5.4722 12.9685 5.71906 13.0794C6.4143 13.3921 7.18646 13.5667 8.00031 13.5667C11.0744 13.5665 13.5665 11.0744 13.5667 8.00031ZM14.7669 8.00031C14.7667 11.7372 11.7372 14.7667 8.00031 14.7669C7.01349 14.7669 6.07389 14.5551 5.22687 14.1741C5.19459 14.1597 5.17067 14.1609 5.15948 14.1634L2.84601 14.6829C1.92949 14.889 1.11544 14.0605 1.33722 13.1478L1.87628 10.928C1.87907 10.9163 1.88025 10.8913 1.86456 10.8577C1.45928 9.9889 1.23375 9.02014 1.2337 8.00031C1.2337 4.26318 4.26318 1.2337 8.00031 1.2337C11.7373 1.23388 14.7669 4.26329 14.7669 8.00031Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconThread = createIcon(
+  "IconThread",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.49978 8.75022H12.4998M7.49978 11.2502H12.4998M6.24431 16.4932C7.81972 17.405 9.67297 17.7127 11.4585 17.359C13.2441 17.0053 14.84 16.0143 15.9489 14.5708C17.0578 13.1273 17.6038 11.3298 17.4852 9.51341C17.3667 7.69704 16.5916 5.98577 15.3045 4.69866C14.0174 3.41156 12.3061 2.63646 10.4897 2.51789C8.67333 2.39932 6.87582 2.94537 5.43231 4.05422C3.9888 5.16308 2.99781 6.75906 2.64412 8.54461C2.29042 10.3302 2.59815 12.1834 3.50993 13.7588L2.53259 16.6768C2.49586 16.7869 2.49053 16.9051 2.5172 17.0181C2.54386 17.131 2.60146 17.2344 2.68355 17.3165C2.76563 17.3985 2.86895 17.4561 2.98194 17.4828C3.09492 17.5095 3.21309 17.5041 3.32321 17.4674L6.24431 16.4932Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconBubbleText6SolidChatMessage = createIcon(
+  "IconBubbleText6SolidChatMessage",
+  /* @__PURE__ */ jsx("path", { d: "M1.33337 5.83333C1.33337 3.71624 3.04961 2 5.16671 2H10.8334C12.9504 2 14.6667 3.71624 14.6667 5.83333V10.1667C14.6667 12.2837 12.9504 14 10.8334 14H1.83337C1.55723 14 1.33337 13.7761 1.33337 13.5V5.83333ZM5.83337 6C5.55723 6 5.33337 6.22386 5.33337 6.5C5.33337 6.77613 5.55723 7 5.83337 7H10.1667C10.4428 7 10.6667 6.77613 10.6667 6.5C10.6667 6.22386 10.4428 6 10.1667 6H5.83337ZM5.83337 9C5.55723 9 5.33337 9.22387 5.33337 9.5C5.33337 9.77613 5.55723 10 5.83337 10H8.16671C8.44284 10 8.66671 9.77613 8.66671 9.5C8.66671 9.22387 8.44284 9 8.16671 9H5.83337Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconThreadFill = createIcon(
+  "IconThreadFill",
+  /* @__PURE__ */ jsx("path", { d: "M10.3125 1.875C8.24119 1.87727 6.25538 2.70111 4.79074 4.16574C3.32611 5.63038 2.50227 7.61619 2.5 9.6875V16.25C2.5 16.5815 2.6317 16.8995 2.86612 17.1339C3.10054 17.3683 3.41848 17.5 3.75 17.5H10.3125C12.3845 17.5 14.3716 16.6769 15.8368 15.2118C17.3019 13.7466 18.125 11.7595 18.125 9.6875C18.125 7.6155 17.3019 5.62836 15.8368 4.16323C14.3716 2.6981 12.3845 1.875 10.3125 1.875ZM12.8125 11.875H7.5C7.33424 11.875 7.17527 11.8092 7.05806 11.6919C6.94085 11.5747 6.875 11.4158 6.875 11.25C6.875 11.0842 6.94085 10.9253 7.05806 10.8081C7.17527 10.6908 7.33424 10.625 7.5 10.625H12.8125C12.9783 10.625 13.1372 10.6908 13.2544 10.8081C13.3717 10.9253 13.4375 11.0842 13.4375 11.25C13.4375 11.4158 13.3717 11.5747 13.2544 11.6919C13.1372 11.8092 12.9783 11.875 12.8125 11.875ZM12.8125 9.375H7.5C7.33424 9.375 7.17527 9.30915 7.05806 9.19194C6.94085 9.07473 6.875 8.91576 6.875 8.75C6.875 8.58424 6.94085 8.42527 7.05806 8.30806C7.17527 8.19085 7.33424 8.125 7.5 8.125H12.8125C12.9783 8.125 13.1372 8.19085 13.2544 8.30806C13.3717 8.42527 13.4375 8.58424 13.4375 8.75C13.4375 8.91576 13.3717 9.07473 13.2544 9.19194C13.1372 9.30915 12.9783 9.375 12.8125 9.375Z" })
+);
+const IconNotification = createIcon(
+  "IconNotification",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M16.25 10V16.25C16.25 16.4158 16.1842 16.5747 16.0669 16.6919C15.9497 16.8092 15.7908 16.875 15.625 16.875H3.75C3.58424 16.875 3.42527 16.8092 3.30806 16.6919C3.19085 16.5747 3.125 16.4158 3.125 16.25V4.375C3.125 4.20924 3.19085 4.05027 3.30806 3.93306C3.42527 3.81585 3.58424 3.75 3.75 3.75H10M17.5 4.6875C17.5 5.89562 16.5206 6.875 15.3125 6.875C14.1044 6.875 13.125 5.89562 13.125 4.6875C13.125 3.47938 14.1044 2.5 15.3125 2.5C16.5206 2.5 17.5 3.47938 17.5 4.6875Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconCamera = createIcon(
+  "IconCamera",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M16.25 16.25H3.75C3.41848 16.25 3.10054 16.1183 2.86612 15.8839C2.6317 15.6495 2.5 15.3315 2.5 15V6.25C2.5 5.91848 2.6317 5.60054 2.86612 5.36612C3.10054 5.1317 3.41848 5 3.75 5H6.25L7.5 3.125H12.5L13.75 5H16.25C16.5815 5 16.8995 5.1317 17.1339 5.36612C17.3683 5.60054 17.5 5.91848 17.5 6.25V15C17.5 15.3315 17.3683 15.6495 17.1339 15.8839C16.8995 16.1183 16.5815 16.25 16.25 16.25Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M10 13.125C11.5533 13.125 12.8125 11.8658 12.8125 10.3125C12.8125 8.7592 11.5533 7.5 10 7.5C8.4467 7.5 7.1875 8.7592 7.1875 10.3125C7.1875 11.8658 8.4467 13.125 10 13.125Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    )
+  ] })
+);
+const IconLink = createIcon(
+  "IconLink",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.49989 12.4999L12.4999 7.49989M8.74989 5.94598L11.0983 3.60223C11.8035 2.90843 12.7543 2.52139 13.7436 2.52542C14.7328 2.52945 15.6804 2.92422 16.3799 3.62374C17.0795 4.32326 17.4742 5.27086 17.4783 6.26012C17.4823 7.24938 17.0953 8.20016 16.4015 8.90536L14.053 11.2499M5.94598 8.74989L3.60223 11.0983C2.90843 11.8035 2.52139 12.7543 2.52542 13.7436C2.52945 14.7328 2.92422 15.6804 3.62374 16.3799C4.32326 17.0795 5.27086 17.4742 6.26012 17.4783C7.24938 17.4823 8.20016 17.0953 8.90536 16.4015L11.2499 14.053",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconPoll = createIcon(
+  "IconPoll",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.75 16.25V10.625H7.5M17.5 16.25H2.5M7.5 16.25V6.875H11.875M11.875 16.25V3.125H16.25V16.25",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconCheckmark1Small = createIcon(
+  "IconCheckmark1Small",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 11.25L7.5 15.625L17.5 5.625",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconCheckmark = createIcon(
+  "IconCheckmark",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 11.25L7.5 15.625L17.5 5.625",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconChevronDown = createIcon(
+  "IconChevronDown",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M16.25 7.5L10 13.75L3.75 7.5",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconChevronLeft = createIcon(
+  "IconChevronLeft",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M12.5 16.25L6.25 10L12.5 3.75",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconChevronRight = createIcon(
+  "IconChevronRight",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.5 3.75L13.75 10L7.5 16.25",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconNoSign = createIcon(
+  "IconNoSign",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15.3031 15.3031L4.69688 4.69688M17.5 10C17.5 14.1421 14.1421 17.5 10 17.5C5.85786 17.5 2.5 14.1421 2.5 10C2.5 5.85786 5.85786 2.5 10 2.5C14.1421 2.5 17.5 5.85786 17.5 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeMiterlimit: "10",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconInfo = createIcon(
+  "IconInfo",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M16.75 10C16.75 6.27208 13.7279 3.25 10 3.25C6.27208 3.25 3.25 6.27208 3.25 10C3.25 13.7279 6.27208 16.75 10 16.75C13.7279 16.75 16.75 13.7279 16.75 10ZM18.25 10C18.25 14.5563 14.5563 18.25 10 18.25C5.44365 18.25 1.75 14.5563 1.75 10C1.75 5.44365 5.44365 1.75 10 1.75C14.5563 1.75 18.25 5.44365 18.25 10Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M10.75 13.0107C11.1047 13.0703 11.375 13.3784 11.375 13.75C11.375 14.1642 11.0392 14.5 10.625 14.5C10.2603 14.5 9.91021 14.3555 9.65234 14.0977C9.39448 13.8398 9.25 13.4897 9.25 13.125V10.1133C8.89539 10.0537 8.625 9.74655 8.625 9.375C8.625 8.96079 8.96079 8.625 9.375 8.625C9.69403 8.625 10.0014 8.73611 10.2461 8.93652L10.3477 9.02734L10.4385 9.12891C10.6389 9.37356 10.75 9.68097 10.75 10V13.0107Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M9.6875 7.5C10.2053 7.5 10.625 7.08027 10.625 6.5625C10.625 6.04473 10.2053 5.625 9.6875 5.625C9.16973 5.625 8.75 6.04473 8.75 6.5625C8.75 7.08027 9.16973 7.5 9.6875 7.5Z" })
+  ] })
+);
+const IconMinusCircle = createIcon(
+  "IconMinusCircle",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M6.875 10H13.125M17.5 10C17.5 14.1421 14.1421 17.5 10 17.5C5.85786 17.5 2.5 14.1421 2.5 10C2.5 5.85786 5.85786 2.5 10 2.5C14.1421 2.5 17.5 5.85786 17.5 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeMiterlimit: "10",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconXCircle = createIcon(
+  "IconXCircle",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M12.5 7.5L7.5 12.5M7.5 7.5L12.5 12.5M17.5 10C17.5 14.1421 14.1421 17.5 10 17.5C5.85786 17.5 2.5 14.1421 2.5 10C2.5 5.85786 5.85786 2.5 10 2.5C14.1421 2.5 17.5 5.85786 17.5 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconClock = createIcon(
+  "IconClock",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M10 5.625V10H14.375M17.5 10C17.5 14.1421 14.1421 17.5 10 17.5C5.85786 17.5 2.5 14.1421 2.5 10C2.5 5.85786 5.85786 2.5 10 2.5C14.1421 2.5 17.5 5.85786 17.5 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconQuote = createIcon(
+  "IconQuote",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M8.4375 11.25H3.125C2.95924 11.25 2.80027 11.1842 2.68306 11.0669C2.56585 10.9497 2.5 10.7908 2.5 10.625V5.625C2.5 5.45924 2.56585 5.30027 2.68306 5.18306C2.80027 5.06585 2.95924 5 3.125 5H7.8125C7.97826 5 8.13723 5.06585 8.25444 5.18306C8.37165 5.30027 8.4375 5.45924 8.4375 5.625V12.5C8.4375 13.3288 8.10826 14.1237 7.52221 14.7097C6.93616 15.2958 6.1413 15.625 5.3125 15.625M17.5 11.25H12.1875C12.0217 11.25 11.8628 11.1842 11.7456 11.0669C11.6283 10.9497 11.5625 10.7908 11.5625 10.625V5.625C11.5625 5.45924 11.6283 5.30027 11.7456 5.18306C11.8628 5.06585 12.0217 5 12.1875 5H16.875C17.0408 5 17.1997 5.06585 17.3169 5.18306C17.4342 5.30027 17.5 5.45924 17.5 5.625V12.5C17.5 13.3288 17.1708 14.1237 16.5847 14.7097C15.9987 15.2958 15.2038 15.625 14.375 15.625",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconXmark = createIcon(
+  "IconXmark",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15.625 4.375L4.375 15.625M15.625 15.625L4.375 4.375",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconCrossSmall = createIcon(
+  "IconCrossSmall",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15.625 4.375L4.375 15.625M15.625 15.625L4.375 4.375",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMore = createIcon(
+  "IconMore",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M10 11.25C10.6904 11.25 11.25 10.6904 11.25 10C11.25 9.30964 10.6904 8.75 10 8.75C9.30964 8.75 8.75 9.30964 8.75 10C8.75 10.6904 9.30964 11.25 10 11.25Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M4.6875 11.25C5.37786 11.25 5.9375 10.6904 5.9375 10C5.9375 9.30964 5.37786 8.75 4.6875 8.75C3.99714 8.75 3.4375 9.30964 3.4375 10C3.4375 10.6904 3.99714 11.25 4.6875 11.25Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M15.3125 11.25C16.0029 11.25 16.5625 10.6904 16.5625 10C16.5625 9.30964 16.0029 8.75 15.3125 8.75C14.6221 8.75 14.0625 9.30964 14.0625 10C14.0625 10.6904 14.6221 11.25 15.3125 11.25Z" })
+  ] })
+);
+const IconReorder = createIcon(
+  "IconReorder",
+  /* @__PURE__ */ jsx("path", { d: "M8.875 15.3125C8.875 16.2445 8.11948 17 7.1875 17C6.25552 17 5.5 16.2445 5.5 15.3125C5.5 14.3805 6.25552 13.625 7.1875 13.625C8.11948 13.625 8.875 14.3805 8.875 15.3125ZM14.5 15.3125C14.5 16.2445 13.7445 17 12.8125 17C11.8805 17 11.125 16.2445 11.125 15.3125C11.125 14.3805 11.8805 13.625 12.8125 13.625C13.7445 13.625 14.5 14.3805 14.5 15.3125ZM8.875 10C8.875 10.932 8.11948 11.6875 7.1875 11.6875C6.25552 11.6875 5.5 10.932 5.5 10C5.5 9.06802 6.25552 8.3125 7.1875 8.3125C8.11948 8.3125 8.875 9.06802 8.875 10ZM14.5 10C14.5 10.932 13.7445 11.6875 12.8125 11.6875C11.8805 11.6875 11.125 10.932 11.125 10C11.125 9.06802 11.8805 8.3125 12.8125 8.3125C13.7445 8.3125 14.5 9.06802 14.5 10ZM8.875 4.6875C8.875 5.61948 8.11948 6.375 7.1875 6.375C6.25552 6.375 5.5 5.61948 5.5 4.6875C5.5 3.75552 6.25552 3 7.1875 3C8.11948 3 8.875 3.75552 8.875 4.6875ZM14.5 4.6875C14.5 5.61948 13.7445 6.375 12.8125 6.375C11.8805 6.375 11.125 5.61948 11.125 4.6875C11.125 3.75552 11.8805 3 12.8125 3C13.7445 3 14.5 3.75552 14.5 4.6875Z" })
+);
+const IconChecks = createIcon(
+  "IconChecks",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M1.5 10.5724L4.98387 13.9936L13.1129 6.00977M10.371 13.9936L18.5 6.00977",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconEdit = createIcon(
+  "IconEdit",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M10.625 5.0001L15 9.3751M7.24141 16.8751H3.75C3.58424 16.8751 3.42527 16.8093 3.30806 16.692C3.19085 16.5748 3.125 16.4159 3.125 16.2501V12.7587C3.12508 12.5932 3.19082 12.4344 3.30781 12.3173L12.9422 2.68291C13.0594 2.56579 13.2183 2.5 13.384 2.5C13.5497 2.5 13.7086 2.56579 13.8258 2.68291L17.3172 6.17198C17.4343 6.28917 17.5001 6.44808 17.5001 6.61377C17.5001 6.77946 17.4343 6.93837 17.3172 7.05557L7.68281 16.6923C7.56569 16.8093 7.40695 16.875 7.24141 16.8751Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconEmoji = createIcon(
+  "IconEmoji",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M16.75 10C16.75 6.27208 13.7279 3.25 10 3.25C6.27208 3.25 3.25 6.27208 3.25 10C3.25 13.7279 6.27208 16.75 10 16.75C13.7279 16.75 16.75 13.7279 16.75 10ZM18.25 10C18.25 14.5563 14.5563 18.25 10 18.25C5.44365 18.25 1.75 14.5563 1.75 10C1.75 5.44365 5.44365 1.75 10 1.75C14.5563 1.75 18.25 5.44365 18.25 10Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M7.1875 9.375C7.70527 9.375 8.125 8.95527 8.125 8.4375C8.125 7.91973 7.70527 7.5 7.1875 7.5C6.66973 7.5 6.25 7.91973 6.25 8.4375C6.25 8.95527 6.66973 9.375 7.1875 9.375Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M12.8125 9.375C13.3303 9.375 13.75 8.95527 13.75 8.4375C13.75 7.91973 13.3303 7.5 12.8125 7.5C12.2947 7.5 11.875 7.91973 11.875 8.4375C11.875 8.95527 12.2947 9.375 12.8125 9.375Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M12.4756 11.499C12.683 11.1407 13.1425 11.0182 13.501 11.2256C13.8593 11.433 13.9818 11.8925 13.7744 12.251C13.0125 13.568 11.6947 14.5 10 14.5C8.30531 14.5 6.98748 13.568 6.22559 12.251C6.01825 11.8925 6.14067 11.433 6.49902 11.2256C6.85749 11.0182 7.31695 11.1407 7.52441 11.499C8.05942 12.424 8.91824 13 10 13C11.0818 13 11.9406 12.424 12.4756 11.499Z" })
+  ] })
+);
+const IconExclamationMarkFill = createIcon(
+  "IconExclamationMarkFill",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M10 16.875C10.6904 16.875 11.25 16.3154 11.25 15.625C11.25 14.9346 10.6904 14.375 10 14.375C9.30964 14.375 8.75 14.9346 8.75 15.625C8.75 16.3154 9.30964 16.875 10 16.875Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M9 11.875V3.75C9 3.19772 9.44772 2.75 10 2.75C10.5523 2.75 11 3.19772 11 3.75V11.875C11 12.4273 10.5523 12.875 10 12.875C9.44772 12.875 9 12.4273 9 11.875Z" })
+  ] })
+);
+const IconExclamationCircleFill = createIcon(
+  "IconExclamationCircleFill",
+  /* @__PURE__ */ jsx("path", { d: "M10 1.875C8.39303 1.875 6.82214 2.35152 5.486 3.24431C4.14985 4.1371 3.10844 5.40605 2.49348 6.8907C1.87852 8.37535 1.71762 10.009 2.03112 11.5851C2.34463 13.1612 3.11846 14.6089 4.25476 15.7452C5.39106 16.8815 6.8388 17.6554 8.41489 17.9689C9.99099 18.2824 11.6247 18.1215 13.1093 17.5065C14.594 16.8916 15.8629 15.8502 16.7557 14.514C17.6485 13.1779 18.125 11.607 18.125 10C18.1227 7.84581 17.266 5.78051 15.7427 4.25727C14.2195 2.73403 12.1542 1.87727 10 1.875ZM9.375 6.25C9.375 6.08424 9.44085 5.92527 9.55806 5.80806C9.67527 5.69085 9.83424 5.625 10 5.625C10.1658 5.625 10.3247 5.69085 10.4419 5.80806C10.5592 5.92527 10.625 6.08424 10.625 6.25V10.625C10.625 10.7908 10.5592 10.9497 10.4419 11.0669C10.3247 11.1842 10.1658 11.25 10 11.25C9.83424 11.25 9.67527 11.1842 9.55806 11.0669C9.44085 10.9497 9.375 10.7908 9.375 10.625V6.25ZM10 14.375C9.81458 14.375 9.63333 14.32 9.47916 14.217C9.32499 14.114 9.20482 13.9676 9.13387 13.7963C9.06291 13.625 9.04434 13.4365 9.08052 13.2546C9.11669 13.0727 9.20598 12.9057 9.33709 12.7746C9.4682 12.6435 9.63525 12.5542 9.81711 12.518C9.99896 12.4818 10.1875 12.5004 10.3588 12.5714C10.5301 12.6423 10.6765 12.7625 10.7795 12.9167C10.8825 13.0708 10.9375 13.2521 10.9375 13.4375C10.9375 13.6861 10.8387 13.9246 10.6629 14.1004C10.4871 14.2762 10.2486 14.375 10 14.375Z" })
+);
+const IconExclamationMark = createIcon(
+  "IconExclamationMark",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M16.75 10C16.75 6.27208 13.7279 3.25 10 3.25C6.27208 3.25 3.25 6.27208 3.25 10C3.25 13.7279 6.27208 16.75 10 16.75C13.7279 16.75 16.75 13.7279 16.75 10ZM18.25 10C18.25 14.5563 14.5563 18.25 10 18.25C5.44365 18.25 1.75 14.5563 1.75 10C1.75 5.44365 5.44365 1.75 10 1.75C14.5563 1.75 18.25 5.44365 18.25 10Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M9.25 10.625V6.25C9.25 5.83579 9.58579 5.5 10 5.5C10.4142 5.5 10.75 5.83579 10.75 6.25V10.625C10.75 11.0392 10.4142 11.375 10 11.375C9.58579 11.375 9.25 11.0392 9.25 10.625Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M10 14.375C10.5178 14.375 10.9375 13.9553 10.9375 13.4375C10.9375 12.9197 10.5178 12.5 10 12.5C9.48223 12.5 9.0625 12.9197 9.0625 13.4375C9.0625 13.9553 9.48223 14.375 10 14.375Z" })
+  ] })
+);
+const IconExclamationTriangle = createIcon(
+  "IconExclamationTriangle",
+  /* @__PURE__ */ jsx("path", { d: "M6.33838 2.1211C7.08775 0.860752 8.91225 0.860759 9.66162 2.1211L14.6509 10.5117C15.4171 11.8003 14.4889 13.4333 12.9897 13.4336H3.01026C1.51115 13.4333 0.582944 11.8003 1.34912 10.5117L6.33838 2.1211ZM8.63037 2.73438C8.34614 2.25634 7.65386 2.25634 7.36963 2.73438L2.38037 11.125C2.08977 11.6138 2.44181 12.2331 3.01026 12.2334H12.9897C13.5582 12.2331 13.9102 11.6138 13.6196 11.125L8.63037 2.73438ZM7.3999 8.50001V5.83302C7.40008 5.5018 7.66923 5.23341 8.00049 5.23341C8.33153 5.23367 8.59993 5.50196 8.6001 5.83302V8.50001C8.6001 8.83122 8.33164 9.09936 8.00049 9.09962C7.66912 9.09962 7.39991 8.83138 7.3999 8.50001ZM8.76709 10.333C8.76709 10.7563 8.4237 11.0994 8.00049 11.0996C7.57705 11.0996 7.23291 10.7565 7.23291 10.333C7.23309 9.90973 7.57716 9.56642 8.00049 9.56642L8.07862 9.57032C8.46503 9.60966 8.76693 9.93626 8.76709 10.333Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconEyeOpen = createIcon(
+  "IconEyeOpen",
+  /* @__PURE__ */ jsx("path", { d: "M8.00001 2.56708C10.6293 2.5671 13.1778 4.13929 14.874 7.11591C15.1862 7.66419 15.1864 8.33627 14.874 8.88446C13.1778 11.861 10.6292 13.4333 8.00001 13.4333C5.37079 13.4333 2.82216 11.861 1.12598 8.88446C0.813474 8.33611 0.813474 7.66328 1.12598 7.11493C2.82216 4.13867 5.37091 2.56707 8.00001 2.56708ZM8.00001 3.7663C5.88909 3.76629 3.69769 5.02518 2.16798 7.70966C2.06545 7.88967 2.0654 8.11071 2.16798 8.29071C3.69768 10.9751 5.88913 12.2331 8.00001 12.2331C10.1109 12.2331 12.3023 10.9751 13.832 8.29071C13.9346 8.11071 13.9346 7.8898 13.832 7.70966C12.3023 5.02517 10.1109 3.76631 8.00001 3.7663ZM9.56641 7.99969C9.56624 7.13461 8.86513 6.43329 8.00001 6.43329C7.13489 6.43329 6.43378 7.13461 6.4336 7.99969C6.4336 8.86492 7.13478 9.56708 8.00001 9.56708C8.86524 9.56708 9.56641 8.86492 9.56641 7.99969ZM10.7666 7.99969C10.7666 9.52767 9.52798 10.7663 8.00001 10.7663C6.47204 10.7663 5.23341 9.52767 5.23341 7.99969C5.23358 6.47187 6.47214 5.23309 8.00001 5.23309C9.52787 5.23309 10.7664 6.47187 10.7666 7.99969Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconUpload = createIcon(
+  "IconUpload",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M11.875 2.5H4.375C4.20924 2.5 4.05027 2.56585 3.93306 2.68306C3.81585 2.80027 3.75 2.95924 3.75 3.125V16.875C3.75 17.0408 3.81585 17.1997 3.93306 17.3169C4.05027 17.4342 4.20924 17.5 4.375 17.5H15.625C15.7908 17.5 15.9497 17.4342 16.0669 17.3169C16.1842 17.1997 16.25 17.0408 16.25 16.875V6.875M11.875 2.5L16.25 6.875M11.875 2.5V6.875H16.25M8.125 11.25L10 9.375M10 9.375L11.875 11.25M10 9.375V14.375",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconFile = createIcon(
+  "IconFile",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M11.875 2.5H4.375C4.20924 2.5 4.05027 2.56585 3.93306 2.68306C3.81585 2.80027 3.75 2.95924 3.75 3.125V16.875C3.75 17.0408 3.81585 17.1997 3.93306 17.3169C4.05027 17.4342 4.20924 17.5 4.375 17.5H15.625C15.7908 17.5 15.9497 17.4342 16.0669 17.3169C16.1842 17.1997 16.25 17.0408 16.25 16.875V6.875M11.875 2.5L16.25 6.875M11.875 2.5V6.875H16.25",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconFlag = createIcon(
+  "IconFlag",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.75 17.5001V4.3751C8.75 0.0446299 12.5 8.70557 17.5 4.3751V13.7501C12.5 18.0806 8.75 9.41963 3.75 13.7501",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconImage = createIcon(
+  "IconImage",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M4.42891 16.875L12.9953 8.30781C13.0534 8.2497 13.1223 8.2036 13.1982 8.17215C13.274 8.1407 13.3554 8.12451 13.4375 8.12451C13.5196 8.12451 13.601 8.1407 13.6768 8.17215C13.7527 8.2036 13.8216 8.2497 13.8797 8.30781L16.875 11.3039M3.75 3.125H16.25C16.5952 3.125 16.875 3.40482 16.875 3.75V16.25C16.875 16.5952 16.5952 16.875 16.25 16.875H3.75C3.40482 16.875 3.125 16.5952 3.125 16.25V3.75C3.125 3.40482 3.40482 3.125 3.75 3.125ZM8.75 7.5C8.75 8.19036 8.19036 8.75 7.5 8.75C6.80964 8.75 6.25 8.19036 6.25 7.5C6.25 6.80964 6.80964 6.25 7.5 6.25C8.19036 6.25 8.75 6.80964 8.75 7.5Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconLayoutAlignLeft = createIcon(
+  "IconLayoutAlignLeft",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M6.875 3.75V16.25M3.125 3.75H16.875C17.2202 3.75 17.5 4.02982 17.5 4.375V15.625C17.5 15.9702 17.2202 16.25 16.875 16.25H3.125C2.77982 16.25 2.5 15.9702 2.5 15.625V4.375C2.5 4.02982 2.77982 3.75 3.125 3.75Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconLightBulbSimple = createIcon(
+  "IconLightBulbSimple",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M12.2328 6.66736C12.2328 4.32904 10.3378 2.43302 7.99945 2.43298C5.66113 2.43298 3.76508 4.32901 3.76508 6.66736C3.76509 8.03465 4.4128 9.25078 5.42035 10.0258C5.44202 10.0425 5.46556 10.0594 5.48871 10.0765C6.00058 10.4543 6.43207 11.0657 6.43207 11.8119V12.6664C6.43232 13.5319 7.13392 14.2338 7.99945 14.2338C8.86496 14.2337 9.56658 13.5318 9.56683 12.6664V11.8119C9.56683 11.0657 9.99831 10.4543 10.5102 10.0765C10.5335 10.0593 10.556 10.0424 10.5776 10.0258L10.7631 9.87537C11.6644 9.09822 12.2328 7.94919 12.2328 6.66736ZM13.433 6.66736C13.433 8.42299 12.6002 9.98457 11.31 10.9769C11.2807 10.9995 11.2513 11.0205 11.2231 11.0414C10.9238 11.2623 10.767 11.55 10.767 11.8119V12.6664C10.7668 14.1946 9.5277 15.4329 7.99945 15.433C6.47116 15.433 5.23213 14.1946 5.23187 12.6664V11.8119C5.23187 11.5827 5.11171 11.3346 4.88129 11.1283L4.77582 11.0424L4.6889 10.9769C3.39867 9.98457 2.56587 8.42301 2.56586 6.66736C2.56586 3.66628 4.99838 1.23376 7.99945 1.23376C11.0005 1.2338 13.433 3.6663 13.433 6.66736Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M10.1669 11.2338C10.4982 11.2338 10.7665 11.502 10.7665 11.8334C10.7665 12.1647 10.4982 12.433 10.1669 12.433H5.83193C5.50056 12.433 5.23232 12.1647 5.23232 11.8334C5.23232 11.502 5.50056 11.2338 5.83193 11.2338H10.1669Z" })
+  ] }),
+  { viewBox: "0 0 16 16" }
+);
+const IconSearch = createIcon(
+  "IconSearch",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M13.1695 13.1695L17.5 17.5M15 8.75C15 12.2018 12.2018 15 8.75 15C5.29822 15 2.5 12.2018 2.5 8.75C2.5 5.29822 5.29822 2.5 8.75 2.5C12.2018 2.5 15 5.29822 15 8.75Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconLocation = createIcon(
+  "IconLocation",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M10 10.625C11.3807 10.625 12.5 9.50571 12.5 8.125C12.5 6.74429 11.3807 5.625 10 5.625C8.61929 5.625 7.5 6.74429 7.5 8.125C7.5 9.50571 8.61929 10.625 10 10.625Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M16.25 8.125C16.25 13.75 10 18.125 10 18.125C10 18.125 3.75 13.75 3.75 8.125C3.75 6.4674 4.40848 4.87769 5.58058 3.70558C6.75269 2.53348 8.3424 1.875 10 1.875C11.6576 1.875 13.2473 2.53348 14.4194 3.70558C15.5915 4.87769 16.25 6.4674 16.25 8.125Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    )
+  ] })
+);
+const IconVoice = createIcon(
+  "IconVoice",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M10 15.625V18.75M10 15.625C11.4918 15.625 12.9226 15.0324 13.9775 13.9775C15.0324 12.9226 15.625 11.4918 15.625 10M10 15.625C8.50816 15.625 7.07742 15.0324 6.02252 13.9775C4.96763 12.9226 4.375 11.4918 4.375 10M10 1.875C11.7259 1.875 13.125 3.27411 13.125 5V10C13.125 11.7259 11.7259 13.125 10 13.125C8.27411 13.125 6.875 11.7259 6.875 10V5C6.875 3.27411 8.27411 1.875 10 1.875Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconVoiceFill = createIcon(
+  "IconVoiceFill",
+  /* @__PURE__ */ jsx("path", { d: "M6.25 10V5C6.25 4.00544 6.64509 3.05161 7.34835 2.34835C8.05161 1.64509 9.00544 1.25 10 1.25C10.9946 1.25 11.9484 1.64509 12.6517 2.34835C13.3549 3.05161 13.75 4.00544 13.75 5V10C13.75 10.9946 13.3549 11.9484 12.6517 12.6517C11.9484 13.3549 10.9946 13.75 10 13.75C9.00544 13.75 8.05161 13.3549 7.34835 12.6517C6.64509 11.9484 6.25 10.9946 6.25 10ZM16.25 10C16.25 9.83424 16.1842 9.67527 16.0669 9.55806C15.9497 9.44085 15.7908 9.375 15.625 9.375C15.4592 9.375 15.3003 9.44085 15.1831 9.55806C15.0658 9.67527 15 9.83424 15 10C15 11.3261 14.4732 12.5979 13.5355 13.5355C12.5979 14.4732 11.3261 15 10 15C8.67392 15 7.40215 14.4732 6.46447 13.5355C5.52678 12.5979 5 11.3261 5 10C5 9.83424 4.93415 9.67527 4.81694 9.55806C4.69973 9.44085 4.54076 9.375 4.375 9.375C4.20924 9.375 4.05027 9.44085 3.93306 9.55806C3.81585 9.67527 3.75 9.83424 3.75 10C3.7519 11.5489 4.32806 13.042 5.36707 14.1907C6.40607 15.3393 7.8341 16.062 9.375 16.2188V18.75C9.375 18.9158 9.44085 19.0747 9.55806 19.1919C9.67527 19.3092 9.83424 19.375 10 19.375C10.1658 19.375 10.3247 19.3092 10.4419 19.1919C10.5592 19.0747 10.625 18.9158 10.625 18.75V16.2188C12.1659 16.062 13.5939 15.3393 14.6329 14.1907C15.6719 13.042 16.2481 11.5489 16.25 10Z" })
+);
+const IconMinus = createIcon(
+  "IconMinus",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 10H16.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMinusSmall = createIcon(
+  "IconMinusSmall",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 10H16.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconMute = createIcon(
+  "IconMute",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15.625 8.125V11.875M18.125 6.875V13.125M4.375 3.125L16.875 16.875M9.38672 4.92109L12.5 2.5V8.34609M12.5 12.0625V17.5L6.875 13.125H3.125C2.95924 13.125 2.80027 13.0592 2.68306 12.9419C2.56585 12.8247 2.5 12.6658 2.5 12.5V7.5C2.5 7.33424 2.56585 7.17527 2.68306 7.05806C2.80027 6.94085 2.95924 6.875 3.125 6.875H7.78437",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconSend = createIcon(
+  "IconSend",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M11.2498 10H6.24982M6.24982 10L3.7881 2.71328C3.74537 2.59349 3.7402 2.4635 3.7733 2.34069C3.80639 2.21788 3.87616 2.10808 3.9733 2.02597C4.07044 1.94386 4.19032 1.89335 4.31693 1.88117C4.44353 1.86899 4.57084 1.89573 4.68185 1.95781L17.8069 9.4461C17.9045 9.50015 17.986 9.57937 18.0427 9.67555C18.0994 9.77172 18.1293 9.88133 18.1293 9.99297C18.1293 10.1046 18.0994 10.2142 18.0427 10.3104C17.986 10.4066 17.9045 10.4858 17.8069 10.5398L4.68185 18.0469C4.57051 18.1096 4.4426 18.1367 4.31537 18.1245C4.18815 18.1123 4.06772 18.0614 3.97032 17.9787C3.87292 17.8959 3.80323 17.7853 3.77065 17.6617C3.73807 17.5381 3.74416 17.4075 3.7881 17.2875L6.24982 10Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconAttachment = createIcon(
+  "IconAttachment",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M12.4999 6.24998L5.9913 12.8664C5.76258 13.102 5.63576 13.4181 5.63823 13.7465C5.6407 14.0748 5.77227 14.389 6.00451 14.6211C6.23674 14.8533 6.55099 14.9847 6.87934 14.987C7.20769 14.9894 7.52376 14.8624 7.75927 14.6336L15.5179 6.76795C15.9868 6.29905 16.2502 5.6631 16.2502 4.99998C16.2502 4.33686 15.9868 3.70091 15.5179 3.23201C15.049 2.76312 14.413 2.49969 13.7499 2.49969C13.0868 2.49969 12.4508 2.76312 11.9819 3.23201L4.22333 11.0984C3.52953 11.8036 3.14249 12.7544 3.14652 13.7437C3.15054 14.7329 3.54531 15.6805 4.24483 16.38C4.94435 17.0796 5.89195 17.4743 6.88121 17.4784C7.87048 17.4824 8.82126 17.0953 9.52645 16.4015L15.9374 9.99998",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconPauseFill = createIcon(
+  "IconPauseFill",
+  /* @__PURE__ */ jsx("path", { d: "M16.875 3.75V16.25C16.875 16.5815 16.7433 16.8995 16.5089 17.1339C16.2745 17.3683 15.9565 17.5 15.625 17.5H12.5C12.1685 17.5 11.8505 17.3683 11.6161 17.1339C11.3817 16.8995 11.25 16.5815 11.25 16.25V3.75C11.25 3.41848 11.3817 3.10054 11.6161 2.86612C11.8505 2.6317 12.1685 2.5 12.5 2.5H15.625C15.9565 2.5 16.2745 2.6317 16.5089 2.86612C16.7433 3.10054 16.875 3.41848 16.875 3.75ZM7.5 2.5H4.375C4.04348 2.5 3.72554 2.6317 3.49112 2.86612C3.2567 3.10054 3.125 3.41848 3.125 3.75V16.25C3.125 16.5815 3.2567 16.8995 3.49112 17.1339C3.72554 17.3683 4.04348 17.5 4.375 17.5H7.5C7.83152 17.5 8.14946 17.3683 8.38388 17.1339C8.6183 16.8995 8.75 16.5815 8.75 16.25V3.75C8.75 3.41848 8.6183 3.10054 8.38388 2.86612C8.14946 2.6317 7.83152 2.5 7.5 2.5Z" })
+);
+const IconUser = createIcon(
+  "IconUser",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M10 12.5C12.7614 12.5 15 10.2614 15 7.5C15 4.73858 12.7614 2.5 10 2.5C7.23858 2.5 5 4.73858 5 7.5C5 10.2614 7.23858 12.5 10 12.5ZM10 12.5C6.76172 12.5 4.01328 14.2602 2.5 16.875M10 12.5C13.2383 12.5 15.9867 14.2602 17.5 16.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconUserAdd = createIcon(
+  "IconUserAdd",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("g", { clipPath: "url(#clip0_14246_498359)", children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M15.625 10.625H19.375M17.5 8.75V12.5M8.4375 12.5C11.0263 12.5 13.125 10.4013 13.125 7.8125C13.125 5.22367 11.0263 3.125 8.4375 3.125C5.84867 3.125 3.75 5.22367 3.75 7.8125C3.75 10.4013 5.84867 12.5 8.4375 12.5ZM8.4375 12.5C5.74688 12.5 3.48047 13.7148 1.875 15.625M8.4375 12.5C11.1281 12.5 13.3945 13.7148 15 15.625",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ) }),
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "clip0_14246_498359", children: /* @__PURE__ */ jsx("rect", { fill: "white", height: "20", width: "20" }) }) })
+  ] })
+);
+const IconUserCheck = createIcon(
+  "IconUserCheck",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("g", { clipPath: "url(#clip0_14236_425131)", children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M8.4375 12.5C11.0263 12.5 13.125 10.4013 13.125 7.8125C13.125 5.22367 11.0263 3.125 8.4375 3.125C5.84867 3.125 3.75 5.22367 3.75 7.8125C3.75 10.4013 5.84867 12.5 8.4375 12.5ZM8.4375 12.5C5.74688 12.5 3.48047 13.7148 1.875 15.625M8.4375 12.5C11.1281 12.5 13.3945 13.7148 15 15.625M15.625 11.25L16.875 12.5L19.375 10",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ) }),
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "clip0_14236_425131", children: /* @__PURE__ */ jsx("rect", { fill: "white", height: "20", width: "20" }) }) })
+  ] })
+);
+const IconUserRemove = createIcon(
+  "IconUserRemove",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("g", { clipPath: "url(#clip0_14246_434209)", children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M15.625 10.625H19.375M8.4375 12.5C11.0263 12.5 13.125 10.4013 13.125 7.8125C13.125 5.22367 11.0263 3.125 8.4375 3.125C5.84867 3.125 3.75 5.22367 3.75 7.8125C3.75 10.4013 5.84867 12.5 8.4375 12.5ZM8.4375 12.5C5.74688 12.5 3.48047 13.7148 1.875 15.625M8.4375 12.5C11.1281 12.5 13.3945 13.7148 15 15.625",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ) }),
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "clip0_14246_434209", children: /* @__PURE__ */ jsx("rect", { fill: "white", height: "20", width: "20" }) }) })
+  ] })
+);
+const IconPin = createIcon(
+  "IconPin",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.52271 12.4773L3.75006 16.25M17.9422 7.68279C18.0594 7.56559 18.1252 7.40668 18.1252 7.24099C18.1252 7.0753 18.0594 6.9164 17.9422 6.7992L13.2032 2.05779C13.086 1.94067 12.9271 1.87488 12.7614 1.87488C12.5957 1.87488 12.4368 1.94067 12.3196 2.05779L7.84303 6.54685C7.84303 6.54685 5.67506 5.46326 3.35943 7.33201C3.29077 7.38697 3.23447 7.45581 3.19424 7.53402C3.154 7.61224 3.13072 7.69806 3.12593 7.78589C3.12114 7.87371 3.13493 7.96156 3.16642 8.04369C3.19791 8.12581 3.24637 8.20037 3.30865 8.26248L11.7383 16.6914C11.8015 16.7541 11.8773 16.8025 11.9606 16.8336C12.044 16.8646 12.133 16.8775 12.2218 16.8713C12.3105 16.8652 12.3969 16.8402 12.4752 16.798C12.5535 16.7558 12.6219 16.6973 12.6758 16.6265C13.3313 15.7547 14.361 13.9633 13.4657 12.1734L17.9422 7.68279Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconPlayFill = createIcon(
+  "IconPlayFill",
+  /* @__PURE__ */ jsx("path", { d: "M18.75 10C18.7505 10.2122 18.6961 10.4209 18.5921 10.6059C18.488 10.7908 18.3379 10.9457 18.1562 11.0555L6.9 17.9414C6.71022 18.0576 6.49287 18.1211 6.27037 18.1252C6.04788 18.1293 5.82832 18.0739 5.63438 17.9648C5.44227 17.8574 5.28225 17.7008 5.17075 17.511C5.05926 17.3213 5.00032 17.1052 5 16.8852V3.11484C5.00032 2.89475 5.05926 2.67872 5.17075 2.48896C5.28225 2.2992 5.44227 2.14257 5.63438 2.03516C5.82832 1.92605 6.04788 1.87071 6.27037 1.87483C6.49287 1.87895 6.71022 1.94239 6.9 2.05859L18.1562 8.94453C18.3379 9.05428 18.488 9.20916 18.5921 9.39411C18.6961 9.57906 18.7505 9.78779 18.75 10Z" })
+);
+const IconPlus = createIcon(
+  "IconPlus",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 10H16.875M10 3.125V16.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconPlusSmall = createIcon(
+  "IconPlusSmall",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M3.125 10H16.875M10 3.125V16.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconCommand = createIcon(
+  "IconCommand",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M6.25 7.5L9.375 10L6.25 12.5M10.625 12.5H13.75M3.125 3.75H16.875C17.2202 3.75 17.5 4.02982 17.5 4.375V15.625C17.5 15.9702 17.2202 16.25 16.875 16.25H3.125C2.77982 16.25 2.5 15.9702 2.5 15.625V4.375C2.5 4.02982 2.77982 3.75 3.125 3.75Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconSettingsGear2 = createIcon(
+  "IconSettingsGear2",
+  /* @__PURE__ */ jsx("path", { d: "M13.5667 8.00031C13.5667 7.81566 13.4743 7.64281 13.3206 7.54034L12.7503 7.16046C12.0815 6.71442 11.7583 5.90079 11.9388 5.11749L12.0472 4.64777C12.092 4.45315 12.034 4.24906 11.8929 4.10773C11.7515 3.96629 11.5467 3.90753 11.3519 3.95245L10.8831 4.06085C10.0996 4.24168 9.28525 3.91849 8.8392 3.24933L8.45932 2.67902C8.35689 2.52558 8.18474 2.43303 8.00034 2.43292C7.81575 2.43292 7.64286 2.5254 7.54037 2.67902L7.16049 3.24933C6.7145 3.91832 5.90097 4.24146 5.11752 4.06085L4.6478 3.95245C4.45304 3.90767 4.24908 3.9664 4.10776 4.10773C3.96643 4.24905 3.9077 4.45301 3.95248 4.64777L4.06088 5.11749C4.24149 5.90094 3.91835 6.71447 3.24936 7.16046L2.67905 7.54034C2.52543 7.64282 2.43295 7.81572 2.43295 8.00031C2.43306 8.18471 2.52561 8.35686 2.67905 8.45929L3.24936 8.83917C3.91852 9.28522 4.24171 10.0995 4.06088 10.8831L3.95248 11.3519C3.90756 11.5467 3.96632 11.7514 4.10776 11.8929C4.24909 12.034 4.45317 12.092 4.6478 12.0472L5.11752 11.9388C5.90082 11.7583 6.71445 12.0814 7.16049 12.7503L7.54037 13.3206C7.64284 13.4743 7.81569 13.5667 8.00034 13.5667C8.18484 13.5666 8.35691 13.4742 8.45932 13.3206L8.8392 12.7503C9.2574 12.123 9.99909 11.8004 10.7357 11.9114L10.8831 11.9388L11.3519 12.0472C11.5467 12.0922 11.7505 12.0334 11.8919 11.8919C12.0334 11.7504 12.0922 11.5467 12.0472 11.3519L11.9388 10.8831C11.7581 10.0996 12.0812 9.28525 12.7503 8.83917L13.3206 8.45929C13.4742 8.35688 13.5666 8.18481 13.5667 8.00031ZM9.23373 8.00031C9.23373 7.31925 8.68135 6.76708 8.00034 6.76691C7.31917 6.76691 6.76694 7.31914 6.76694 8.00031C6.76711 8.68132 7.31928 9.2337 8.00034 9.2337C8.68124 9.23353 9.23356 8.68121 9.23373 8.00031ZM10.433 8.00031C10.4328 9.34395 9.34398 10.4327 8.00034 10.4329C6.65654 10.4329 5.56692 9.34406 5.56674 8.00031C5.56674 6.6564 6.65643 5.56671 8.00034 5.56671C9.34409 5.56689 10.433 6.65651 10.433 8.00031ZM14.7669 8.00031C14.7668 8.58607 14.474 9.13337 13.9867 9.45831L13.4164 9.8382C13.1627 10.0072 13.0404 10.3155 13.1087 10.6126L13.2171 11.0823C13.355 11.6803 13.1744 12.3067 12.7406 12.7405C12.3067 13.1744 11.6803 13.355 11.0824 13.2171L10.6126 13.1087C10.3155 13.0403 10.0073 13.1627 9.83823 13.4163L9.45834 13.9866C9.1334 14.4739 8.5861 14.7668 8.00034 14.7669C7.41454 14.7669 6.86735 14.4739 6.54233 13.9866L6.16245 13.4163C5.99328 13.1626 5.6843 13.0402 5.38705 13.1087L4.9183 13.2171C4.32022 13.3552 3.69313 13.1746 3.25912 12.7405C2.82535 12.3066 2.64568 11.6802 2.78354 11.0823L2.89194 10.6126C2.96027 10.3155 2.83695 10.0072 2.58334 9.8382L2.01401 9.45831C1.52667 9.13338 1.23384 8.58608 1.23373 8.00031C1.23373 7.4144 1.52657 6.86729 2.01401 6.5423L2.58334 6.16241C2.83709 5.99325 2.96042 5.68417 2.89194 5.38702L2.78354 4.91827C2.64553 4.32022 2.82513 3.69309 3.25912 3.25909C3.69312 2.8251 4.32025 2.6455 4.9183 2.78351L5.38705 2.89191C5.6842 2.96039 5.99328 2.83706 6.16245 2.58331L6.54233 2.01398C6.86732 1.52654 7.41443 1.2337 8.00034 1.2337C8.58611 1.23381 9.13341 1.52663 9.45834 2.01398L9.83823 2.58331C10.0073 2.83692 10.3156 2.96024 10.6126 2.89191L11.0824 2.78351C11.6803 2.64565 12.3067 2.82532 12.7406 3.25909C13.1746 3.6931 13.3552 4.3202 13.2171 4.91827L13.1087 5.38702C13.0402 5.68427 13.1626 5.99325 13.4164 6.16241L13.9867 6.5423C14.4739 6.86732 14.7669 7.41451 14.7669 8.00031Z" }),
+  { viewBox: "0 0 16 16" }
+);
+const IconCopy = createIcon(
+  "IconCopy",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M13.125 13.125H16.875V3.125H6.875V6.875M3.125 6.875H13.125V16.875H3.125V6.875Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconThunder = createIcon(
+  "IconThunder",
+  /* @__PURE__ */ jsx("path", { d: "M16.7071 9.80157L7.95711 19.1766C7.86438 19.2755 7.74198 19.3416 7.60839 19.3649C7.47479 19.3882 7.33724 19.3674 7.2165 19.3057C7.09576 19.244 6.99837 19.1446 6.93904 19.0227C6.8797 18.9007 6.86164 18.7628 6.88757 18.6297L8.03289 12.9008L3.53054 11.2102C3.43385 11.174 3.34762 11.1144 3.27956 11.0368C3.2115 10.9592 3.16373 10.8659 3.14052 10.7653C3.1173 10.6647 3.11937 10.5599 3.14653 10.4603C3.17369 10.3607 3.2251 10.2694 3.29617 10.1945L12.0462 0.819538C12.1389 0.720581 12.2613 0.654468 12.3949 0.631176C12.5285 0.607884 12.666 0.628675 12.7868 0.690414C12.9075 0.752152 13.0049 0.851488 13.0642 0.97343C13.1236 1.09537 13.1416 1.2333 13.1157 1.36641L11.9673 7.10157L16.4696 8.78985C16.5656 8.82626 16.6511 8.88576 16.7187 8.96307C16.7862 9.04039 16.8336 9.13315 16.8568 9.23316C16.88 9.33317 16.8781 9.43734 16.8515 9.53648C16.8248 9.63562 16.7742 9.72666 16.704 9.80157H16.7071Z" })
+);
+const IconTranslate = createIcon(
+  "IconTranslate",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M18.75 16.875L14.375 8.125L10 16.875M11.25 14.375H17.5M7.5 2.5V4.375M2.5 4.375H12.5M10 4.375C10 6.36412 9.20982 8.27178 7.8033 9.6783C6.39678 11.0848 4.48912 11.875 2.5 11.875M5.42734 6.875C5.94442 8.33751 6.90226 9.60371 8.16893 10.4992C9.4356 11.3947 10.9488 11.8753 12.5 11.875",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconDelete = createIcon(
+  "IconDelete",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M16.875 4.375H3.125M8.125 8.125V13.125M11.875 8.125V13.125M15.625 4.375V16.25C15.625 16.4158 15.5592 16.5747 15.4419 16.6919C15.3247 16.8092 15.1658 16.875 15 16.875H5C4.83424 16.875 4.67527 16.8092 4.55806 16.6919C4.44085 16.5747 4.375 16.4158 4.375 16.25V4.375M13.125 4.375V3.125C13.125 2.79348 12.9933 2.47554 12.7589 2.24112C12.5245 2.0067 12.2065 1.875 11.875 1.875H8.125C7.79348 1.875 7.47554 2.0067 7.24112 2.24112C7.0067 2.47554 6.875 2.79348 6.875 3.125V4.375",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconTrophy = createIcon(
+  "IconTrophy",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.5 17.5H12.5M10 14.375V17.5M4.53125 10H3.75C3.08696 10 2.45107 9.73661 1.98223 9.26777C1.51339 8.79893 1.25 8.16304 1.25 7.5V6.25C1.25 6.08424 1.31585 5.92527 1.43306 5.80806C1.55027 5.69085 1.70924 5.625 1.875 5.625H4.375M15.4688 10H16.25C16.913 10 17.5489 9.73661 18.0178 9.26777C18.4866 8.79893 18.75 8.16304 18.75 7.5V6.25C18.75 6.08424 18.6842 5.92527 18.5669 5.80806C18.4497 5.69085 18.2908 5.625 18.125 5.625H15.625M4.375 3.75H15.625V8.67969C15.625 11.7812 13.1445 14.3516 10.043 14.375C9.30068 14.3807 8.5646 14.2394 7.87718 13.9592C7.18975 13.6791 6.56458 13.2656 6.03769 12.7427C5.5108 12.2198 5.09262 11.5978 4.80725 10.9126C4.52188 10.2273 4.37498 9.49231 4.375 8.75V3.75Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconUnpin = createIcon(
+  "IconUnpin",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M7.52271 12.4773L3.75006 16.25M3.75006 3.12498L16.2501 16.875M14.4532 11.1828L17.9415 7.68279C18.0586 7.56559 18.1244 7.40668 18.1244 7.24099C18.1244 7.0753 18.0586 6.9164 17.9415 6.7992L13.2032 2.05779C13.086 1.94067 12.9271 1.87488 12.7614 1.87488C12.5957 1.87488 12.4368 1.94067 12.3196 2.05779L9.09615 5.28904M6.58756 6.24998C5.74537 6.18435 4.57271 6.3531 3.35943 7.33201C3.29077 7.38697 3.23447 7.45581 3.19424 7.53402C3.154 7.61224 3.13072 7.69806 3.12593 7.78589C3.12114 7.87371 3.13493 7.96156 3.16642 8.04369C3.19791 8.12581 3.24637 8.20037 3.30865 8.26248L11.7383 16.6914C11.8015 16.7541 11.8773 16.8025 11.9606 16.8336C12.044 16.8646 12.133 16.8775 12.2218 16.8713C12.3105 16.8652 12.3969 16.8402 12.4752 16.798C12.5535 16.7558 12.6219 16.6973 12.6758 16.6265C13.0829 16.0851 13.6344 15.1898 13.779 14.1594",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconVideo = createIcon(
+  "IconVideo",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("g", { clipPath: "url(#clip0_14111_491476)", children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M15.625 8.75L19.375 6.25V13.75L15.625 11.25M2.5 5H15C15.3452 5 15.625 5.27982 15.625 5.625V14.375C15.625 14.7202 15.3452 15 15 15H2.5C2.15482 15 1.875 14.7202 1.875 14.375V5.625C1.875 5.27982 2.15482 5 2.5 5Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        strokeWidth: "1.5"
+      }
+    ) }),
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "clip0_14111_491476", children: /* @__PURE__ */ jsx("rect", { fill: "white", height: "20", width: "20" }) }) })
+  ] })
+);
+const IconVideoFill = createIcon(
+  "IconVideoFill",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("g", { clipPath: "url(#clip0_14064_467281)", children: /* @__PURE__ */ jsx("path", { d: "M15 5.625V14.375C15 14.7065 14.8683 15.0245 14.6339 15.2589C14.3995 15.4933 14.0815 15.625 13.75 15.625H2.5C2.16848 15.625 1.85054 15.4933 1.61612 15.2589C1.3817 15.0245 1.25 14.7065 1.25 14.375V5.625C1.25 5.29348 1.3817 4.97554 1.61612 4.74112C1.85054 4.5067 2.16848 4.375 2.5 4.375H13.75C14.0815 4.375 14.3995 4.5067 14.6339 4.74112C14.8683 4.97554 15 5.29348 15 5.625ZM19.5312 5.64453C19.4431 5.62295 19.3513 5.62029 19.2621 5.63672C19.1728 5.65315 19.088 5.68829 19.0133 5.73984L16.3891 7.48906C16.3463 7.51762 16.3112 7.55631 16.2869 7.6017C16.2626 7.64708 16.25 7.69776 16.25 7.74922V12.2508C16.25 12.3022 16.2626 12.3529 16.2869 12.3983C16.3112 12.4437 16.3463 12.4824 16.3891 12.5109L19.0281 14.2703C19.1269 14.3362 19.2424 14.3726 19.3611 14.3752C19.4798 14.3779 19.5968 14.3466 19.6984 14.2852C19.7924 14.2254 19.8695 14.1425 19.9223 14.0444C19.9751 13.9464 20.0019 13.8364 20 13.725V6.25C20.0001 6.11139 19.9541 5.97668 19.8692 5.86708C19.7843 5.75747 19.6655 5.67918 19.5312 5.64453Z" }) }),
+    /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "clip0_14064_467281", children: /* @__PURE__ */ jsx("rect", { fill: "white", height: "20", width: "20" }) }) })
+  ] })
+);
+const IconAudio = createIcon(
+  "IconAudio",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M15.625 8.125V11.875M18.125 6.875V13.125M6.875 13.125H3.125C2.95924 13.125 2.80027 13.0592 2.68306 12.9419C2.56585 12.8247 2.5 12.6658 2.5 12.5V7.5C2.5 7.33424 2.56585 7.17527 2.68306 7.05806C2.80027 6.94085 2.95924 6.875 3.125 6.875H6.875L12.5 2.5V17.5L6.875 13.125Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconArchive = createIcon(
+  "IconArchive",
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M16.875 7.5V15C16.875 15.1658 16.8092 15.3247 16.6919 15.4419C16.5747 15.5592 16.4158 15.625 16.25 15.625H3.75C3.58424 15.625 3.42527 15.5592 3.30806 15.4419C3.19085 15.3247 3.125 15.1658 3.125 15V7.5M8.125 10.625H11.875M2.5 4.375H17.5C17.8452 4.375 18.125 4.65482 18.125 5V6.875C18.125 7.22018 17.8452 7.5 17.5 7.5H2.5C2.15482 7.5 1.875 7.22018 1.875 6.875V5C1.875 4.65482 2.15482 4.375 2.5 4.375Z",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: "1.5"
+    }
+  )
+);
+const IconLoading = createIcon(
+  "IconLoading",
+  /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M17.5 10C17.5 14.1422 14.1422 17.5 10 17.5C5.85787 17.5 2.5 14.1422 2.5 10C2.5 5.85787 5.85787 2.5 10 2.5C14.1422 2.5 17.5 5.85787 17.5 10Z",
+        fill: "none",
+        stroke: "currentColor",
+        strokeOpacity: "0.3",
+        strokeWidth: "2"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M17.4544 10.8334C17.0701 14.3097 14.3098 17.07 10.8335 17.4543",
+        fill: "none",
+        stroke: "currentColor",
+        strokeLinecap: "round",
+        strokeWidth: "2"
+      }
+    )
+  ] })
+);
+const UnMemoizedEmptyStateIndicator = (props) => {
+  const { listType, messageText } = props;
+  const { t } = useTranslationContext("EmptyStateIndicator");
+  if (listType === "thread") return null;
+  if (listType === "channel") {
+    const text = t("No conversations yet");
+    return /* @__PURE__ */ jsxs("div", { className: "str-chat__channel-list-empty", children: [
+      /* @__PURE__ */ jsx(IconMessageBubbles, {}),
+      /* @__PURE__ */ jsx("p", { role: "listitem", children: text })
+    ] });
+  }
+  if (listType === "message") {
+    const text = t(messageText || "Send a message to start the conversation");
+    return /* @__PURE__ */ jsxs("div", { className: "str-chat__empty-channel", children: [
+      /* @__PURE__ */ jsx(IconMessageBubble, {}),
+      /* @__PURE__ */ jsx("p", { className: "str-chat__empty-channel-text", role: "listitem", children: text })
+    ] });
+  }
+  return /* @__PURE__ */ jsx("p", { children: t("No items exist") });
+};
+const EmptyStateIndicator = React.memo(
+  UnMemoizedEmptyStateIndicator
+);
+const makeChannelReducer = () => (state, action) => {
+  switch (action.type) {
+    case "closeThread": {
+      return {
+        ...state,
+        thread: null,
+        threadLoadingMore: false,
+        threadMessages: []
+      };
+    }
+    case "copyMessagesFromChannel": {
+      const { channel, parentId } = action;
+      return {
+        ...state,
+        messages: [...channel.state.messages],
+        pinnedMessages: [...channel.state.pinnedMessages],
+        // copying messages from channel happens with new message - this resets the suppressAutoscroll
+        suppressAutoscroll: false,
+        threadMessages: parentId ? { ...channel.state.threads }[parentId] || [] : state.threadMessages
+      };
+    }
+    case "copyStateFromChannelOnEvent": {
+      const { channel } = action;
+      return {
+        ...state,
+        members: { ...channel.state.members },
+        messages: [...channel.state.messages],
+        pinnedMessages: [...channel.state.pinnedMessages],
+        read: { ...channel.state.read },
+        watcherCount: channel.state.watcher_count,
+        watchers: { ...channel.state.watchers }
+      };
+    }
+    case "initStateFromChannel": {
+      const { channel, hasMore } = action;
+      return {
+        ...state,
+        hasMore,
+        loading: false,
+        members: { ...channel.state.members },
+        messages: [...channel.state.messages],
+        pinnedMessages: [...channel.state.pinnedMessages],
+        read: { ...channel.state.read },
+        watcherCount: channel.state.watcher_count,
+        watchers: { ...channel.state.watchers }
+      };
+    }
+    case "jumpToLatestMessageFinished": {
+      const { hasMore, hasMoreNewer, messages } = action;
+      return {
+        ...state,
+        hasMore,
+        hasMoreNewer,
+        highlightedMessageId: void 0,
+        loading: false,
+        messages,
+        suppressAutoscroll: false
+      };
+    }
+    case "jumpToMessageFinished": {
+      return {
+        ...state,
+        hasMore: action.channel.state.messagePagination.hasPrev,
+        hasMoreNewer: action.channel.state.messagePagination.hasNext,
+        highlightedMessageId: action.highlightedMessageId,
+        loadingMore: false,
+        loadingMoreForJumpToChannelMessage: false,
+        messages: action.channel.state.messages,
+        suppressAutoscroll: false
+      };
+    }
+    case "clearHighlightedMessage": {
+      return {
+        ...state,
+        highlightedMessageId: void 0
+      };
+    }
+    case "loadMoreFinished": {
+      const { hasMore, messages } = action;
+      return {
+        ...state,
+        hasMore,
+        loadingMore: false,
+        messages,
+        suppressAutoscroll: false
+      };
+    }
+    case "loadMoreNewerFinished": {
+      const { hasMoreNewer, messages } = action;
+      return {
+        ...state,
+        hasMoreNewer,
+        loadingMoreNewer: false,
+        messages
+      };
+    }
+    case "loadMoreThreadFinished": {
+      const { threadHasMore, threadMessages } = action;
+      return {
+        ...state,
+        threadHasMore,
+        threadLoadingMore: false,
+        threadMessages
+      };
+    }
+    case "openThread": {
+      const { channel, message } = action;
+      return {
+        ...state,
+        thread: message,
+        threadHasMore: true,
+        threadMessages: message.id ? { ...channel.state.threads }[message.id] || [] : [],
+        threadSuppressAutoscroll: false
+      };
+    }
+    case "setError": {
+      const { error } = action;
+      return { ...state, error };
+    }
+    case "setLoadingMore": {
+      const { loadingMore } = action;
+      return { ...state, loadingMore, suppressAutoscroll: loadingMore };
+    }
+    case "setLoadingMoreForJumpToChannelMessage": {
+      const { loadingMoreForJumpToChannelMessage } = action;
+      return {
+        ...state,
+        loadingMoreForJumpToChannelMessage,
+        suppressAutoscroll: loadingMoreForJumpToChannelMessage
+      };
+    }
+    case "setLoadingMoreNewer": {
+      const { loadingMoreNewer } = action;
+      return { ...state, loadingMoreNewer };
+    }
+    case "setThread": {
+      const { message } = action;
+      return { ...state, thread: message };
+    }
+    case "setTyping": {
+      const { channel } = action;
+      return {
+        ...state,
+        typing: { ...channel.state.typing }
+      };
+    }
+    case "startLoadingThread": {
+      return {
+        ...state,
+        threadLoadingMore: true,
+        threadSuppressAutoscroll: true
+      };
+    }
+    case "updateThreadOnEvent": {
+      const { channel, message } = action;
+      if (!state.thread) return state;
+      return {
+        ...state,
+        thread: message?.id === state.thread.id ? channel.state.formatMessage(message) : state.thread,
+        threadMessages: state.thread?.id ? { ...channel.state.threads }[state.thread.id] || [] : []
+      };
+    }
+    default:
+      return state;
+  }
+};
+const initialState = {
+  error: null,
+  hasMore: true,
+  hasMoreNewer: false,
+  loading: true,
+  loadingMore: false,
+  loadingMoreForJumpToChannelMessage: false,
+  members: {},
+  messages: [],
+  pinnedMessages: [],
+  read: {},
+  suppressAutoscroll: false,
+  thread: null,
+  threadHasMore: true,
+  threadLoadingMore: false,
+  threadMessages: [],
+  threadSuppressAutoscroll: false,
+  typing: {},
+  watcherCount: 0,
+  watchers: {}
+};
+const useCreateChannelStateContext = (value) => {
+  const {
+    channel,
+    channelCapabilitiesArray = [],
+    channelConfig,
+    channelUnreadUiState,
+    error,
+    giphyVersion,
+    hasMore,
+    hasMoreNewer,
+    highlightedMessageId,
+    imageAttachmentSizeHandler,
+    loading,
+    loadingMore,
+    loadingMoreForJumpToChannelMessage,
+    members,
+    messages = [],
+    mutes,
+    notifications,
+    pinnedMessages,
+    read = {},
+    shouldGenerateVideoThumbnail,
+    skipMessageDataMemoization,
+    suppressAutoscroll,
+    thread,
+    threadHasMore,
+    threadLoadingMore,
+    threadMessages = [],
+    videoAttachmentSizeHandler,
+    watcher_count,
+    watcherCount,
+    watchers
+  } = value;
+  const channelId = channel.cid;
+  const lastRead = channel.initialized && channel.lastRead()?.getTime();
+  const membersLength = Object.keys(members || []).length;
+  const notificationsLength = notifications.length;
+  const readUsers = Object.values(read);
+  const readUsersLength = readUsers.length;
+  const readUsersLastReadDateStrings = [];
+  for (const { last_read } of readUsers) {
+    if (!lastRead) continue;
+    readUsersLastReadDateStrings.push(last_read?.toISOString());
+  }
+  const readUsersLastReads = readUsersLastReadDateStrings.join();
+  const threadMessagesLength = threadMessages?.length;
+  const channelCapabilities = {};
+  channelCapabilitiesArray.forEach((capability) => {
+    channelCapabilities[capability] = true;
+  });
+  const memoizedMessageData = skipMessageDataMemoization ? messages : messages.map(
+    ({
+      deleted_at,
+      latest_reactions,
+      pinned,
+      reply_count,
+      status,
+      type,
+      updated_at,
+      user
+    }) => `${type}${deleted_at}${latest_reactions ? latest_reactions.map(({ type: type2 }) => type2).join() : ""}${pinned}${reply_count}${status}${updated_at && (isDayOrMoment(updated_at) || isDate(updated_at)) ? updated_at.toISOString() : updated_at || ""}${user?.updated_at}`
+  ).join();
+  const memoizedThreadMessageData = threadMessages.map(
+    ({ deleted_at, latest_reactions, pinned, status, updated_at, user }) => `${deleted_at}${latest_reactions ? latest_reactions.map(({ type }) => type).join() : ""}${pinned}${status}${updated_at && (isDayOrMoment(updated_at) || isDate(updated_at)) ? updated_at.toISOString() : updated_at || ""}${user?.updated_at}`
+  ).join();
+  const channelStateContext = useMemo(
+    () => ({
+      channel,
+      channelCapabilities,
+      channelConfig,
+      channelUnreadUiState,
+      error,
+      giphyVersion,
+      hasMore,
+      hasMoreNewer,
+      highlightedMessageId,
+      imageAttachmentSizeHandler,
+      loading,
+      loadingMore,
+      loadingMoreForJumpToChannelMessage,
+      members,
+      messages,
+      mutes,
+      notifications,
+      pinnedMessages,
+      read,
+      shouldGenerateVideoThumbnail,
+      suppressAutoscroll,
+      thread,
+      threadHasMore,
+      threadLoadingMore,
+      threadMessages,
+      videoAttachmentSizeHandler,
+      watcher_count,
+      watcherCount,
+      watchers
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      channel.data?.name,
+      // otherwise ChannelHeader will not be updated
+      channelId,
+      channelUnreadUiState,
+      error,
+      hasMore,
+      hasMoreNewer,
+      highlightedMessageId,
+      lastRead,
+      loading,
+      loadingMore,
+      loadingMoreForJumpToChannelMessage,
+      membersLength,
+      memoizedMessageData,
+      memoizedThreadMessageData,
+      notificationsLength,
+      readUsersLength,
+      readUsersLastReads,
+      shouldGenerateVideoThumbnail,
+      skipMessageDataMemoization,
+      suppressAutoscroll,
+      thread,
+      threadHasMore,
+      threadLoadingMore,
+      threadMessagesLength,
+      watcherCount
+    ]
+  );
+  return channelStateContext;
+};
+const useCreateTypingContext = (value) => {
+  const { typing } = value;
+  const typingValue = Object.keys(typing || {}).join();
+  const typingContext = useMemo(
+    () => ({
+      typing
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [typingValue]
+  );
+  return typingContext;
+};
+const useEditMessageHandler = (doUpdateMessageRequest) => {
+  const { channel, client } = useChatContext("useEditMessageHandler");
+  return (updatedMessage, options) => {
+    if (doUpdateMessageRequest && channel) {
+      return Promise.resolve(
+        doUpdateMessageRequest(channel.cid, updatedMessage, options)
+      );
+    }
+    return client.updateMessage(updatedMessage, void 0, options);
+  };
+};
+const useIsMounted = () => {
+  const isMounted = useRef(false);
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return isMounted;
+};
+const useMentionsHandlers = (onMentionsHover, onMentionsClick) => useCallback(
+  (event, mentioned_users) => {
+    if (!onMentionsHover && !onMentionsClick || !(event.target instanceof HTMLElement)) {
+      return;
+    }
+    const target = event.target;
+    const textContent = target.innerHTML.replace("*", "");
+    if (textContent[0] === "@") {
+      const userName = textContent.replace("@", "");
+      const user = mentioned_users?.find(
+        ({ id, name }) => name === userName || id === userName
+      );
+      if (onMentionsHover && typeof onMentionsHover === "function" && event.type === "mouseover") {
+        onMentionsHover(event, user);
+      }
+      if (onMentionsClick && event.type === "click" && typeof onMentionsClick === "function") {
+        onMentionsClick(event, user);
+      }
+    }
+  },
+  [onMentionsClick, onMentionsHover]
+);
+const LoadingMessage = ({
+  bubbleSize,
+  metadataSize,
+  outgoing = false
+}) => /* @__PURE__ */ jsxs(
+  "div",
+  {
+    className: `str-chat__loading-channel-message ${outgoing ? "str-chat__loading-channel-message--outgoing" : "str-chat__loading-channel-message--incoming"}`,
+    children: [
+      !outgoing ? /* @__PURE__ */ jsx("div", { className: "str-chat__loading-channel-message-avatar" }) : null,
+      /* @__PURE__ */ jsxs("div", { className: "str-chat__loading-channel-message-content", children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `str-chat__loading-channel-message-bubble str-chat__loading-channel-message-bubble--${bubbleSize}`
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `str-chat__loading-channel-message-metadata str-chat__loading-channel-message-metadata--${metadataSize}`
+          }
+        )
+      ] })
+    ]
+  }
+);
+const LoadingMessageInput = () => /* @__PURE__ */ jsx("div", { className: "str-chat__message-composer-container str-chat__message-composer-container--loading", children: /* @__PURE__ */ jsxs("div", { className: "str-chat__message-composer", children: [
+  /* @__PURE__ */ jsx("div", { className: "str-chat__loading-channel-message-input-button" }),
+  /* @__PURE__ */ jsx("div", { className: "str-chat__loading-channel-message-input-pill" })
+] }) });
+const LoadingChannelHeader = () => /* @__PURE__ */ jsxs("div", { className: "str-chat__channel-header str-chat__channel-header--loading", children: [
+  /* @__PURE__ */ jsx("div", { className: "str-chat__channel-header__data str-chat__channel-header__data--loading", children: /* @__PURE__ */ jsx("div", { className: "str-chat__loading-channel-header-name" }) }),
+  /* @__PURE__ */ jsx("div", { className: "str-chat__loading-channel-header-avatar" })
+] });
+const LoadingChannel = () => /* @__PURE__ */ jsxs("div", { className: "str-chat__loading-channel", children: [
+  /* @__PURE__ */ jsx(LoadingChannelHeader, {}),
+  /* @__PURE__ */ jsx("div", { className: "str-chat__message-list str-chat__message-list--loading", children: /* @__PURE__ */ jsx("div", { className: "str-chat__message-list-scroll", children: /* @__PURE__ */ jsxs("div", { className: "str-chat__loading-channel-message-list", children: [
+    /* @__PURE__ */ jsx(LoadingMessage, { bubbleSize: "lg", metadataSize: "md" }),
+    /* @__PURE__ */ jsx(LoadingMessage, { bubbleSize: "md", metadataSize: "sm", outgoing: true }),
+    /* @__PURE__ */ jsx(LoadingMessage, { bubbleSize: "lg", metadataSize: "md" })
+  ] }) }) }),
+  /* @__PURE__ */ jsx(LoadingMessageInput, {})
+] });
+const UnMemoizedLoadingErrorIndicator = ({ error }) => {
+  const { t } = useTranslationContext("LoadingErrorIndicator");
+  if (!error) return null;
+  return /* @__PURE__ */ jsx("div", { children: t("Error: {{ errorMessage }}", { errorMessage: error.message }) });
+};
+const LoadingErrorIndicator = React.memo(
+  UnMemoizedLoadingErrorIndicator,
+  (prevProps, nextProps) => prevProps.error?.message === nextProps.error?.message
+);
+const CHANNEL_CONTAINER_ID = "str-chat__channel";
+const DEFAULT_NEXT_CHANNEL_PAGE_SIZE = 25;
+const DEFAULT_JUMP_TO_PAGE_SIZE = 25;
+const DEFAULT_THREAD_PAGE_SIZE = 25;
+const DEFAULT_LOAD_PAGE_SCROLL_THRESHOLD = 250;
+const DEFAULT_HIGHLIGHT_DURATION = 500;
+const validateAndGetMessage = (func, args) => {
+  if (!func || typeof func !== "function") return null;
+  if (!Array.isArray(args)) {
+    args = [args];
+  }
+  const returnValue = func(...args);
+  if (typeof returnValue !== "string") return null;
+  return returnValue;
+};
+const isUserMuted = (message, mutes) => {
+  if (!mutes || !message) return false;
+  const userMuted = mutes.filter((el) => el.target.id === message.user?.id);
+  return !!userMuted.length;
+};
+const OPTIONAL_MESSAGE_ACTIONS = {
+  deleteForMe: "deleteForMe"
+};
+const MESSAGE_ACTIONS = {
+  delete: "delete",
+  edit: "edit",
+  flag: "flag",
+  markUnread: "markUnread",
+  mute: "mute",
+  pin: "pin",
+  quote: "quote",
+  react: "react",
+  remindMe: "remindMe",
+  reply: "reply",
+  saveForLater: "saveForLater"
+};
+const defaultPinPermissions = {
+  commerce: {
+    admin: true,
+    anonymous: false,
+    channel_member: false,
+    channel_moderator: true,
+    guest: false,
+    member: false,
+    moderator: true,
+    owner: true,
+    user: false
+  },
+  gaming: {
+    admin: true,
+    anonymous: false,
+    channel_member: false,
+    channel_moderator: true,
+    guest: false,
+    member: false,
+    moderator: true,
+    owner: false,
+    user: false
+  },
+  livestream: {
+    admin: true,
+    anonymous: false,
+    channel_member: false,
+    channel_moderator: true,
+    guest: false,
+    member: false,
+    moderator: true,
+    owner: true,
+    user: false
+  },
+  messaging: {
+    admin: true,
+    anonymous: false,
+    channel_member: true,
+    channel_moderator: true,
+    guest: false,
+    member: true,
+    moderator: true,
+    owner: true,
+    user: false
+  },
+  team: {
+    admin: true,
+    anonymous: false,
+    channel_member: true,
+    channel_moderator: true,
+    guest: false,
+    member: true,
+    moderator: true,
+    owner: true,
+    user: false
+  }
+};
+const getMessageActions = (actions, {
+  canDelete,
+  canEdit,
+  canFlag,
+  canMarkUnread,
+  canMute,
+  canPin,
+  canQuote,
+  canReact,
+  canReply
+}, channelConfig) => {
+  const messageActionsAfterPermission = [];
+  let messageActions = [];
+  if (actions && typeof actions === "boolean") {
+    messageActions = Object.keys(MESSAGE_ACTIONS);
+  } else if (actions && actions.length > 0) {
+    messageActions = [...actions];
+  } else {
+    return [];
+  }
+  if (canDelete && messageActions.indexOf(MESSAGE_ACTIONS.delete) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.delete);
+  }
+  if (canDelete && messageActions.indexOf(OPTIONAL_MESSAGE_ACTIONS.deleteForMe) > -1) {
+    messageActionsAfterPermission.push(OPTIONAL_MESSAGE_ACTIONS.deleteForMe);
+  }
+  if (canEdit && messageActions.indexOf(MESSAGE_ACTIONS.edit) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.edit);
+  }
+  if (canFlag && messageActions.indexOf(MESSAGE_ACTIONS.flag) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.flag);
+  }
+  if (canMarkUnread && messageActions.indexOf(MESSAGE_ACTIONS.markUnread) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.markUnread);
+  }
+  if (canMute && messageActions.indexOf(MESSAGE_ACTIONS.mute) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.mute);
+  }
+  if (canPin && messageActions.indexOf(MESSAGE_ACTIONS.pin) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.pin);
+  }
+  if (canQuote && messageActions.indexOf(MESSAGE_ACTIONS.quote) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.quote);
+  }
+  if (canReact && messageActions.indexOf(MESSAGE_ACTIONS.react) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.react);
+  }
+  if (channelConfig?.["user_message_reminders"] && messageActions.indexOf(MESSAGE_ACTIONS.remindMe) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.remindMe);
+  }
+  if (canReply && messageActions.indexOf(MESSAGE_ACTIONS.reply) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.reply);
+  }
+  if (channelConfig?.["user_message_reminders"] && messageActions.indexOf(MESSAGE_ACTIONS.saveForLater) > -1) {
+    messageActionsAfterPermission.push(MESSAGE_ACTIONS.saveForLater);
+  }
+  return messageActionsAfterPermission;
+};
+const ACTIONS_NOT_WORKING_IN_THREAD = [
+  MESSAGE_ACTIONS.pin,
+  MESSAGE_ACTIONS.reply,
+  MESSAGE_ACTIONS.markUnread
+];
+function areMessagesEqual(prevMessage, nextMessage) {
+  const areBaseMessagesEqual = (prevMessage2, nextMessage2) => prevMessage2.deleted_at === nextMessage2.deleted_at && prevMessage2.latest_reactions?.length === nextMessage2.latest_reactions?.length && prevMessage2.own_reactions?.length === nextMessage2.own_reactions?.length && prevMessage2.pinned === nextMessage2.pinned && prevMessage2.reply_count === nextMessage2.reply_count && prevMessage2.show_in_channel === nextMessage2.show_in_channel && prevMessage2.status === nextMessage2.status && prevMessage2.text === nextMessage2.text && prevMessage2.type === nextMessage2.type && prevMessage2.updated_at === nextMessage2.updated_at && prevMessage2.user?.updated_at === nextMessage2.user?.updated_at;
+  return areBaseMessagesEqual(prevMessage, nextMessage) && Boolean(prevMessage.quoted_message) === Boolean(nextMessage.quoted_message) && (!prevMessage.quoted_message && !nextMessage.quoted_message || areBaseMessagesEqual(
+    prevMessage.quoted_message,
+    nextMessage.quoted_message
+  ));
+}
+const areMessagePropsEqual = (prevProps, nextProps) => {
+  const { message: prevMessage, Message: prevMessageUI } = prevProps;
+  const { message: nextMessage, Message: nextMessageUI } = nextProps;
+  if (prevMessageUI !== nextMessageUI) return false;
+  if (nextProps.showDetailedReactions !== prevProps.showDetailedReactions) {
+    return false;
+  }
+  if (nextProps.closeReactionSelectorOnClick !== prevProps.closeReactionSelectorOnClick) {
+    return false;
+  }
+  const messagesAreEqual = areMessagesEqual(prevMessage, nextMessage);
+  if (!messagesAreEqual) return false;
+  const deepEqualProps = deepequal(nextProps.messageActions, prevProps.messageActions) && deepequal(nextProps.readBy, prevProps.readBy) && deepequal(nextProps.deliveredTo, prevProps.deliveredTo) && deepequal(nextProps.highlighted, prevProps.highlighted) && deepequal(nextProps.groupStyles, prevProps.groupStyles) && // last 3 messages can have different group styles
+  deepequal(nextProps.mutes, prevProps.mutes) && deepequal(nextProps.lastReceivedId, prevProps.lastReceivedId);
+  if (!deepEqualProps) return false;
+  return prevProps.messageListRect === nextProps.messageListRect;
+};
+const areMessageUIPropsEqual = (prevProps, nextProps) => {
+  const { lastReceivedId: prevLastReceivedId, message: prevMessage } = prevProps;
+  const { lastReceivedId: nextLastReceivedId, message: nextMessage } = nextProps;
+  if (prevProps.highlighted !== nextProps.highlighted) return false;
+  if (prevProps.threadList !== nextProps.threadList) return false;
+  if (prevProps.endOfGroup !== nextProps.endOfGroup) return false;
+  if (prevProps.mutes?.length !== nextProps.mutes?.length) return false;
+  if (prevProps.readBy?.length !== nextProps.readBy?.length) return false;
+  if (prevProps.deliveredTo?.length !== nextProps.deliveredTo?.length) return false;
+  if (prevProps.groupStyles !== nextProps.groupStyles) return false;
+  if (prevProps.showDetailedReactions !== nextProps.showDetailedReactions) {
+    return false;
+  }
+  if ((prevMessage.id === prevLastReceivedId || prevMessage.id === nextLastReceivedId) && prevLastReceivedId !== nextLastReceivedId) {
+    return false;
+  }
+  return areMessagesEqual(prevMessage, nextMessage);
+};
+const messageHasReactions = (message) => Object.values(message?.reaction_groups ?? {}).some(({ count }) => count > 0);
+const messageHasAttachments = (message) => !!message?.attachments && !!message.attachments.length;
+const messageHasSingleAttachment = (message) => message?.attachments?.length === 1;
+const messageHasGiphyAttachment = (message) => !!message?.attachments?.some((att) => att.type === "giphy");
+const getImages = (message) => {
+  if (!message?.attachments) {
+    return [];
+  }
+  return message.attachments.filter((item) => item.type === "image");
+};
+const getNonImageAttachments = (message) => {
+  if (!message?.attachments) {
+    return [];
+  }
+  return message.attachments.filter((item) => item.type !== "image");
+};
+const mapToUserNameOrId = (user) => user.name || user.id;
+const getReadByTooltipText = (users, t, client, tooltipUserNameMapper) => {
+  let outStr = "";
+  if (!t) {
+    throw new Error(
+      "getReadByTooltipText was called, but translation function is not available"
+    );
+  }
+  if (!tooltipUserNameMapper) {
+    throw new Error(
+      "getReadByTooltipText was called, but tooltipUserNameMapper function is not available"
+    );
+  }
+  const otherUsers = users.filter((item) => item && client?.user && item.id !== client.user.id).map(tooltipUserNameMapper);
+  const slicedArr = otherUsers.slice(0, 5);
+  const restLength = otherUsers.length - slicedArr.length;
+  if (slicedArr.length === 1) {
+    outStr = `${slicedArr[0]} `;
+  } else if (slicedArr.length === 2) {
+    outStr = t("{{ firstUser }} and {{ secondUser }}", {
+      firstUser: slicedArr[0],
+      secondUser: slicedArr[1]
+    });
+  } else if (slicedArr.length > 2) {
+    if (restLength === 0) {
+      const lastUser = slicedArr.splice(slicedArr.length - 1, 1);
+      outStr = t("{{ commaSeparatedUsers }}, and {{ lastUser }}", {
+        commaSeparatedUsers: slicedArr.join(", "),
+        lastUser
+      });
+    } else {
+      outStr = t("{{ commaSeparatedUsers }} and {{ moreCount }} more", {
+        commaSeparatedUsers: slicedArr.join(", "),
+        moreCount: restLength
+      });
+    }
+  }
+  return outStr;
+};
+const countEmojis = (text) => {
+  const matches = text?.match(emojiRegex());
+  return matches ? matches.length : 0;
+};
+const messageTextHasEmojisOnly = (message) => {
+  if (!message.text) return false;
+  const noEmojis = message.text.replace(emojiRegex(), "");
+  const noSpace = noEmojis.replace(/[\s\n]/gm, "");
+  return !noSpace;
+};
+const isMessageErrorRetryable = (message) => message.status === "failed" && message.error?.status !== 403;
+const isNetworkSendFailure = (message) => message.status === "failed" && message.error?.status === 0;
+const isMessageBounced = (message) => message.type === "error" && (message.moderation_details?.action === "MESSAGE_RESPONSE_ACTION_BOUNCE" || message.moderation?.action === "bounce");
+const isMessageBlocked = (message) => message.type === "error" && (message.moderation_details?.action === "MESSAGE_RESPONSE_ACTION_REMOVE" || message.moderation?.action === "remove");
+const isMessageEdited = (message) => !!message.message_text_updated_at;
+const hasResizeObserver = typeof window !== "undefined" && "ResizeObserver" in window;
+function autoMiddlewareFor(p) {
+  if (!String(p).startsWith("auto")) return null;
+  const alignment = p === "auto-start" ? "start" : p === "auto-end" ? "end" : void 0;
+  return autoPlacement({ alignment });
+}
+function toOffsetMw(opt) {
+  if (opt == null) return null;
+  if (Array.isArray(opt)) {
+    const [crossAxis, mainAxis] = opt;
+    return offset({ crossAxis, mainAxis });
+  }
+  if (typeof opt === "number") return offset(opt);
+  return offset(opt);
+}
+function usePopoverPosition({
+  allowFlip = true,
+  allowShift = true,
+  autoUpdateOptions,
+  fitAvailableSpace = false,
+  freeze = false,
+  offset: offset2,
+  placement = "bottom-start",
+  shiftOptions
+}) {
+  const autoMw = autoMiddlewareFor(placement);
+  const offsetMiddleware = toOffsetMw(offset2);
+  const isSidePlacement = placement.startsWith("left") || placement.startsWith("right");
+  const mergedShiftOptions = shiftOptions ? { padding: 8, ...shiftOptions } : { padding: 8 };
+  const middleware = [
+    // offset first (mirrors common Popper setups)
+    ...offsetMiddleware ? [offsetMiddleware] : [],
+    // choose between autoPlacement (Popper's "auto*") OR flip()
+    // only allow flip when not explicitly 'left*' or 'right*'
+    ...autoMw ? [autoMw] : allowFlip && !isSidePlacement ? [flip()] : [],
+    // viewport collision adjustments
+    ...allowShift ? [shift(mergedShiftOptions)] : [],
+    // optional size constraining
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    ...fitAvailableSpace ? [size({ apply: () => {
+    } })] : []
+  ];
+  const seedPlacement = String(placement).startsWith("auto") ? "bottom" : placement;
+  return useFloating({
+    middleware,
+    placement: seedPlacement,
+    strategy: "fixed",
+    whileElementsMounted: freeze ? void 0 : (reference, floating, update) => autoUpdate(reference, floating, update, {
+      ancestorResize: true,
+      ancestorScroll: true,
+      animationFrame: false,
+      elementResize: hasResizeObserver,
+      ...autoUpdateOptions
+    })
+  });
+}
+const LegacyThreadContext = React.createContext({ legacyThread: void 0 });
+const useLegacyThreadContext = () => useContext(LegacyThreadContext);
+const cooldownTimerStateSelector = (state) => ({
+  isCooldownActive: !!state.cooldownRemaining
+});
+const useIsCooldownActive = () => {
+  const { channel } = useChannelStateContext();
+  return useStateStore(channel.cooldownTimer.state, cooldownTimerStateSelector).isCooldownActive;
+};
+const queueCache = new FixedSizeQueueCache(64);
+const useMessageComposerController = () => {
+  const { client } = useChatContext();
+  const { channel } = useChannelStateContext();
+  const { legacyThread: parentMessage } = useLegacyThreadContext();
+  const threadInstance = useThreadContext();
+  const cachedParentMessage = useMemo(() => {
+    if (!parentMessage) return void 0;
+    return parentMessage;
+  }, [parentMessage?.id]);
+  const messageComposer = useMemo(() => {
+    if (threadInstance) {
+      return threadInstance.messageComposer;
+    } else if (cachedParentMessage) {
+      const compositionContext = {
+        ...cachedParentMessage,
+        legacyThreadId: cachedParentMessage.id
+      };
+      const tag = MessageComposer.constructTag(compositionContext);
+      const cachedComposer = queueCache.get(tag);
+      if (cachedComposer) return cachedComposer;
+      return new MessageComposer({
+        client,
+        compositionContext
+      });
+    } else {
+      return channel.messageComposer;
+    }
+  }, [cachedParentMessage, channel, client, threadInstance]);
+  if (["legacy_thread", "message"].includes(
+    messageComposer.contextType
+  ) && !queueCache.peek(messageComposer.tag)) {
+    queueCache.add(messageComposer.tag, messageComposer);
+  }
+  useEffect(() => {
+    const unsubscribe = messageComposer.registerSubscriptions();
+    return () => {
+      unsubscribe();
+    };
+  }, [messageComposer]);
+  return messageComposer;
+};
+const CUSTOM_MESSAGE_TYPE = {
+  date: "message.date",
+  intro: "channel.intro"
+};
+const processMessages = (params) => {
+  const { messages, reviewProcessedMessage, setGiphyPreviewMessage, ...context } = params;
+  const {
+    enableDateSeparator,
+    hideDeletedMessages,
+    hideNewMessageSeparator,
+    lastRead,
+    userId
+  } = context;
+  let unread = false;
+  let ephemeralMessagePresent = false;
+  let lastDateSeparator;
+  const newMessages = [];
+  for (let i = 0; i < messages.length; i += 1) {
+    const message = messages[i];
+    if (hideDeletedMessages && message.type === "deleted") {
+      continue;
+    }
+    if (setGiphyPreviewMessage && message.type === "ephemeral" && message.command === "giphy") {
+      ephemeralMessagePresent = true;
+      setGiphyPreviewMessage(message);
+      continue;
+    }
+    const changes = [];
+    const messageDate = message.created_at && isDate(message.created_at) && message.created_at.toDateString() || "";
+    const previousMessage = messages[i - 1];
+    let prevMessageDate = messageDate;
+    if (enableDateSeparator && previousMessage?.created_at && isDate(previousMessage.created_at)) {
+      prevMessageDate = previousMessage.created_at.toDateString();
+    }
+    if (!unread && !hideNewMessageSeparator) {
+      unread = lastRead && message.created_at && new Date(lastRead) < message.created_at || false;
+      if (enableDateSeparator && unread && message.user?.id !== userId) {
+        changes.push({
+          customType: CUSTOM_MESSAGE_TYPE.date,
+          date: message.created_at,
+          id: makeDateMessageId(message.created_at),
+          unread
+        });
+      }
+    }
+    if (enableDateSeparator && (i === 0 || // always put date separator before the first message
+    messageDate !== prevMessageDate || // add date separator btw. 2 messages created on different date
+    // if hiding deleted messages replace the previous deleted message(s) with A separator if the last rendered message was created on different date
+    hideDeletedMessages && previousMessage?.type === "deleted" && lastDateSeparator !== messageDate) && !isDateSeparatorMessage(changes[changes.length - 1])) {
+      lastDateSeparator = messageDate;
+      changes.push(
+        {
+          customType: CUSTOM_MESSAGE_TYPE.date,
+          date: message.created_at,
+          id: makeDateMessageId(message.created_at)
+        },
+        message
+      );
+    } else {
+      changes.push(message);
+    }
+    newMessages.push(
+      ...reviewProcessedMessage?.({
+        changes,
+        context,
+        index: i,
+        messages,
+        processedMessages: newMessages
+      }) || changes
+    );
+  }
+  if (setGiphyPreviewMessage && !ephemeralMessagePresent) {
+    setGiphyPreviewMessage(void 0);
+  }
+  return newMessages;
+};
+const makeIntroMessage = () => ({
+  customType: CUSTOM_MESSAGE_TYPE.intro,
+  id: nanoid()
+});
+const makeDateMessageId = (date) => {
+  let idSuffix;
+  try {
+    idSuffix = !date ? nanoid() : date instanceof Date ? date.toISOString() : date;
+  } catch (e) {
+    idSuffix = nanoid();
+  }
+  return `${CUSTOM_MESSAGE_TYPE.date}-${idSuffix}`;
+};
+const getLastReceived = (messages) => {
+  for (let i = messages.length - 1; i > 0; i -= 1) {
+    if (messages[i].status === "received") {
+      return messages[i].id;
+    }
+  }
+  return null;
+};
+const insertIntro = (messages, headerPosition) => {
+  const newMessages = messages;
+  const intro = makeIntroMessage();
+  if (!headerPosition) {
+    newMessages.unshift(intro);
+    return newMessages;
+  }
+  if (!newMessages.length) {
+    newMessages.unshift(intro);
+    return newMessages;
+  }
+  for (let i = 0; i < messages.length; i += 1) {
+    const messageTime = isDate(messages[i].created_at) ? messages[i].created_at.getTime() : null;
+    const nextMessageTime = isDate(messages[i + 1].created_at) ? messages[i + 1].created_at.getTime() : null;
+    if (messageTime && messageTime < headerPosition) {
+      if (nextMessageTime && nextMessageTime < headerPosition) {
+        if (messages[i + 1] && isDateSeparatorMessage(messages[i + 1])) continue;
+        if (!nextMessageTime) {
+          newMessages.push(intro);
+          return newMessages;
+        }
+      } else {
+        newMessages.splice(i + 1, 0, intro);
+        return newMessages;
+      }
+    }
+  }
+  return newMessages;
+};
+const getGroupStyles = (message, previousMessage, nextMessage, noGroupByUser, maxTimeBetweenGroupedMessages) => {
+  if (isDateSeparatorMessage(message) || isIntroMessage(message)) return "";
+  if (noGroupByUser || message.attachments?.length !== 0) return "single";
+  const isTopMessage = !previousMessage || isIntroMessage(previousMessage) || isDateSeparatorMessage(previousMessage) || previousMessage.type === "system" || previousMessage.type === "error" || previousMessage.attachments?.length !== 0 || message.user?.id !== previousMessage.user?.id || message.reaction_groups && Object.keys(message.reaction_groups).length > 0 || isMessageEdited(previousMessage) || maxTimeBetweenGroupedMessages !== void 0 && previousMessage.created_at && message.created_at && new Date(message.created_at).getTime() - new Date(previousMessage.created_at).getTime() > maxTimeBetweenGroupedMessages;
+  const isBottomMessage = !nextMessage || isIntroMessage(nextMessage) || isDateSeparatorMessage(nextMessage) || nextMessage.type === "system" || nextMessage.type === "error" || nextMessage.attachments?.length !== 0 || message.user?.id !== nextMessage.user?.id || nextMessage.reaction_groups && Object.keys(nextMessage.reaction_groups).length > 0 || isMessageEdited(message) || maxTimeBetweenGroupedMessages !== void 0 && nextMessage.created_at && message.created_at && new Date(nextMessage.created_at).getTime() - new Date(message.created_at).getTime() > maxTimeBetweenGroupedMessages;
+  if (!isTopMessage && !isBottomMessage) {
+    if (message.type === "error") return "single";
+    return "middle";
+  }
+  if (isBottomMessage) {
+    if (isTopMessage || message.type === "error") return "single";
+    return "bottom";
+  }
+  if (isTopMessage) return "top";
+  return "";
+};
+const hasMoreMessagesProbably = (returnedCountMessages, limit) => returnedCountMessages >= limit;
+const hasNotMoreMessages = (returnedCountMessages, limit) => returnedCountMessages < limit;
+function isIntroMessage(message) {
+  return message.customType === CUSTOM_MESSAGE_TYPE.intro;
+}
+function isDateSeparatorMessage(message) {
+  return message !== null && typeof message === "object" && message.customType === CUSTOM_MESSAGE_TYPE.date && isDate(message.date);
+}
+function isLocalMessage(message) {
+  return !isDateSeparatorMessage(message) && !isIntroMessage(message);
+}
+const getIsFirstUnreadMessage = ({
+  firstUnreadMessageId,
+  isFirstMessage,
+  lastReadDate,
+  lastReadMessageId,
+  message,
+  previousMessage,
+  unreadMessageCount = 0
+}) => {
+  if (message.parent_id) return false;
+  const createdAtTimestamp = message.created_at && new Date(message.created_at).getTime();
+  const lastReadTimestamp = lastReadDate?.getTime();
+  const messageIsUnread = !!createdAtTimestamp && !!lastReadTimestamp && createdAtTimestamp > lastReadTimestamp;
+  const previousMessageIsLastRead = !!lastReadMessageId && lastReadMessageId === previousMessage?.id;
+  return firstUnreadMessageId === message.id || !!unreadMessageCount && messageIsUnread && (isFirstMessage || previousMessageIsLastRead);
+};
+const useImageFlagEmojisOnWindowsClass = () => {
+  const { useImageFlagEmojisOnWindows } = useChatContext("Channel");
+  return useImageFlagEmojisOnWindows && navigator.userAgent.match(/Win/) ? "str-chat--windows-flags" : "";
+};
+const getChatContainerClass = (customClass) => customClass ?? "str-chat__container";
+const useChannelContainerClasses = ({
+  customClasses
+}) => {
+  const windowsEmojiClass = useImageFlagEmojisOnWindowsClass();
+  return {
+    channelClass: customClasses?.channel ?? "str-chat__channel",
+    chatClass: customClasses?.chat ?? "str-chat",
+    chatContainerClass: getChatContainerClass(customClasses?.chatContainer),
+    windowsEmojiClass
+  };
+};
+const findInMsgSetById = (targetId, msgSet) => {
+  for (let i = msgSet.length - 1; i >= 0; i--) {
+    const item = msgSet[i];
+    if (item.id === targetId) {
+      return {
+        index: i,
+        target: item
+      };
+    }
+  }
+  return {
+    index: -1
+  };
+};
+const findInMsgSetByDate = (targetDate, msgSet, exact = false) => {
+  const targetTimestamp = targetDate.getTime();
+  let left = 0;
+  let middle = 0;
+  let right = msgSet.length - 1;
+  while (left <= right) {
+    middle = Math.floor((right + left) / 2);
+    const middleTimestamp = new Date(
+      msgSet[middle].created_at
+    ).getTime();
+    const middleLeftTimestamp = msgSet[middle - 1]?.created_at && new Date(msgSet[middle - 1].created_at).getTime();
+    const middleRightTimestamp = msgSet[middle + 1]?.created_at && new Date(msgSet[middle + 1].created_at).getTime();
+    if (middleTimestamp === targetTimestamp || middleLeftTimestamp && middleRightTimestamp && middleLeftTimestamp < targetTimestamp && targetTimestamp < middleRightTimestamp) {
+      return { index: middle, target: msgSet[middle] };
+    }
+    if (middleTimestamp < targetTimestamp) left = middle + 1;
+    else right = middle - 1;
+  }
+  if (!exact || new Date(msgSet[left].created_at).getTime() === targetTimestamp) {
+    return { index: left, target: msgSet[left] };
+  }
+  return { index: -1 };
+};
+const adaptMessageSendErrorToErrorFromResponse = (error) => {
+  if (error instanceof ErrorFromResponse) {
+    return error;
+  }
+  const fallbackMessage = error instanceof Error ? error.message : "Message send failed";
+  let message = fallbackMessage;
+  let status = 0;
+  let code = null;
+  if (typeof error === "object" && error !== null) {
+    const maybeAxiosError = error;
+    if (maybeAxiosError.name === "AxiosError" && maybeAxiosError.code === "ERR_NETWORK") {
+      message = typeof maybeAxiosError.message === "string" ? maybeAxiosError.message : "Network Error";
+      status = maybeAxiosError.response?.status ?? 0;
+      return new ErrorFromResponse(message, {
+        code: null,
+        response: maybeAxiosError.response ?? {
+          // Compatibility shim: this is an intentionally incomplete AxiosResponse-like object.
+          data: {
+            duration: "",
+            message,
+            more_info: "",
+            StatusCode: status
+          },
+          status
+        },
+        status
+      });
+    }
+    try {
+      const stringError = JSON.stringify(error);
+      const parsedError = stringError ? JSON.parse(stringError) : {};
+      if (typeof parsedError.message === "string") {
+        message = parsedError.message;
+      }
+      if (typeof parsedError.status === "number") {
+        status = parsedError.status;
+      }
+      if (typeof parsedError.code === "number") {
+        code = parsedError.code;
+      }
+    } catch {
+    }
+  }
+  return new ErrorFromResponse(message, {
+    code,
+    response: {
+      // Compatibility shim: this is an intentionally incomplete AxiosResponse-like object.
+      data: {
+        duration: "",
+        message,
+        more_info: "",
+        StatusCode: status
+      },
+      status
+    },
+    status
+  });
+};
+const WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL = {};
+const getChannel = async ({
+  channel,
+  client,
+  id,
+  members,
+  options,
+  type
+}) => {
+  if (!channel && !type) {
+    throw new Error("Channel or channel type have to be provided to query a channel.");
+  }
+  const theChannel = channel || client.channel(type, id, { members });
+  const originalCid = theChannel?.id ? theChannel.cid : members && members.length ? generateChannelTempCid(theChannel.type, members) : void 0;
+  if (!originalCid) {
+    throw new Error(
+      "Channel ID or channel members array have to be provided to query a channel."
+    );
+  }
+  const queryPromise = WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
+  if (queryPromise) {
+    await queryPromise;
+  } else {
+    try {
+      WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid] = theChannel.watch(options);
+      await WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
+    } finally {
+      delete WATCH_QUERY_IN_PROGRESS_FOR_CHANNEL[originalCid];
+    }
+  }
+  return theChannel;
+};
+const generateChannelTempCid = (channelType, members) => {
+  if (!members) return;
+  const membersStr = [...members].sort().join(",");
+  return `${channelType}:!members-${membersStr}`;
+};
+const getImageAttachmentConfiguration = (attachment, element) => {
+  let newUrl = void 0;
+  const urlToTest = attachment.image_url || attachment.thumb_url || "";
+  if (linkify.test(urlToTest, "url")) {
+    const url = new URL(urlToTest);
+    const resizeDimensions = getSizingRestrictions(url, element);
+    if (resizeDimensions) {
+      resizeDimensions.height *= 2;
+      resizeDimensions.width *= 2;
+      addResizingParamsToUrl(resizeDimensions, url);
+    }
+    newUrl = url.href;
+  }
+  return {
+    url: newUrl || ""
+  };
+};
+const getVideoAttachmentConfiguration = (attachment, element, shouldGenerateVideoThumbnail) => {
+  let thumbUrl = void 0;
+  if (attachment.thumb_url && shouldGenerateVideoThumbnail && linkify.test(attachment.thumb_url, "url")) {
+    const url = new URL(attachment.thumb_url);
+    const resizeDimensions = getSizingRestrictions(url, element);
+    if (resizeDimensions) {
+      resizeDimensions.height *= 2;
+      resizeDimensions.width *= 2;
+      addResizingParamsToUrl(resizeDimensions, url);
+    }
+    thumbUrl = url.href;
+  }
+  return {
+    thumbUrl,
+    url: attachment.asset_url || ""
+  };
+};
+const getSizingRestrictions = (url, htmlElement) => {
+  const urlParams = url.searchParams;
+  const originalHeight = Number(urlParams.get("oh")) || 1;
+  const originalWidth = Number(urlParams.get("ow")) || 1;
+  const cssSizeRestriction = getCSSSizeRestrictions(htmlElement);
+  let resizeDimensions;
+  if ((cssSizeRestriction.maxHeight || cssSizeRestriction.height) && cssSizeRestriction.maxWidth) {
+    resizeDimensions = getResizeDimensions(
+      originalHeight,
+      originalWidth,
+      /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+      cssSizeRestriction.maxHeight || cssSizeRestriction.height,
+      cssSizeRestriction.maxWidth
+    );
+  } else {
+    resizeDimensions = void 0;
+  }
+  return resizeDimensions;
+};
+const getResizeDimensions = (originalHeight, originalWidth, maxHeight, maxWidth) => ({
+  height: Math.round(Math.max(maxHeight, maxWidth / originalWidth * originalHeight)),
+  width: Math.round(Math.max(maxHeight, maxWidth / originalHeight * originalWidth))
+});
+const getCSSSizeRestrictions = (htmlElement) => {
+  const computedStylesheet = getComputedStyle(htmlElement);
+  const height = getValueRepresentationOfCSSProperty(
+    computedStylesheet.getPropertyValue("height")
+  );
+  const maxHeight = getValueRepresentationOfCSSProperty(
+    computedStylesheet.getPropertyValue("max-height")
+  );
+  const maxWidth = getValueRepresentationOfCSSProperty(
+    computedStylesheet.getPropertyValue("max-width")
+  );
+  if (!((height || maxHeight) && maxWidth)) {
+    console.warn(
+      `Invalid value set for height/max-height and/or max-width for HTML element, this can cause scrolling issues inside the message list, more info https://getstream.io/chat/docs/sdk/react/message-components/attachment/#image-and-video-sizing`
+    );
+  }
+  return { height, maxHeight, maxWidth };
+};
+const getValueRepresentationOfCSSProperty = (property) => {
+  if (!property.endsWith("px")) {
+    return void 0;
+  }
+  const number = parseFloat(property);
+  return isNaN(number) ? void 0 : number;
+};
+const addResizingParamsToUrl = (resizeDimensions, url) => {
+  url.searchParams.set("h", resizeDimensions.height.toString());
+  url.searchParams.set("w", resizeDimensions.width.toString());
+};
+const searchControllerStateSelector = (nextValue) => ({
+  focusedMessage: nextValue.focusedMessage
+});
+const useSearchFocusedMessage = () => {
+  const { searchController } = useChatContext("Channel");
+  const { focusedMessage } = useStateStore(
+    searchController._internalState,
+    searchControllerStateSelector
+  );
+  return focusedMessage;
+};
+const ChannelContainer = ({
+  children,
+  className: additionalClassName,
+  ...props
+}) => {
+  const { customClasses, theme } = useChatContext("Channel");
+  const { channelClass, chatClass } = useChannelContainerClasses({
+    customClasses
+  });
+  const className = clsx(chatClass, theme, channelClass, additionalClassName);
+  return /* @__PURE__ */ jsx("div", { id: CHANNEL_CONTAINER_ID, ...props, className, children });
+};
+const UnMemoizedChannel = (props) => {
+  const { channel: propsChannel, EmptyPlaceholder } = props;
+  const {
+    EmptyStateIndicator: EmptyStateIndicator$1 = EmptyStateIndicator,
+    LoadingErrorIndicator: LoadingErrorIndicator2,
+    LoadingIndicator = LoadingChannel
+  } = useComponentContext();
+  const { channel: contextChannel, channelsQueryState } = useChatContext("Channel");
+  const channel = propsChannel || contextChannel;
+  const emptyPlaceholder = "EmptyPlaceholder" in props ? EmptyPlaceholder : EmptyStateIndicator$1 && /* @__PURE__ */ jsx(EmptyStateIndicator$1, { listType: "message" });
+  if (channelsQueryState.queryInProgress === "reload" && LoadingIndicator) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: /* @__PURE__ */ jsx(LoadingIndicator, {}) });
+  }
+  if (channelsQueryState.error && LoadingErrorIndicator2) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: /* @__PURE__ */ jsx(LoadingErrorIndicator2, { error: channelsQueryState.error }) });
+  }
+  if (channelsQueryState.error) {
+    return /* @__PURE__ */ jsx(ChannelContainer, {});
+  }
+  if (!channel?.cid) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: emptyPlaceholder });
+  }
+  return /* @__PURE__ */ createElement(ChannelInner, { ...props, channel, key: channel.cid });
+};
+const ChannelInner = (props) => {
+  const {
+    activeUnreadHandler,
+    allowConcurrentAudioPlayback,
+    channel,
+    channelQueryOptions,
+    children,
+    doDeleteMessageRequest,
+    doMarkReadRequest,
+    doSendMessageRequest,
+    doUpdateMessageRequest,
+    initializeOnMount = true,
+    markReadOnMount = true,
+    onMentionsClick,
+    onMentionsHover,
+    skipMessageDataMemoization
+  } = props;
+  const {
+    LoadingErrorIndicator: LoadingErrorIndicator$1 = LoadingErrorIndicator,
+    LoadingIndicator = LoadingChannel
+  } = useComponentContext();
+  const { client, customClasses, latestMessageDatesByChannels, mutes, searchController } = useChatContext("Channel");
+  const { t } = useTranslationContext("Channel");
+  const chatContainerClass = getChatContainerClass(customClasses?.chatContainer);
+  const windowsEmojiClass = useImageFlagEmojisOnWindowsClass();
+  const thread = useThreadContext();
+  const [channelConfig, setChannelConfig] = useState(channel.getConfig());
+  const [channelUnreadUiState, _setChannelUnreadUiState] = useState();
+  const channelReducer = useMemo(() => makeChannelReducer(), []);
+  const [state, dispatch] = useReducer(
+    channelReducer,
+    // channel.initialized === false if client.channel().query() was not called, e.g. ChannelList is not used
+    // => Channel will call channel.watch() in useLayoutEffect => state.loading is used to signal the watch() call state
+    {
+      ...initialState,
+      hasMore: channel.state.messagePagination.hasPrev,
+      loading: !channel.initialized,
+      messages: channel.state.messages
+    }
+  );
+  const jumpToMessageFromSearch = useSearchFocusedMessage();
+  const isMounted = useIsMounted();
+  const originalTitle = useRef("");
+  const lastRead = useRef(void 0);
+  const online = useRef(true);
+  const clearHighlightedMessageTimeoutId = useRef(
+    null
+  );
+  const channelCapabilitiesArray = channel.data?.own_capabilities;
+  const throttledCopyStateFromChannel = throttle(
+    () => dispatch({ channel, type: "copyStateFromChannelOnEvent" }),
+    500,
+    {
+      leading: true,
+      trailing: true
+    }
+  );
+  const setChannelUnreadUiState = useMemo(
+    () => throttle(_setChannelUnreadUiState, 200, {
+      leading: true,
+      trailing: false
+    }),
+    []
+  );
+  const markRead = useMemo(
+    () => throttle(
+      async (options) => {
+        const { updateChannelUiUnreadState = true } = options ?? {};
+        if (channel.disconnected || !channelConfig?.read_events) {
+          return;
+        }
+        lastRead.current = /* @__PURE__ */ new Date();
+        try {
+          if (doMarkReadRequest) {
+            doMarkReadRequest(
+              channel,
+              updateChannelUiUnreadState ? setChannelUnreadUiState : void 0
+            );
+          } else {
+            const markReadResponse = await channel.markRead();
+            if (updateChannelUiUnreadState && markReadResponse?.event) {
+              _setChannelUnreadUiState({
+                last_read: lastRead.current,
+                last_read_message_id: markReadResponse.event.last_read_message_id,
+                unread_messages: 0
+              });
+            }
+          }
+          if (activeUnreadHandler) {
+            activeUnreadHandler(0, originalTitle.current);
+          } else if (originalTitle.current) {
+            document.title = originalTitle.current;
+          }
+        } catch (e) {
+          console.error(t("Failed to mark channel as read"));
+        }
+      },
+      500,
+      { leading: true, trailing: false }
+    ),
+    [
+      activeUnreadHandler,
+      channel,
+      channelConfig,
+      doMarkReadRequest,
+      setChannelUnreadUiState,
+      t
+    ]
+  );
+  const handleEvent = async (event) => {
+    if (event.message) {
+      dispatch({
+        channel,
+        message: event.message,
+        type: "updateThreadOnEvent"
+      });
+    }
+    if (event.type === "user.messages.deleted" && event.cid && event.cid !== channel.cid)
+      return;
+    if (event.type === "user.watching.start" || event.type === "user.watching.stop")
+      return;
+    if (event.type === "typing.start" || event.type === "typing.stop") {
+      return dispatch({ channel, type: "setTyping" });
+    }
+    if (event.type === "connection.changed" && typeof event.online === "boolean") {
+      online.current = event.online;
+    }
+    if (event.type === "message.new") {
+      const mainChannelUpdated = !event.message?.parent_id || event.message?.show_in_channel;
+      if (mainChannelUpdated) {
+        if (document.hidden && channelConfig?.read_events && !channel.muteStatus().muted) {
+          const unread = channel.countUnread(lastRead.current);
+          if (activeUnreadHandler) {
+            activeUnreadHandler(unread, originalTitle.current);
+          } else {
+            document.title = `(${unread}) ${originalTitle.current}`;
+          }
+        }
+      }
+      if (event.message?.user?.id === client.userID && event?.message?.created_at && event?.message?.cid) {
+        const messageDate = new Date(event.message.created_at);
+        const cid = event.message.cid;
+        if (!latestMessageDatesByChannels[cid] || latestMessageDatesByChannels[cid].getTime() < messageDate.getTime()) {
+          latestMessageDatesByChannels[cid] = messageDate;
+        }
+      }
+    }
+    if (event.type === "user.deleted") {
+      const oldestID = channel.state?.messages?.[0]?.id;
+      await channel.query({
+        messages: { id_lt: oldestID, limit: DEFAULT_NEXT_CHANNEL_PAGE_SIZE },
+        watchers: { limit: DEFAULT_NEXT_CHANNEL_PAGE_SIZE }
+      });
+    }
+    if (event.type === "notification.mark_unread")
+      _setChannelUnreadUiState((prev) => {
+        if (!(event.last_read_at && event.user)) return prev;
+        return {
+          first_unread_message_id: event.first_unread_message_id,
+          last_read: new Date(event.last_read_at),
+          last_read_message_id: event.last_read_message_id,
+          unread_messages: event.unread_messages ?? 0
+        };
+      });
+    if (event.type === "channel.truncated" && event.cid === channel.cid) {
+      _setChannelUnreadUiState(void 0);
+    }
+    throttledCopyStateFromChannel();
+  };
+  useLayoutEffect(() => {
+    let errored = false;
+    let done = false;
+    (async () => {
+      if (!channel.initialized && initializeOnMount) {
+        try {
+          const members = [];
+          if (!channel.id && channel.data?.members) {
+            for (const member of channel.data.members) {
+              let userId;
+              if (typeof member === "string") {
+                userId = member;
+              } else if (typeof member === "object") {
+                const { user, user_id } = member;
+                userId = user_id || user?.id;
+              }
+              if (userId) {
+                members.push(userId);
+              }
+            }
+          }
+          await getChannel({ channel, client, members, options: channelQueryOptions });
+          const config = channel.getConfig();
+          setChannelConfig(config);
+        } catch (e) {
+          dispatch({ error: e, type: "setError" });
+          errored = true;
+        }
+      }
+      done = true;
+      originalTitle.current = document.title;
+      if (!errored) {
+        dispatch({
+          channel,
+          hasMore: channel.state.messagePagination.hasPrev,
+          type: "initStateFromChannel"
+        });
+        if (client.user?.id && channel.state.read[client.user.id]) {
+          const { user, ...ownReadState } = channel.state.read[client.user.id];
+          _setChannelUnreadUiState(ownReadState);
+        }
+        if (channel.countUnread() > 0 && markReadOnMount)
+          markRead({ updateChannelUiUnreadState: false });
+        client.on("connection.changed", handleEvent);
+        client.on("connection.recovered", handleEvent);
+        client.on("user.updated", handleEvent);
+        client.on("user.deleted", handleEvent);
+        client.on("user.messages.deleted", handleEvent);
+        channel.on(handleEvent);
+      }
+    })();
+    return () => {
+      if (errored || !done) return;
+      channel?.off(handleEvent);
+      client.off("connection.changed", handleEvent);
+      client.off("connection.recovered", handleEvent);
+      client.off("user.deleted", handleEvent);
+    };
+  }, [
+    channel.cid,
+    channelQueryOptions,
+    doMarkReadRequest,
+    channelConfig?.read_events,
+    initializeOnMount
+  ]);
+  useEffect(() => {
+    if (!state.thread) return;
+    const message = state.messages?.find((m) => m.id === state.thread?.id);
+    if (message) dispatch({ message, type: "setThread" });
+  }, [state.messages, state.thread]);
+  const handleHighlightedMessageChange = useCallback(
+    ({
+      highlightDuration,
+      highlightedMessageId
+    }) => {
+      dispatch({
+        channel,
+        highlightedMessageId,
+        type: "jumpToMessageFinished"
+      });
+      if (clearHighlightedMessageTimeoutId.current) {
+        clearTimeout(clearHighlightedMessageTimeoutId.current);
+      }
+      clearHighlightedMessageTimeoutId.current = setTimeout(() => {
+        if (searchController._internalState.getLatestValue().focusedMessage) {
+          searchController._internalState.partialNext({ focusedMessage: void 0 });
+        }
+        clearHighlightedMessageTimeoutId.current = null;
+        dispatch({ type: "clearHighlightedMessage" });
+      }, highlightDuration ?? DEFAULT_HIGHLIGHT_DURATION);
+    },
+    [channel, searchController]
+  );
+  useEffect(() => {
+    if (!jumpToMessageFromSearch?.id) return;
+    handleHighlightedMessageChange({ highlightedMessageId: jumpToMessageFromSearch.id });
+  }, [jumpToMessageFromSearch, handleHighlightedMessageChange]);
+  const notifyJumpToFirstUnreadError = useCallback(() => {
+    client.notifications.addError({
+      message: t("Failed to jump to the first unread message"),
+      options: {
+        tags: addNotificationTargetTag("channel"),
+        type: "channel:jumpToFirstUnread:failed"
+      },
+      origin: {
+        context: { feature: "jumpToFirstUnread" },
+        emitter: "Channel"
+      }
+    });
+  }, [client, t]);
+  const loadMoreFinished = useCallback(
+    debounce(
+      (hasMore, messages) => {
+        if (!isMounted.current) return;
+        dispatch({ hasMore, messages, type: "loadMoreFinished" });
+      },
+      2e3,
+      { leading: true, trailing: true }
+    ),
+    []
+  );
+  const finishLoadMore = useCallback(
+    (hasMore, messages) => {
+      if (!isMounted.current) return;
+      dispatch({ hasMore, messages, type: "loadMoreFinished" });
+    },
+    [isMounted]
+  );
+  const loadMore = async (limit = DEFAULT_NEXT_CHANNEL_PAGE_SIZE) => {
+    if (!online.current || !window.navigator.onLine || !channel.state.messagePagination.hasPrev)
+      return 0;
+    const oldestMessage = state?.messages?.[0];
+    if (state.loadingMore || state.loadingMoreNewer || oldestMessage?.status !== "received") {
+      return 0;
+    }
+    dispatch({ loadingMore: true, type: "setLoadingMore" });
+    const oldestID = oldestMessage?.id;
+    const perPage = limit;
+    let queryResponse;
+    try {
+      queryResponse = await channel.query({
+        messages: { id_lt: oldestID, limit: perPage },
+        watchers: { limit: perPage }
+      });
+    } catch (e) {
+      console.warn("message pagination request failed with error", e);
+      dispatch({ loadingMore: false, type: "setLoadingMore" });
+      return 0;
+    }
+    loadMoreFinished.cancel();
+    finishLoadMore(channel.state.messagePagination.hasPrev, channel.state.messages);
+    return queryResponse.messages.length;
+  };
+  const loadMoreNewer = async (limit = DEFAULT_NEXT_CHANNEL_PAGE_SIZE) => {
+    if (!online.current || !window.navigator.onLine || !channel.state.messagePagination.hasNext)
+      return 0;
+    const newestMessage = state?.messages?.[state?.messages?.length - 1];
+    if (state.loadingMore || state.loadingMoreNewer) return 0;
+    dispatch({ loadingMoreNewer: true, type: "setLoadingMoreNewer" });
+    const newestId = newestMessage?.id;
+    const perPage = limit;
+    let queryResponse;
+    try {
+      queryResponse = await channel.query({
+        messages: { id_gt: newestId, limit: perPage },
+        watchers: { limit: perPage }
+      });
+    } catch (e) {
+      console.warn("message pagination request failed with error", e);
+      dispatch({ loadingMoreNewer: false, type: "setLoadingMoreNewer" });
+      return 0;
+    }
+    dispatch({
+      hasMoreNewer: channel.state.messagePagination.hasNext,
+      messages: channel.state.messages,
+      type: "loadMoreNewerFinished"
+    });
+    return queryResponse.messages.length;
+  };
+  const jumpToMessage = useCallback(
+    async (messageId, messageLimit = DEFAULT_JUMP_TO_PAGE_SIZE, highlightDuration = DEFAULT_HIGHLIGHT_DURATION) => {
+      dispatch({
+        loadingMoreForJumpToChannelMessage: true,
+        type: "setLoadingMoreForJumpToChannelMessage"
+      });
+      loadMoreFinished.cancel();
+      try {
+        await channel.state.loadMessageIntoState(messageId, void 0, messageLimit);
+        handleHighlightedMessageChange({
+          highlightDuration,
+          highlightedMessageId: messageId
+        });
+      } catch (error) {
+        dispatch({
+          loadingMoreForJumpToChannelMessage: false,
+          type: "setLoadingMoreForJumpToChannelMessage"
+        });
+        throw error;
+      }
+    },
+    [channel, handleHighlightedMessageChange, loadMoreFinished]
+  );
+  const jumpToLatestMessage = useCallback(async () => {
+    loadMoreFinished.cancel();
+    await channel.state.loadMessageIntoState("latest");
+    dispatch({
+      hasMore: channel.state.messagePagination.hasPrev,
+      hasMoreNewer: channel.state.messagePagination.hasNext,
+      messages: channel.state.messages,
+      type: "jumpToLatestMessageFinished"
+    });
+  }, [channel, loadMoreFinished]);
+  const jumpToFirstUnreadMessage = useCallback(
+    async (queryMessageLimit = DEFAULT_JUMP_TO_PAGE_SIZE, highlightDuration = DEFAULT_HIGHLIGHT_DURATION) => {
+      if (!channelUnreadUiState?.unread_messages) return;
+      let lastReadMessageId = channelUnreadUiState?.last_read_message_id;
+      let firstUnreadMessageId = channelUnreadUiState?.first_unread_message_id;
+      let isInCurrentMessageSet = false;
+      if (firstUnreadMessageId) {
+        const result = findInMsgSetById(firstUnreadMessageId, channel.state.messages);
+        isInCurrentMessageSet = result.index !== -1;
+      } else if (lastReadMessageId) {
+        const result = findInMsgSetById(lastReadMessageId, channel.state.messages);
+        isInCurrentMessageSet = !!result.target;
+        firstUnreadMessageId = result.index > -1 ? channel.state.messages[result.index + 1]?.id : void 0;
+      } else {
+        const lastReadTimestamp = channelUnreadUiState.last_read.getTime();
+        const { index: lastReadMessageIndex, target: lastReadMessage } = findInMsgSetByDate(
+          channelUnreadUiState.last_read,
+          channel.state.messages,
+          true
+        );
+        if (lastReadMessage) {
+          firstUnreadMessageId = channel.state.messages[lastReadMessageIndex + 1]?.id;
+          isInCurrentMessageSet = !!firstUnreadMessageId;
+          lastReadMessageId = lastReadMessage.id;
+        } else {
+          dispatch({ loadingMore: true, type: "setLoadingMore" });
+          let messages;
+          try {
+            messages = (await channel.query(
+              {
+                messages: {
+                  created_at_around: channelUnreadUiState.last_read.toISOString(),
+                  limit: queryMessageLimit
+                }
+              },
+              "new"
+            )).messages;
+          } catch (e) {
+            notifyJumpToFirstUnreadError();
+            finishLoadMore(
+              channel.state.messagePagination.hasPrev,
+              channel.state.messages
+            );
+            return;
+          }
+          const firstMessageWithCreationDate = messages.find((msg) => msg.created_at);
+          if (!firstMessageWithCreationDate) {
+            notifyJumpToFirstUnreadError();
+            finishLoadMore(
+              channel.state.messagePagination.hasPrev,
+              channel.state.messages
+            );
+            return;
+          }
+          const firstMessageTimestamp = new Date(
+            firstMessageWithCreationDate.created_at
+          ).getTime();
+          if (lastReadTimestamp < firstMessageTimestamp) {
+            firstUnreadMessageId = firstMessageWithCreationDate.id;
+          } else {
+            const result = findInMsgSetByDate(channelUnreadUiState.last_read, messages);
+            lastReadMessageId = result.target?.id;
+          }
+          finishLoadMore(
+            channel.state.messagePagination.hasPrev,
+            channel.state.messages
+          );
+        }
+      }
+      if (!firstUnreadMessageId && !lastReadMessageId) {
+        notifyJumpToFirstUnreadError();
+        return;
+      }
+      if (!isInCurrentMessageSet) {
+        dispatch({ loadingMore: true, type: "setLoadingMore" });
+        try {
+          const targetId = firstUnreadMessageId ?? lastReadMessageId;
+          await channel.state.loadMessageIntoState(
+            targetId,
+            void 0,
+            queryMessageLimit
+          );
+          const indexOfTarget = channel.state.messages.findIndex(
+            (message) => message.id === targetId
+          );
+          finishLoadMore(
+            channel.state.messagePagination.hasPrev,
+            channel.state.messages
+          );
+          firstUnreadMessageId = firstUnreadMessageId ?? channel.state.messages[indexOfTarget + 1]?.id;
+        } catch (e) {
+          notifyJumpToFirstUnreadError();
+          finishLoadMore(
+            channel.state.messagePagination.hasPrev,
+            channel.state.messages
+          );
+          return;
+        }
+      }
+      if (!firstUnreadMessageId) {
+        notifyJumpToFirstUnreadError();
+        return;
+      }
+      if (!channelUnreadUiState.first_unread_message_id)
+        _setChannelUnreadUiState({
+          ...channelUnreadUiState,
+          first_unread_message_id: firstUnreadMessageId,
+          last_read_message_id: lastReadMessageId
+        });
+      handleHighlightedMessageChange({
+        highlightDuration,
+        highlightedMessageId: firstUnreadMessageId
+      });
+    },
+    [
+      channel,
+      finishLoadMore,
+      handleHighlightedMessageChange,
+      notifyJumpToFirstUnreadError,
+      channelUnreadUiState
+    ]
+  );
+  const deleteMessage = useCallback(
+    async (message, options) => {
+      if (!message?.id) {
+        throw new Error("Cannot delete a message - missing message ID.");
+      }
+      let deletedMessage;
+      if (doDeleteMessageRequest) {
+        deletedMessage = await doDeleteMessageRequest(message, options);
+      } else {
+        const result = await client.deleteMessage(message.id, options);
+        deletedMessage = result.message;
+      }
+      return deletedMessage;
+    },
+    [client, doDeleteMessageRequest]
+  );
+  const updateMessage = (updatedMessage) => {
+    channel.state.addMessageSorted(updatedMessage, true);
+    dispatch({
+      channel,
+      parentId: state.thread && updatedMessage.parent_id,
+      type: "copyMessagesFromChannel"
+    });
+  };
+  const doSendMessage = async ({
+    localMessage,
+    message,
+    options
+  }) => {
+    try {
+      let messageResponse;
+      if (doSendMessageRequest) {
+        messageResponse = await doSendMessageRequest(channel, message, options);
+      } else {
+        messageResponse = await channel.sendMessage(message, options);
+      }
+      let existingMessage = void 0;
+      for (let i = channel.state.messages.length - 1; i >= 0; i--) {
+        const msg = channel.state.messages[i];
+        if (msg.id && msg.id === message.id) {
+          existingMessage = msg;
+          break;
+        }
+      }
+      const responseTimestamp = new Date(
+        messageResponse?.message?.updated_at || 0
+      ).getTime();
+      const existingMessageTimestamp = existingMessage?.updated_at?.getTime() || 0;
+      const responseIsTheNewest = responseTimestamp > existingMessageTimestamp;
+      if (messageResponse?.message && (responseIsTheNewest || existingMessage?.status === "sending")) {
+        updateMessage({
+          ...messageResponse.message,
+          status: "received"
+        });
+      }
+    } catch (error) {
+      const parsedError = adaptMessageSendErrorToErrorFromResponse(error);
+      if (parsedError.code === 4 && error instanceof Error && error.message.includes("already exists")) {
+        updateMessage({
+          ...localMessage,
+          status: "received"
+        });
+      } else {
+        updateMessage({
+          ...localMessage,
+          error: parsedError,
+          status: "failed"
+        });
+        thread?.upsertReplyLocally({
+          message: {
+            ...localMessage,
+            error: parsedError,
+            status: "failed"
+          }
+        });
+      }
+    }
+  };
+  const sendMessage = async ({
+    localMessage,
+    message,
+    options
+  }) => {
+    channel.state.filterErrorMessages();
+    thread?.upsertReplyLocally({
+      message: localMessage
+    });
+    updateMessage(localMessage);
+    await doSendMessage({ localMessage, message, options });
+  };
+  const retrySendMessage = async (localMessage) => {
+    const type = localMessage.type === "error" ? "regular" : localMessage.type;
+    updateMessage({
+      ...localMessage,
+      error: void 0,
+      status: "sending",
+      type
+    });
+    await doSendMessage({
+      localMessage,
+      message: localMessageToNewMessagePayload({ ...localMessage, type })
+    });
+  };
+  const removeMessage = (message) => {
+    channel.state.removeMessage(message);
+    dispatch({
+      channel,
+      parentId: state.thread && message.parent_id,
+      type: "copyMessagesFromChannel"
+    });
+  };
+  const openThread = (message, event) => {
+    event?.preventDefault();
+    dispatch({ channel, message, type: "openThread" });
+  };
+  const closeThread = (event) => {
+    event?.preventDefault();
+    dispatch({ type: "closeThread" });
+  };
+  const loadMoreThreadFinished = useCallback(
+    debounce(
+      (threadHasMore, threadMessages) => {
+        dispatch({
+          threadHasMore,
+          threadMessages,
+          type: "loadMoreThreadFinished"
+        });
+      },
+      2e3,
+      { leading: true, trailing: true }
+    ),
+    []
+  );
+  const loadMoreThread = async (limit = DEFAULT_THREAD_PAGE_SIZE) => {
+    if (state.threadLoadingMore || !state.thread || !state.threadHasMore) return;
+    dispatch({ type: "startLoadingThread" });
+    const parentId = state.thread.id;
+    if (!parentId) {
+      return dispatch({ type: "closeThread" });
+    }
+    const oldMessages = channel.state.threads[parentId] || [];
+    const oldestMessageId = oldMessages[0]?.id;
+    try {
+      const queryResponse = await channel.getReplies(parentId, {
+        id_lt: oldestMessageId,
+        limit
+      });
+      const threadHasMoreMessages = hasMoreMessagesProbably(
+        queryResponse.messages.length,
+        limit
+      );
+      const newThreadMessages = channel.state.threads[parentId] || [];
+      loadMoreThreadFinished(threadHasMoreMessages, newThreadMessages);
+    } catch (e) {
+      loadMoreThreadFinished(false, oldMessages);
+    }
+  };
+  const onMentionsHoverOrClick = useMentionsHandlers(onMentionsHover, onMentionsClick);
+  const editMessage = useEditMessageHandler(doUpdateMessageRequest);
+  const { typing, ...restState } = state;
+  const channelStateContextValue = useCreateChannelStateContext({
+    ...restState,
+    channel,
+    channelCapabilitiesArray,
+    channelConfig,
+    channelUnreadUiState,
+    giphyVersion: props.giphyVersion || "fixed_height",
+    imageAttachmentSizeHandler: props.imageAttachmentSizeHandler || getImageAttachmentConfiguration,
+    mutes,
+    notifications: [],
+    shouldGenerateVideoThumbnail: props.shouldGenerateVideoThumbnail || true,
+    videoAttachmentSizeHandler: props.videoAttachmentSizeHandler || getVideoAttachmentConfiguration,
+    watcher_count: state.watcherCount
+  });
+  const channelActionContextValue = useMemo(
+    () => ({
+      closeThread,
+      deleteMessage,
+      dispatch,
+      editMessage,
+      jumpToFirstUnreadMessage,
+      jumpToLatestMessage,
+      jumpToMessage,
+      loadMore,
+      loadMoreNewer,
+      loadMoreThread,
+      markRead,
+      onMentionsClick: onMentionsHoverOrClick,
+      onMentionsHover: onMentionsHoverOrClick,
+      openThread,
+      removeMessage,
+      retrySendMessage,
+      sendMessage,
+      setChannelUnreadUiState,
+      skipMessageDataMemoization,
+      updateMessage
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      channel.cid,
+      deleteMessage,
+      loadMore,
+      loadMoreNewer,
+      markRead,
+      jumpToFirstUnreadMessage,
+      jumpToMessage,
+      jumpToLatestMessage,
+      setChannelUnreadUiState
+    ]
+  );
+  const typingContextValue = useCreateTypingContext({
+    typing
+  });
+  if (state.error) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: /* @__PURE__ */ jsx(LoadingErrorIndicator$1, { error: state.error }) });
+  }
+  if (state.loading) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: /* @__PURE__ */ jsx(LoadingIndicator, {}) });
+  }
+  if (!channel.watch) {
+    return /* @__PURE__ */ jsx(ChannelContainer, { children: /* @__PURE__ */ jsx("div", { children: t("Channel Missing") }) });
+  }
+  return /* @__PURE__ */ jsx(ChannelContainer, { className: windowsEmojiClass, children: /* @__PURE__ */ jsx(ChannelStateProvider, { value: channelStateContextValue, children: /* @__PURE__ */ jsx(ChannelActionProvider, { value: channelActionContextValue, children: /* @__PURE__ */ jsx(TypingProvider, { value: typingContextValue, children: /* @__PURE__ */ jsx(WithAudioPlayback, { allowConcurrentPlayback: allowConcurrentAudioPlayback, children: /* @__PURE__ */ jsx("div", { className: clsx(chatContainerClass), children }) }) }) }) }) });
+};
+const Channel = React.memo(UnMemoizedChannel);
+const ThreadContext = createContext(void 0);
+const useThreadContext = () => useContext(ThreadContext);
+const ThreadProvider = ({
+  children,
+  thread
+}) => /* @__PURE__ */ jsx(ThreadContext.Provider, { value: thread, children: /* @__PURE__ */ jsx(Channel, { channel: thread?.channel, children }) });
+const UnreadCountBadge = ({
+  children,
+  count,
+  position
+}) => /* @__PURE__ */ jsxs("div", { className: "str-chat__unread-count-badge-container", children: [
+  children,
+  count > 0 && /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: clsx(
+        "str-chat__unread-count-badge",
+        position && `str-chat__unread-count-badge--${position}`
+      ),
+      children: count
+    }
+  )
+] });
+const ChatViewContext = createContext(void 0);
+const useChatViewContext = () => {
+  const value = useContext(ChatViewContext);
+  if (!value) {
+    console.warn(
+      "The useChatViewContext hook was called outside of the ChatView provider."
+    );
+    return {};
+  }
+  return value;
+};
+const ChatView = ({ children }) => {
+  const [activeChatView, setActiveChatView] = useState("channels");
+  const { theme } = useChatContext();
+  const value = useMemo(() => ({ activeChatView, setActiveChatView }), [activeChatView]);
+  return /* @__PURE__ */ jsx(ChatViewContext.Provider, { value, children: /* @__PURE__ */ jsx("div", { className: clsx("str-chat", theme, "str-chat__chat-view"), children }) });
+};
+const ChannelsView = ({ children }) => {
+  const { activeChatView } = useChatViewContext();
+  if (activeChatView !== "channels") return null;
+  return /* @__PURE__ */ jsx("div", { className: "str-chat__chat-view__channels", children });
+};
+const ThreadsViewContext = createContext({
+  activeThread: void 0,
+  setActiveThread: () => void 0
+});
+const useThreadsViewContext = () => useContext(ThreadsViewContext);
+const ThreadsView = ({ children }) => {
+  const { activeChatView } = useChatViewContext();
+  const [activeThread, setActiveThread] = useState(void 0);
+  const value = useMemo(() => ({ activeThread, setActiveThread }), [activeThread]);
+  if (activeChatView !== "threads") return null;
+  return /* @__PURE__ */ jsx(ThreadsViewContext.Provider, { value, children: /* @__PURE__ */ jsx("div", { className: "str-chat__chat-view__threads", children }) });
+};
+const useActiveThread = ({ activeThread }) => {
+  useEffect(() => {
+    if (!activeThread) return;
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === "visible" && document.hasFocus()) {
+        activeThread.activate();
+      }
+      if (document.visibilityState === "hidden" || !document.hasFocus()) {
+        activeThread.deactivate();
+      }
+    };
+    handleVisibilityChange();
+    window.addEventListener("focus", handleVisibilityChange);
+    window.addEventListener("blur", handleVisibilityChange);
+    return () => {
+      activeThread.deactivate();
+      window.addEventListener("blur", handleVisibilityChange);
+      window.removeEventListener("focus", handleVisibilityChange);
+    };
+  }, [activeThread]);
+};
+const ThreadAdapter = ({ children }) => {
+  const { client } = useChatContext("ThreadAdapter");
+  const { EmptyStateIndicator: EmptyStateIndicator$1 = EmptyStateIndicator } = useComponentContext();
+  const { activeThread } = useThreadsViewContext();
+  const { t } = useTranslationContext("ThreadAdapter");
+  const { isLoading, ready } = useStateStore(
+    client.threads.state,
+    threadAdapterSelector
+  ) ?? {
+    isLoading: false,
+    ready: false
+  };
+  useActiveThread({ activeThread });
+  if (!activeThread && ready && !isLoading && EmptyStateIndicator$1) {
+    return /* @__PURE__ */ jsx("div", { className: "str-chat__thread-container str-chat__thread", children: /* @__PURE__ */ jsx(
+      EmptyStateIndicator$1,
+      {
+        listType: "message",
+        messageText: t("Select a thread to continue the conversation")
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx(ThreadProvider, { thread: activeThread, children });
+};
+const ChatViewSelectorButton = ({
+  ActiveIcon,
+  children,
+  className,
+  Icon,
+  iconOnly = true,
+  isActive,
+  text,
+  ...props
+}) => {
+  const SelectorIcon = isActive && ActiveIcon ? ActiveIcon : Icon;
+  const shouldShowTooltip = !!text && iconOnly;
+  return /* @__PURE__ */ jsxs("div", { className: "str-chat__chat-view__selector-button-container", children: [
+    /* @__PURE__ */ jsxs(
+      Button,
+      {
+        appearance: "ghost",
+        "aria-label": props["aria-label"] ?? (shouldShowTooltip ? text : void 0),
+        className: clsx("str-chat__chat-view__selector-button", className),
+        role: "tab",
+        variant: "secondary",
+        ...props,
+        children: [
+          children ?? (SelectorIcon && /* @__PURE__ */ jsx(SelectorIcon, {})),
+          !iconOnly && text && /* @__PURE__ */ jsx("div", { className: "str-chat__chat-view__selector-button-text", children: text })
+        ]
+      }
+    ),
+    shouldShowTooltip && /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-hidden": "true",
+        className: "str-chat__chat-view__selector-button-tooltip str-chat__tooltip",
+        children: text
+      }
+    )
+  ] });
+};
+const threadAdapterSelector = ({ pagination, ready }) => ({
+  isLoading: pagination.isLoading,
+  ready
+});
+const unreadThreadCountSelector = ({ unreadThreadCount }) => ({
+  unreadThreadCount
+});
+const ChatViewChannelsSelectorButton = ({
+  iconOnly = true
+}) => {
+  const { activeChatView, setActiveChatView } = useChatViewContext();
+  const { openMobileNav } = useChatContext("ChatViewChannelsSelectorButton");
+  const { t } = useTranslationContext();
+  const isActive = activeChatView === "channels";
+  return /* @__PURE__ */ jsx(
+    ChatViewSelectorButton,
+    {
+      ActiveIcon: IconMessageBubbleFill,
+      "aria-selected": isActive,
+      Icon: IconMessageBubble,
+      iconOnly,
+      isActive,
+      onPointerDown: () => {
+        openMobileNav();
+        setActiveChatView("channels");
+      },
+      text: t("Channels")
+    }
+  );
+};
+const ChatViewThreadsSelectorButton = ({
+  iconOnly = true
+}) => {
+  const { client, openMobileNav } = useChatContext();
+  const { unreadThreadCount } = useStateStore(
+    client.threads.state,
+    unreadThreadCountSelector
+  ) ?? {
+    unreadThreadCount: 0
+  };
+  const { activeChatView, setActiveChatView } = useChatViewContext();
+  const { t } = useTranslationContext();
+  const isActive = activeChatView === "threads";
+  return /* @__PURE__ */ jsx(
+    ChatViewSelectorButton,
+    {
+      ActiveIcon: IconBubbleText6SolidChatMessage,
+      "aria-selected": isActive,
+      Icon: IconThread,
+      iconOnly,
+      isActive,
+      onPointerDown: () => {
+        openMobileNav();
+        setActiveChatView("threads");
+      },
+      text: t("Threads"),
+      children: /* @__PURE__ */ jsx(UnreadCountBadge, { count: unreadThreadCount, position: "top-right", children: isActive ? /* @__PURE__ */ jsx(IconBubbleText6SolidChatMessage, {}) : /* @__PURE__ */ jsx(IconThread, {}) })
+    }
+  );
+};
+const defaultChatViewSelectorItemSet = [
+  {
+    Component: ChatViewChannelsSelectorButton,
+    type: "channels"
+  },
+  {
+    Component: ChatViewThreadsSelectorButton,
+    type: "threads"
+  }
+];
+const ChatViewSelector = ({
+  iconOnly = true,
+  itemSet = defaultChatViewSelectorItemSet
+}) => {
+  const { navOpen } = useChatContext("ChatView.Selector");
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: clsx("str-chat__chat-view__selector", {
+        "str-chat__chat-view__selector--nav-closed": navOpen === false,
+        "str-chat__chat-view__selector--nav-open": navOpen === true
+      }),
+      children: itemSet.map(({ Component, type }) => /* @__PURE__ */ jsx(Component, { iconOnly }, type))
+    }
+  );
+};
+ChatView.Channels = ChannelsView;
+ChatView.Threads = ThreadsView;
+ChatView.ThreadAdapter = ThreadAdapter;
+ChatView.Selector = ChatViewSelector;
+const useNotificationTarget = () => {
+  const chatViewContext = useContext(ChatViewContext);
+  const { channels } = useChannelListContext();
+  const { channel } = useChannelStateContext();
+  const threadInstance = useThreadContext();
+  const { legacyThread } = useLegacyThreadContext();
+  if (threadInstance || legacyThread) return "thread";
+  if (channel) return "channel";
+  if (chatViewContext?.activeChatView === "threads") return "thread-list";
+  if (channels) return "channel-list";
+  return void 0;
+};
+const AudioPlayerContext = React.createContext({
+  audioPlayers: null
+});
+const WithAudioPlayback = ({
+  allowConcurrentPlayback,
+  children
+}) => {
+  const [audioPlayers] = useState(() => new AudioPlayerPool({ allowConcurrentPlayback }));
+  useEffect(
+    () => () => {
+      audioPlayers.clear();
+    },
+    [audioPlayers]
+  );
+  return /* @__PURE__ */ jsx(AudioPlayerContext.Provider, { value: { audioPlayers }, children });
+};
+const makeAudioPlayerId = ({ requester, src }) => `${requester ?? "requester-unknown"}:${src}`;
+const useAudioPlayer = ({
+  durationSeconds,
+  fileSize,
+  mimeType,
+  playbackRates,
+  plugins,
+  requester = "",
+  src,
+  title,
+  waveformData
+}) => {
+  const { client } = useChatContext();
+  const panel = useNotificationTarget();
+  const { t } = useTranslationContext();
+  const { audioPlayers } = useContext(AudioPlayerContext);
+  const audioPlayer = src && audioPlayers ? audioPlayers.getOrAdd({
+    durationSeconds,
+    fileSize,
+    id: makeAudioPlayerId({ requester, src }),
+    mimeType,
+    playbackRates,
+    plugins,
+    src,
+    title,
+    waveformData
+  }) : void 0;
+  useEffect(() => {
+    if (!audioPlayer) return;
+    const notificationsPlugin = audioPlayerNotificationsPluginFactory({
+      client,
+      panel,
+      t
+    });
+    audioPlayer.setPlugins((currentPlugins) => [
+      ...currentPlugins.filter((plugin) => plugin.id !== notificationsPlugin.id),
+      notificationsPlugin
+    ]);
+  }, [audioPlayer, client, panel, t]);
+  return audioPlayer;
+};
+const activeAudioPlayerSelector = ({ activeAudioPlayer }) => ({
+  activeAudioPlayer
+});
+const useActiveAudioPlayer = () => {
+  const { audioPlayers } = useContext(AudioPlayerContext);
+  const { activeAudioPlayer } = useStateStore(audioPlayers?.state, activeAudioPlayerSelector) ?? {};
+  return activeAudioPlayer;
+};
+export {
+  IconImage as $,
+  IconChevronLeft as A,
+  BaseIcon as B,
+  ComponentContext as C,
+  IconArrowLeft as D,
+  IconExclamationMark as E,
+  IconNoSign as F,
+  isMessageErrorRetryable as G,
+  ACTIONS_NOT_WORKING_IN_THREAD as H,
+  IconPauseFill as I,
+  useNotificationTarget as J,
+  IconArrowUpRight as K,
+  LocalizedFormat as L,
+  addNotificationTargetTag as M,
+  IconPin as N,
+  mapToUserNameOrId as O,
+  IconClock as P,
+  IconCheckmark1Small as Q,
+  IconChecks as R,
+  getReadByTooltipText as S,
+  messageHasAttachments as T,
+  messageTextHasEmojisOnly as U,
+  isDate as V,
+  getDateString as W,
+  IconTranslate as X,
+  useMessageComposerContext as Y,
+  useIsCooldownActive as Z,
+  IconCrossSmall as _,
+  useMessageComposerController as a,
+  processMessages as a$,
+  IconPoll as a0,
+  IconLocation as a1,
+  IconFile as a2,
+  IconLink as a3,
+  IconVideo as a4,
+  IconVideoFill as a5,
+  IconVoice as a6,
+  IconSave as a7,
+  IconBell as a8,
+  IconChevronDown as a9,
+  isLanguageSupported as aA,
+  IconLayoutAlignLeft as aB,
+  useChatViewContext as aC,
+  MESSAGE_ACTIONS as aD,
+  LegacyThreadContext as aE,
+  IconReply as aF,
+  IconEmoji as aG,
+  IconMore as aH,
+  IconUserCheck as aI,
+  IconUnsave as aJ,
+  IconBellOff as aK,
+  IconNotification as aL,
+  IconEdit as aM,
+  IconCopy as aN,
+  IconUnpin as aO,
+  IconQuote as aP,
+  IconThread as aQ,
+  areMessageUIPropsEqual as aR,
+  isDateSeparatorMessage as aS,
+  isMessageBlocked as aT,
+  messageHasSingleAttachment as aU,
+  messageHasGiphyAttachment as aV,
+  messageHasReactions as aW,
+  isMessageEdited as aX,
+  countEmojis as aY,
+  areMessagePropsEqual as aZ,
+  getMessageActions as a_,
+  IconPlusSmall as aa,
+  IconCheckmark as ab,
+  DEFAULT_LOAD_PAGE_SCROLL_THRESHOLD as ac,
+  IconTrophy as ad,
+  IconReorder as ae,
+  IconMinusCircle as af,
+  IconSend as ag,
+  IconAudio as ah,
+  IconUserAdd as ai,
+  IconMute as aj,
+  IconFlag as ak,
+  IconUserRemove as al,
+  IconAttachment as am,
+  IconCommand as an,
+  CHANNEL_CONTAINER_ID as ao,
+  IconPlus as ap,
+  IconExclamationTriangle as aq,
+  useAudioPlayer as ar,
+  IconRetry as as,
+  IconArrowDownCircle as at,
+  IconThunder as au,
+  IconDelete as av,
+  IconUpload as aw,
+  MessageComposerContextProvider as ax,
+  useTypingContext as ay,
+  defaultDateTimeParser as az,
+  useChannelActionContext as b,
+  isNotificationTargetPanel as b$,
+  insertIntro as b0,
+  getGroupStyles as b1,
+  getLastReceived as b2,
+  IconArrowUp as b3,
+  isIntroMessage as b4,
+  isLocalMessage as b5,
+  getIsFirstUnreadMessage as b6,
+  IconArrowDown as b7,
+  DEFAULT_NEXT_CHANNEL_PAGE_SIZE as b8,
+  EmptyStateIndicator as b9,
+  useActiveThread as bA,
+  ChatViewSelectorButton as bB,
+  ChatViewChannelsSelectorButton as bC,
+  ChatViewThreadsSelectorButton as bD,
+  defaultChatViewSelectorItemSet as bE,
+  createIcon as bF,
+  IconArrowRight as bG,
+  IconMessageBubble as bH,
+  IconMessageBubbleFill as bI,
+  IconBubble3ChatMessage as bJ,
+  IconBubbleText6SolidChatMessage as bK,
+  IconThreadFill as bL,
+  IconInfo as bM,
+  IconLightBulbSimple as bN,
+  IconVoiceFill as bO,
+  IconMinus as bP,
+  IconMinusSmall as bQ,
+  IconSettingsGear2 as bR,
+  LoadingChannel as bS,
+  LoadingErrorIndicator as bT,
+  OPTIONAL_MESSAGE_ACTIONS as bU,
+  getImages as bV,
+  getNonImageAttachments as bW,
+  makeIntroMessage as bX,
+  makeDateMessageId as bY,
+  hasMoreMessagesProbably as bZ,
+  hasNotMoreMessages as b_,
+  getChannel as ba,
+  IconSearch as bb,
+  IconXCircle as bc,
+  useChannelListContext as bd,
+  DEFAULT_JUMP_TO_PAGE_SIZE as be,
+  ChannelListContextProvider as bf,
+  IconArchive as bg,
+  IconLeave as bh,
+  IconCamera as bi,
+  IconExclamationCircleFill as bj,
+  ChatProvider as bk,
+  TranslationProvider as bl,
+  useThreadsViewContext as bm,
+  IconMessageBubbles as bn,
+  IconRefresh as bo,
+  IconEyeOpen as bp,
+  useActiveAudioPlayer as bq,
+  WithAudioPlayback as br,
+  defaultRegisterAudioPlayerError as bs,
+  elementIsPlaying as bt,
+  AudioPlayer as bu,
+  useEditMessageHandler as bv,
+  useMentionsHandlers as bw,
+  Channel as bx,
+  ChatViewContext as by,
+  ChatView as bz,
+  useTranslationContext as c,
+  getNotificationTargetPanel as c0,
+  getNotificationTargetTag as c1,
+  useLegacyThreadContext as c2,
+  ThreadContext as c3,
+  ThreadProvider as c4,
+  ChannelActionContext as c5,
+  ChannelActionProvider as c6,
+  ChannelListContext as c7,
+  ChannelStateContext as c8,
+  ChannelStateProvider as c9,
+  ChatContext as ca,
+  ComponentProvider as cb,
+  MessageComposerContext as cc,
+  TranslationContext as cd,
+  TypingContext as ce,
+  TypingProvider as cf,
+  isDayOrMoment as cg,
+  isNumberOrString as ch,
+  useChannelStateContext as d,
+  useChatContext as e,
+  isNotificationForPanel as f,
+  Button as g,
+  IconPlayFill as h,
+  isMessageBounced as i,
+  getDefaultExportFromCjs as j,
+  defaultTranslatorFunction as k,
+  calendar as l,
+  IconLoading as m,
+  isNetworkSendFailure as n,
+  isUserMuted as o,
+  predefinedFormatters as p,
+  defaultPinPermissions as q,
+  useThreadContext as r,
+  usePopoverPosition as s,
+  useComponentContext as t,
+  useStateStore as u,
+  validateAndGetMessage as v,
+  IconXmark as w,
+  IconUser as x,
+  IconExclamationMarkFill as y,
+  IconChevronRight as z
+};
+//# sourceMappingURL=WithAudioPlayback.89700cb5.mjs.map