@blocklet/discuss-kit-ux 1.6.243 → 1.6.244

package/dist/{index-Cy-AzaWZ.mjs → index-C30pyzPN.mjs}

@@ -9,10 +9,11 @@ import { Labels2, LabelPicker } from "@blocklet/labels";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { useTheme, ThemeProvider, styled } from "@mui/material/styles";
 import { create as create$1, styled as styled$1 } from "@arcblock/ux/lib/Theme";
-import { useEffect, useRef, lazy, useState, createElement, useContext, useMemo, isValidElement, Suspense, createContext, Fragment as Fragment$1, forwardRef, useCallback } from "react";
+import require$$0, { useEffect, useRef, useState, createElement, useContext, useMemo, isValidElement, lazy, Suspense, createContext, Fragment as Fragment$1, forwardRef, useCallback } from "react";
 import { Box, useTheme as useTheme$1, useMediaQuery, Tooltip as Tooltip$1, Chip as Chip$1, alpha, ClickAwayListener, Dialog as Dialog$1, DialogTitle, DialogContent, DialogActions, DialogContentText, Button as Button$1, Divider, Skeleton, IconButton as IconButton$2, InputBase, tooltipClasses as tooltipClasses$1, Backdrop, Autocomplete, Typography as Typography$1, TextField as TextField$1, InputAdornment, Badge as Badge$1, Paper, ToggleButtonGroup, ToggleButton } from "@mui/material";
 import isNil from "lodash/isNil";
 import { useEditorConfig, EditorConfigProvider } from "@blocklet/editor/lib/config";
+import { lazyWithPreload } from "react-lazy-with-preload";
 import { $getRoot, $createParagraphNode, $createTextNode, KEY_ENTER_COMMAND, COMMAND_PRIORITY_LOW, $getSelection } from "lexical";
 import { $isRootTextContentEmpty } from "@lexical/text";
 import joinUrl from "url-join";
@@ -65,6 +66,7 @@ import CircularProgress from "@mui/material/CircularProgress";
 import { Helmet } from "react-helmet";
 import { Flipper, Flipped } from "react-flip-toolkit";
 import grey$1 from "@mui/material/colors/grey";
+import cmp from "semver-compare";
 import bridge from "@arcblock/bridge";
 import Fab from "@mui/material/Fab";
 import debounce from "lodash/debounce";
@@ -535,7 +537,8 @@ const useMeasure = () => {
   const size = useSize(ref);
   return [ref, size || { width: 0, height: 0 }];
 };
-const BlockletEditor$2 = lazy(() => import("@blocklet/editor"));
+const BlockletEditor$2 = lazyWithPreload(() => import("@blocklet/editor"));
+const preloadInput = () => BlockletEditor$2.preload();
 const Input = ({
   initialContent = "",
   send,
@@ -3913,9 +3916,915 @@ function ChannelGroup({ size = "normal", chat, children, ...rest }) {
     ] })
   ] });
 }
+function getAugmentedNamespace(n) {
+  if (n.__esModule)
+    return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      if (this instanceof a2) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else
+    a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+var lib = {};
+var useInterval$1 = {};
+Object.defineProperty(useInterval$1, "__esModule", {
+  value: true
+});
+useInterval$1.default = useInterval;
+var _react$2 = require$$0;
+function useInterval(callback, delay) {
+  const savedCallback = (0, _react$2.useRef)();
+  (0, _react$2.useEffect)(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  (0, _react$2.useEffect)(() => {
+    function tick() {
+      savedCallback.current();
+    }
+    if (delay !== null) {
+      const id2 = setInterval(tick, delay);
+      return () => clearInterval(id2);
+    }
+  }, [delay]);
+}
+var useStorage$1 = {};
+const privateData = /* @__PURE__ */ new WeakMap();
+const wrappers = /* @__PURE__ */ new WeakMap();
+function pd(event) {
+  const retv = privateData.get(event);
+  console.assert(
+    retv != null,
+    "'this' is expected an Event object, but got",
+    event
+  );
+  return retv;
+}
+function setCancelFlag(data) {
+  if (data.passiveListener != null) {
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(
+        "Unable to preventDefault inside passive event listener invocation.",
+        data.passiveListener
+      );
+    }
+    return;
+  }
+  if (!data.event.cancelable) {
+    return;
+  }
+  data.canceled = true;
+  if (typeof data.event.preventDefault === "function") {
+    data.event.preventDefault();
+  }
+}
+function Event(eventTarget, event) {
+  privateData.set(this, {
+    eventTarget,
+    event,
+    eventPhase: 2,
+    currentTarget: eventTarget,
+    canceled: false,
+    stopped: false,
+    immediateStopped: false,
+    passiveListener: null,
+    timeStamp: event.timeStamp || Date.now()
+  });
+  Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+  const keys = Object.keys(event);
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    if (!(key in this)) {
+      Object.defineProperty(this, key, defineRedirectDescriptor(key));
+    }
+  }
+}
+Event.prototype = {
+  /**
+   * The type of this event.
+   * @type {string}
+   */
+  get type() {
+    return pd(this).event.type;
+  },
+  /**
+   * The target of this event.
+   * @type {EventTarget}
+   */
+  get target() {
+    return pd(this).eventTarget;
+  },
+  /**
+   * The target of this event.
+   * @type {EventTarget}
+   */
+  get currentTarget() {
+    return pd(this).currentTarget;
+  },
+  /**
+   * @returns {EventTarget[]} The composed path of this event.
+   */
+  composedPath() {
+    const currentTarget = pd(this).currentTarget;
+    if (currentTarget == null) {
+      return [];
+    }
+    return [currentTarget];
+  },
+  /**
+   * Constant of NONE.
+   * @type {number}
+   */
+  get NONE() {
+    return 0;
+  },
+  /**
+   * Constant of CAPTURING_PHASE.
+   * @type {number}
+   */
+  get CAPTURING_PHASE() {
+    return 1;
+  },
+  /**
+   * Constant of AT_TARGET.
+   * @type {number}
+   */
+  get AT_TARGET() {
+    return 2;
+  },
+  /**
+   * Constant of BUBBLING_PHASE.
+   * @type {number}
+   */
+  get BUBBLING_PHASE() {
+    return 3;
+  },
+  /**
+   * The target of this event.
+   * @type {number}
+   */
+  get eventPhase() {
+    return pd(this).eventPhase;
+  },
+  /**
+   * Stop event bubbling.
+   * @returns {void}
+   */
+  stopPropagation() {
+    const data = pd(this);
+    data.stopped = true;
+    if (typeof data.event.stopPropagation === "function") {
+      data.event.stopPropagation();
+    }
+  },
+  /**
+   * Stop event bubbling.
+   * @returns {void}
+   */
+  stopImmediatePropagation() {
+    const data = pd(this);
+    data.stopped = true;
+    data.immediateStopped = true;
+    if (typeof data.event.stopImmediatePropagation === "function") {
+      data.event.stopImmediatePropagation();
+    }
+  },
+  /**
+   * The flag to be bubbling.
+   * @type {boolean}
+   */
+  get bubbles() {
+    return Boolean(pd(this).event.bubbles);
+  },
+  /**
+   * The flag to be cancelable.
+   * @type {boolean}
+   */
+  get cancelable() {
+    return Boolean(pd(this).event.cancelable);
+  },
+  /**
+   * Cancel this event.
+   * @returns {void}
+   */
+  preventDefault() {
+    setCancelFlag(pd(this));
+  },
+  /**
+   * The flag to indicate cancellation state.
+   * @type {boolean}
+   */
+  get defaultPrevented() {
+    return pd(this).canceled;
+  },
+  /**
+   * The flag to be composed.
+   * @type {boolean}
+   */
+  get composed() {
+    return Boolean(pd(this).event.composed);
+  },
+  /**
+   * The unix time of this event.
+   * @type {number}
+   */
+  get timeStamp() {
+    return pd(this).timeStamp;
+  },
+  /**
+   * The target of this event.
+   * @type {EventTarget}
+   * @deprecated
+   */
+  get srcElement() {
+    return pd(this).eventTarget;
+  },
+  /**
+   * The flag to stop event bubbling.
+   * @type {boolean}
+   * @deprecated
+   */
+  get cancelBubble() {
+    return pd(this).stopped;
+  },
+  set cancelBubble(value) {
+    if (!value) {
+      return;
+    }
+    const data = pd(this);
+    data.stopped = true;
+    if (typeof data.event.cancelBubble === "boolean") {
+      data.event.cancelBubble = true;
+    }
+  },
+  /**
+   * The flag to indicate cancellation state.
+   * @type {boolean}
+   * @deprecated
+   */
+  get returnValue() {
+    return !pd(this).canceled;
+  },
+  set returnValue(value) {
+    if (!value) {
+      setCancelFlag(pd(this));
+    }
+  },
+  /**
+   * Initialize this event object. But do nothing under event dispatching.
+   * @param {string} type The event type.
+   * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
+   * @param {boolean} [cancelable=false] The flag to be possible to cancel.
+   * @deprecated
+   */
+  initEvent() {
+  }
+};
+Object.defineProperty(Event.prototype, "constructor", {
+  value: Event,
+  configurable: true,
+  writable: true
+});
+if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
+  Object.setPrototypeOf(Event.prototype, window.Event.prototype);
+  wrappers.set(window.Event.prototype, Event);
+}
+function defineRedirectDescriptor(key) {
+  return {
+    get() {
+      return pd(this).event[key];
+    },
+    set(value) {
+      pd(this).event[key] = value;
+    },
+    configurable: true,
+    enumerable: true
+  };
+}
+function defineCallDescriptor(key) {
+  return {
+    value() {
+      const event = pd(this).event;
+      return event[key].apply(event, arguments);
+    },
+    configurable: true,
+    enumerable: true
+  };
+}
+function defineWrapper(BaseEvent, proto) {
+  const keys = Object.keys(proto);
+  if (keys.length === 0) {
+    return BaseEvent;
+  }
+  function CustomEvent2(eventTarget, event) {
+    BaseEvent.call(this, eventTarget, event);
+  }
+  CustomEvent2.prototype = Object.create(BaseEvent.prototype, {
+    constructor: { value: CustomEvent2, configurable: true, writable: true }
+  });
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    if (!(key in BaseEvent.prototype)) {
+      const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+      const isFunc = typeof descriptor.value === "function";
+      Object.defineProperty(
+        CustomEvent2.prototype,
+        key,
+        isFunc ? defineCallDescriptor(key) : defineRedirectDescriptor(key)
+      );
+    }
+  }
+  return CustomEvent2;
+}
+function getWrapper(proto) {
+  if (proto == null || proto === Object.prototype) {
+    return Event;
+  }
+  let wrapper = wrappers.get(proto);
+  if (wrapper == null) {
+    wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
+    wrappers.set(proto, wrapper);
+  }
+  return wrapper;
+}
+function wrapEvent(eventTarget, event) {
+  const Wrapper = getWrapper(Object.getPrototypeOf(event));
+  return new Wrapper(eventTarget, event);
+}
+function isStopped(event) {
+  return pd(event).immediateStopped;
+}
+function setEventPhase(event, eventPhase) {
+  pd(event).eventPhase = eventPhase;
+}
+function setCurrentTarget(event, currentTarget) {
+  pd(event).currentTarget = currentTarget;
+}
+function setPassiveListener(event, passiveListener) {
+  pd(event).passiveListener = passiveListener;
+}
+const listenersMap = /* @__PURE__ */ new WeakMap();
+const CAPTURE = 1;
+const BUBBLE = 2;
+const ATTRIBUTE = 3;
+function isObject(x) {
+  return x !== null && typeof x === "object";
+}
+function getListeners(eventTarget) {
+  const listeners = listenersMap.get(eventTarget);
+  if (listeners == null) {
+    throw new TypeError(
+      "'this' is expected an EventTarget object, but got another value."
+    );
+  }
+  return listeners;
+}
+function defineEventAttributeDescriptor(eventName) {
+  return {
+    get() {
+      const listeners = getListeners(this);
+      let node = listeners.get(eventName);
+      while (node != null) {
+        if (node.listenerType === ATTRIBUTE) {
+          return node.listener;
+        }
+        node = node.next;
+      }
+      return null;
+    },
+    set(listener) {
+      if (typeof listener !== "function" && !isObject(listener)) {
+        listener = null;
+      }
+      const listeners = getListeners(this);
+      let prev = null;
+      let node = listeners.get(eventName);
+      while (node != null) {
+        if (node.listenerType === ATTRIBUTE) {
+          if (prev !== null) {
+            prev.next = node.next;
+          } else if (node.next !== null) {
+            listeners.set(eventName, node.next);
+          } else {
+            listeners.delete(eventName);
+          }
+        } else {
+          prev = node;
+        }
+        node = node.next;
+      }
+      if (listener !== null) {
+        const newNode = {
+          listener,
+          listenerType: ATTRIBUTE,
+          passive: false,
+          once: false,
+          next: null
+        };
+        if (prev === null) {
+          listeners.set(eventName, newNode);
+        } else {
+          prev.next = newNode;
+        }
+      }
+    },
+    configurable: true,
+    enumerable: true
+  };
+}
+function defineEventAttribute(eventTargetPrototype, eventName) {
+  Object.defineProperty(
+    eventTargetPrototype,
+    `on${eventName}`,
+    defineEventAttributeDescriptor(eventName)
+  );
+}
+function defineCustomEventTarget(eventNames) {
+  function CustomEventTarget() {
+    EventTarget.call(this);
+  }
+  CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
+    constructor: {
+      value: CustomEventTarget,
+      configurable: true,
+      writable: true
+    }
+  });
+  for (let i = 0; i < eventNames.length; ++i) {
+    defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
+  }
+  return CustomEventTarget;
+}
+function EventTarget() {
+  if (this instanceof EventTarget) {
+    listenersMap.set(this, /* @__PURE__ */ new Map());
+    return;
+  }
+  if (arguments.length === 1 && Array.isArray(arguments[0])) {
+    return defineCustomEventTarget(arguments[0]);
+  }
+  if (arguments.length > 0) {
+    const types = new Array(arguments.length);
+    for (let i = 0; i < arguments.length; ++i) {
+      types[i] = arguments[i];
+    }
+    return defineCustomEventTarget(types);
+  }
+  throw new TypeError("Cannot call a class as a function");
+}
+EventTarget.prototype = {
+  /**
+   * Add a given listener to this event target.
+   * @param {string} eventName The event name to add.
+   * @param {Function} listener The listener to add.
+   * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+   * @returns {void}
+   */
+  addEventListener(eventName, listener, options) {
+    if (listener == null) {
+      return;
+    }
+    if (typeof listener !== "function" && !isObject(listener)) {
+      throw new TypeError("'listener' should be a function or an object.");
+    }
+    const listeners = getListeners(this);
+    const optionsIsObj = isObject(options);
+    const capture = optionsIsObj ? Boolean(options.capture) : Boolean(options);
+    const listenerType = capture ? CAPTURE : BUBBLE;
+    const newNode = {
+      listener,
+      listenerType,
+      passive: optionsIsObj && Boolean(options.passive),
+      once: optionsIsObj && Boolean(options.once),
+      next: null
+    };
+    let node = listeners.get(eventName);
+    if (node === void 0) {
+      listeners.set(eventName, newNode);
+      return;
+    }
+    let prev = null;
+    while (node != null) {
+      if (node.listener === listener && node.listenerType === listenerType) {
+        return;
+      }
+      prev = node;
+      node = node.next;
+    }
+    prev.next = newNode;
+  },
+  /**
+   * Remove a given listener from this event target.
+   * @param {string} eventName The event name to remove.
+   * @param {Function} listener The listener to remove.
+   * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+   * @returns {void}
+   */
+  removeEventListener(eventName, listener, options) {
+    if (listener == null) {
+      return;
+    }
+    const listeners = getListeners(this);
+    const capture = isObject(options) ? Boolean(options.capture) : Boolean(options);
+    const listenerType = capture ? CAPTURE : BUBBLE;
+    let prev = null;
+    let node = listeners.get(eventName);
+    while (node != null) {
+      if (node.listener === listener && node.listenerType === listenerType) {
+        if (prev !== null) {
+          prev.next = node.next;
+        } else if (node.next !== null) {
+          listeners.set(eventName, node.next);
+        } else {
+          listeners.delete(eventName);
+        }
+        return;
+      }
+      prev = node;
+      node = node.next;
+    }
+  },
+  /**
+   * Dispatch a given event.
+   * @param {Event|{type:string}} event The event to dispatch.
+   * @returns {boolean} `false` if canceled.
+   */
+  dispatchEvent(event) {
+    if (event == null || typeof event.type !== "string") {
+      throw new TypeError('"event.type" should be a string.');
+    }
+    const listeners = getListeners(this);
+    const eventName = event.type;
+    let node = listeners.get(eventName);
+    if (node == null) {
+      return true;
+    }
+    const wrappedEvent = wrapEvent(this, event);
+    let prev = null;
+    while (node != null) {
+      if (node.once) {
+        if (prev !== null) {
+          prev.next = node.next;
+        } else if (node.next !== null) {
+          listeners.set(eventName, node.next);
+        } else {
+          listeners.delete(eventName);
+        }
+      } else {
+        prev = node;
+      }
+      setPassiveListener(
+        wrappedEvent,
+        node.passive ? node.listener : null
+      );
+      if (typeof node.listener === "function") {
+        try {
+          node.listener.call(this, wrappedEvent);
+        } catch (err) {
+          if (typeof console !== "undefined" && typeof console.error === "function") {
+            console.error(err);
+          }
+        }
+      } else if (node.listenerType !== ATTRIBUTE && typeof node.listener.handleEvent === "function") {
+        node.listener.handleEvent(wrappedEvent);
+      }
+      if (isStopped(wrappedEvent)) {
+        break;
+      }
+      node = node.next;
+    }
+    setPassiveListener(wrappedEvent, null);
+    setEventPhase(wrappedEvent, 0);
+    setCurrentTarget(wrappedEvent, null);
+    return !wrappedEvent.defaultPrevented;
+  }
+};
+Object.defineProperty(EventTarget.prototype, "constructor", {
+  value: EventTarget,
+  configurable: true,
+  writable: true
+});
+if (typeof window !== "undefined" && typeof window.EventTarget !== "undefined") {
+  Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
+}
+const eventTargetShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EventTarget,
+  default: EventTarget,
+  defineEventAttribute
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$1$1 = /* @__PURE__ */ getAugmentedNamespace(eventTargetShim);
+Object.defineProperty(useStorage$1, "__esModule", {
+  value: true
+});
+useStorage$1.default = useStorage;
+var _react$1 = require$$0;
+var _eventTargetShim = require$$1$1;
+const evtTarget = new _eventTargetShim.EventTarget();
+function useStorage(storage, keyPrefix) {
+  return (key, defaultValue) => {
+    const storeKey = "".concat(keyPrefix, ".").concat(key);
+    const raw = storage.getItem(storeKey);
+    const [value, setValue] = (0, _react$1.useState)(raw ? JSON.parse(raw) : defaultValue);
+    const updater = (updatedValue) => {
+      setValue(updatedValue);
+      storage.setItem(storeKey, JSON.stringify(updatedValue));
+      evtTarget.dispatchEvent(new CustomEvent("storage_change", {
+        detail: {
+          key
+        }
+      }));
+    };
+    if (defaultValue != null && !raw) {
+      updater(defaultValue);
+    }
+    (0, _react$1.useEffect)(() => {
+      const listener = (_ref) => {
+        let {
+          detail
+        } = _ref;
+        if (detail.key === key) {
+          const _raw = storage.getItem(storeKey);
+          if (_raw !== raw) {
+            setValue(JSON.parse(_raw));
+          }
+        }
+      };
+      evtTarget.addEventListener("storage_change", listener);
+      return () => evtTarget.removeEventListener("storage_change", listener);
+    });
+    return [value, updater];
+  };
+}
+var useBrowser$1 = {};
+var appleIphone = /iPhone/i;
+var appleIpod = /iPod/i;
+var appleTablet = /iPad/i;
+var appleUniversal = /\biOS-universal(?:.+)Mac\b/i;
+var androidPhone = /\bAndroid(?:.+)Mobile\b/i;
+var androidTablet = /Android/i;
+var amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i;
+var amazonTablet = /Silk/i;
+var windowsPhone = /Windows Phone/i;
+var windowsTablet = /\bWindows(?:.+)ARM\b/i;
+var otherBlackBerry = /BlackBerry/i;
+var otherBlackBerry10 = /BB10/i;
+var otherOpera = /Opera Mini/i;
+var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
+var otherFirefox = /Mobile(?:.+)Firefox\b/i;
+var isAppleTabletOnIos13 = function(navigator2) {
+  return typeof navigator2 !== "undefined" && navigator2.platform === "MacIntel" && typeof navigator2.maxTouchPoints === "number" && navigator2.maxTouchPoints > 1 && typeof MSStream === "undefined";
+};
+function createMatch(userAgent) {
+  return function(regex) {
+    return regex.test(userAgent);
+  };
+}
+function isMobile(param) {
+  var nav = {
+    userAgent: "",
+    platform: "",
+    maxTouchPoints: 0
+  };
+  if (!param && typeof navigator !== "undefined") {
+    nav = {
+      userAgent: navigator.userAgent,
+      platform: navigator.platform,
+      maxTouchPoints: navigator.maxTouchPoints || 0
+    };
+  } else if (typeof param === "string") {
+    nav.userAgent = param;
+  } else if (param && param.userAgent) {
+    nav = {
+      userAgent: param.userAgent,
+      platform: param.platform,
+      maxTouchPoints: param.maxTouchPoints || 0
+    };
+  }
+  var userAgent = nav.userAgent;
+  var tmp = userAgent.split("[FBAN");
+  if (typeof tmp[1] !== "undefined") {
+    userAgent = tmp[0];
+  }
+  tmp = userAgent.split("Twitter");
+  if (typeof tmp[1] !== "undefined") {
+    userAgent = tmp[0];
+  }
+  var match = createMatch(userAgent);
+  var result = {
+    apple: {
+      phone: match(appleIphone) && !match(windowsPhone),
+      ipod: match(appleIpod),
+      tablet: !match(appleIphone) && (match(appleTablet) || isAppleTabletOnIos13(nav)) && !match(windowsPhone),
+      universal: match(appleUniversal),
+      device: (match(appleIphone) || match(appleIpod) || match(appleTablet) || match(appleUniversal) || isAppleTabletOnIos13(nav)) && !match(windowsPhone)
+    },
+    amazon: {
+      phone: match(amazonPhone),
+      tablet: !match(amazonPhone) && match(amazonTablet),
+      device: match(amazonPhone) || match(amazonTablet)
+    },
+    android: {
+      phone: !match(windowsPhone) && match(amazonPhone) || !match(windowsPhone) && match(androidPhone),
+      tablet: !match(windowsPhone) && !match(amazonPhone) && !match(androidPhone) && (match(amazonTablet) || match(androidTablet)),
+      device: !match(windowsPhone) && (match(amazonPhone) || match(amazonTablet) || match(androidPhone) || match(androidTablet)) || match(/\bokhttp\b/i)
+    },
+    windows: {
+      phone: match(windowsPhone),
+      tablet: match(windowsTablet),
+      device: match(windowsPhone) || match(windowsTablet)
+    },
+    other: {
+      blackberry: match(otherBlackBerry),
+      blackberry10: match(otherBlackBerry10),
+      opera: match(otherOpera),
+      firefox: match(otherFirefox),
+      chrome: match(otherChrome),
+      device: match(otherBlackBerry) || match(otherBlackBerry10) || match(otherOpera) || match(otherFirefox) || match(otherChrome)
+    },
+    any: false,
+    phone: false,
+    tablet: false
+  };
+  result.any = result.apple.device || result.android.device || result.windows.device || result.other.device;
+  result.phone = result.apple.phone || result.android.phone || result.windows.phone;
+  result.tablet = result.apple.tablet || result.android.tablet || result.windows.tablet;
+  return result;
+}
+const esm = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: isMobile
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$1 = /* @__PURE__ */ getAugmentedNamespace(esm);
+Object.defineProperty(useBrowser$1, "__esModule", {
+  value: true
+});
+useBrowser$1.default = useBrowser;
+var _react = require$$0;
+var _ismobilejs = _interopRequireDefault(require$$1);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t)
+    return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i)
+      return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+const DID_WALLET_TAG = "ABTWallet";
+function getDIDWalletVersion(userAgent) {
+  var _result$groups;
+  const reg = new RegExp("".concat(DID_WALLET_TAG, "/(?<version>[0-9.]+)"), "g");
+  const result = reg.exec(userAgent);
+  const version = result === null || result === void 0 ? void 0 : (_result$groups = result.groups) === null || _result$groups === void 0 ? void 0 : _result$groups.version;
+  return version;
+}
+function useBrowser() {
+  var _window, _window$navigator;
+  const userAgent = (_window = window) === null || _window === void 0 ? void 0 : (_window$navigator = _window.navigator) === null || _window$navigator === void 0 ? void 0 : _window$navigator.userAgent;
+  const [browser] = (0, _react.useState)({
+    wallet: userAgent.indexOf(DID_WALLET_TAG) > -1,
+    walletVersion: getDIDWalletVersion(userAgent),
+    wechat: /MicroMessenger/i.test(userAgent),
+    mobile: _objectSpread({
+      apple: {
+        phone: false,
+        ipod: false,
+        tablet: false,
+        device: false
+      },
+      amazon: {
+        phone: false,
+        tablet: false,
+        device: false
+      },
+      android: {
+        phone: false,
+        tablet: false,
+        device: false
+      },
+      windows: {
+        phone: false,
+        tablet: false,
+        device: false
+      },
+      other: {
+        blackberry: false,
+        blackberry10: false,
+        opera: false,
+        firefox: false,
+        chrome: false,
+        device: false
+      },
+      phone: false,
+      tablet: false,
+      any: false
+    }, (0, _ismobilejs.default)(userAgent))
+  });
+  return browser;
+}
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "useBrowser", {
+    enumerable: true,
+    get: function get() {
+      return _useBrowser.default;
+    }
+  });
+  Object.defineProperty(exports, "useInterval", {
+    enumerable: true,
+    get: function get() {
+      return _useInterval.default;
+    }
+  });
+  Object.defineProperty(exports, "useStorage", {
+    enumerable: true,
+    get: function get() {
+      return _useStorage.default;
+    }
+  });
+  var _useInterval = _interopRequireDefault2(useInterval$1);
+  var _useStorage = _interopRequireDefault2(useStorage$1);
+  var _useBrowser = _interopRequireDefault2(useBrowser$1);
+  function _interopRequireDefault2(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+})(lib);
+const useChatInWallet = () => {
+  const navigate = useNavigate();
+  const { walletVersion, mobile } = lib.useBrowser();
+  const navigateToChat = ({ id: id2, title }) => {
+    const targetVersion = mobile.apple.device ? "5.3.2" : "5.3.0";
+    if (walletVersion && cmp(walletVersion, targetVersion) === 1) {
+      navigate(`/chat-in-wallet/${id2}`);
+    } else {
+      bridge.call("clickChat", { id: id2, title });
+    }
+  };
+  return { navigateToChat };
+};
 function ChatList({ inWallet, ...rest }) {
   const { t } = useLocaleContext();
   const { orderedChats, activeChatId, setActiveChat, getOppositeUser, hasUnreadMessages, getLastMessageText } = useChatContext();
+  const { navigateToChat } = useChatInWallet();
   const renderItem = (chat) => {
     if (chat.type === "notification") {
       return /* @__PURE__ */ jsx(SystemUser, { name: t("chat.notification") });
@@ -3985,7 +4894,7 @@ function ChatList({ inWallet, ...rest }) {
               const getTitle = webTitleMap[chat.type] || webTitleMap.default;
               return getTitle();
             };
-            bridge.call("clickChat", { id: chat.id, title: getWebTitle() });
+            navigateToChat({ id: chat.id, title: getWebTitle() });
           } else {
             setActiveChat(chat);
           }
@@ -4898,6 +5807,7 @@ function UserSearch({ sx, ...rest }) {
   const { client: client2, isInWallet, chats, setActiveChat, createDM } = useChatContext();
   const [inputValue, setInputValue] = useState("");
   const [open, setOpen] = useState(false);
+  const { navigateToChat } = useChatInWallet();
   const { data, loading } = useRequest(
     async () => {
       if (!open) {
@@ -4974,10 +5884,10 @@ function UserSearch({ sx, ...rest }) {
           const chat = chats.find((x) => x.id === chatId);
           if (isInWallet) {
             if (chat) {
-              bridge.call("clickChat", { id: chat.id, title: newValue.fullName });
+              navigateToChat({ id: chat.id, title: newValue.fullName });
             } else {
               const dm = await createDM(newValue.did);
-              bridge.call("clickChat", { id: dm.id, title: newValue.fullName });
+              navigateToChat({ id: dm.id, title: newValue.fullName });
             }
           } else if (chat) {
             setActiveChat(chat);
@@ -5546,7 +6456,7 @@ function Pagination({
     }
   );
 }
-const Editor = lazy(() => import("./editor-N32Ffdew.mjs"));
+const Editor = lazy(() => import("./editor-T5YWV1te.mjs"));
 function LazyEditor(props) {
   const fallback = /* @__PURE__ */ jsxs(Box, { sx: { px: 3 }, children: [
     /* @__PURE__ */ jsx(Skeleton, {}),
@@ -11726,87 +12636,88 @@ function SegmentedControl({ value, options, onChange, sx, ...rest }) {
   ) });
 }
 export {
-  useChatContext as $,
+  ChatHeaderAddon as $,
   Avatar as A,
   Badge as B,
   CommentInput as C,
   DefaultEditorConfigProvider as D,
-  BinaryThumb as E,
-  EmptyStatus as F,
+  CommentsProvider as E,
+  BinaryThumb as F,
   GithubReaction as G,
-  BlogListWrapper as H,
+  EmptyStatus as H,
   ImagePathFixerPlugin as I,
-  BlogCard as J,
-  BlogPermaLink as K,
-  getBlogLink as L,
+  BlogListWrapper as J,
+  BlogCard as K,
+  BlogPermaLink as L,
   Menu as M,
-  CoverImage as N,
-  CoverImageUpload as O,
+  getBlogLink as N,
+  CoverImage as O,
   Pagination as P,
-  AccessControl as Q,
+  CoverImageUpload as Q,
   RelativeTime as R,
   ScrollableEditorWrapper as S,
-  useAuthzContext as T,
-  AuthzProvider as U,
+  AccessControl as T,
+  useAuthzContext as U,
   VideoPathFixerPlugin as V,
-  ChatClient as W,
-  Chat as X,
-  ChatInWallet as Y,
-  ChatListInWallet as Z,
-  ChatHeaderAddon as _,
+  AuthzProvider as W,
+  ChatClient as X,
+  Chat as Y,
+  ChatInWallet as Z,
+  ChatListInWallet as _,
   isEmptyContent as a,
-  ChatProvider as a0,
-  UnreadNotificationContext as a1,
-  useUnreadNotification as a2,
-  UnreadNotificationProvider as a3,
-  Confirm as a4,
-  ConfirmContext as a5,
-  useConfirm as a6,
-  ConfirmProvider as a7,
-  SecureLabelPicker as a8,
-  useApiErrorHandler as a9,
-  useDefaultApiErrorHandler as aa,
-  DefaultApiErrorHandler as ab,
-  Back as ac,
-  LazyEditor as ad,
-  EditorPreview as ae,
-  DirtyPromptContainer as af,
-  ConfirmNavigation as ag,
-  UploaderContext as ah,
-  useUploader as ai,
-  UploaderTrigger as aj,
-  UploaderProvider as ak,
-  composeImageUrl as al,
-  usePointUpContext as am,
-  PointUpProvider as an,
-  ButtonGroup as ao,
-  SegmentedControl as ap,
-  create as aq,
-  getWsClient as ar,
-  useSubscription as as,
+  useChatContext as a0,
+  ChatProvider as a1,
+  UnreadNotificationContext as a2,
+  useUnreadNotification as a3,
+  UnreadNotificationProvider as a4,
+  Confirm as a5,
+  ConfirmContext as a6,
+  useConfirm as a7,
+  ConfirmProvider as a8,
+  SecureLabelPicker as a9,
+  useApiErrorHandler as aa,
+  useDefaultApiErrorHandler as ab,
+  DefaultApiErrorHandler as ac,
+  Back as ad,
+  LazyEditor as ae,
+  EditorPreview as af,
+  DirtyPromptContainer as ag,
+  ConfirmNavigation as ah,
+  UploaderContext as ai,
+  useUploader as aj,
+  UploaderTrigger as ak,
+  UploaderProvider as al,
+  composeImageUrl as am,
+  usePointUpContext as an,
+  PointUpProvider as ao,
+  ButtonGroup as ap,
+  SegmentedControl as aq,
+  create as ar,
+  getWsClient as as,
+  useSubscription as at,
   Input as b,
   useChanged as c,
   useSessionContext as d,
   utils as e,
-  typography as f,
+  preferences as f,
   getExcerptSync as g,
-  themeOverrides as h,
+  typography as h,
   inferInitialEditorState as i,
-  InternalThemeProvider as j,
-  Avatars as k,
+  themeOverrides as j,
+  InternalThemeProvider as k,
   lexical as l,
-  AuthorInfo as m,
-  SystemUser as n,
-  PostContent as o,
-  preferences as p,
-  PostComponent as q,
+  Avatars as m,
+  AuthorInfo as n,
+  SystemUser as o,
+  preloadInput as p,
+  PostContent as q,
   routes as r,
   stringify as s,
   translations as t,
   useNow as u,
-  Comment as v,
-  CommentList as w,
-  CommentsContext as x,
-  useCommentsContext as y,
-  CommentsProvider as z
+  PostComponent as v,
+  Comment as w,
+  CommentList as x,
+  CommentsContext as y,
+  useCommentsContext as z
 };