stream-chat-react 9.3.0 → 9.4.0

package/dist/browser.full-bundle.js

@@ -13555,346 +13555,681 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
     var linkifyjs = linkify;
     var linkifyjs_1 = linkifyjs.find;
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
-    var convert_1 = convert;
-
-    function convert(test) {
-      if (test == null) {
-        return ok
-      }
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};function escapeStringRegexp(string) {
+    	if (typeof string !== 'string') {
+    		throw new TypeError('Expected a string');
+    	}
 
-      if (typeof test === 'string') {
-        return typeFactory(test)
-      }
+    	// Escape characters with special meaning either inside or outside character sets.
+    	// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+    	return string
+    		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
+    		.replace(/-/g, '\\x2d');
+    }
 
-      if (typeof test === 'object') {
-        return 'length' in test ? anyFactory(test) : allFactory(test)
-      }
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};/**
+     * @typedef {import('unist').Node} Node
+     * @typedef {import('unist').Parent} Parent
+     *
+     * @typedef {string} Type
+     * @typedef {Object<string, unknown>} Props
+     *
+     * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
+     */
 
-      if (typeof test === 'function') {
-        return test
-      }
+    const convert$2 =
+      /**
+       * @type {(
+       *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+       *   ((test?: Test) => AssertAnything)
+       * )}
+       */
+      (
+        /**
+         * Generate an assertion from a check.
+         * @param {Test} [test]
+         * When nullish, checks if `node` is a `Node`.
+         * When `string`, works like passing `function (node) {return node.type === test}`.
+         * When `function` checks if function passed the node is true.
+         * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+         * When `array`, checks any one of the subtests pass.
+         * @returns {AssertAnything}
+         */
+        function (test) {
+          if (test === undefined || test === null) {
+            return ok$2
+          }
 
-      throw new Error('Expected function, string, or object as test')
-    }
+          if (typeof test === 'string') {
+            return typeFactory$2(test)
+          }
 
-    // Utility assert each property in `test` is represented in `node`, and each
-    // values are strictly equal.
-    function allFactory(test) {
-      return all
+          if (typeof test === 'object') {
+            return Array.isArray(test) ? anyFactory$2(test) : propsFactory$1(test)
+          }
 
-      function all(node) {
-        var key;
+          if (typeof test === 'function') {
+            return castFactory$1(test)
+          }
 
-        for (key in test) {
-          if (node[key] !== test[key]) return false
+          throw new Error('Expected function, string, or object as test')
         }
-
-        return true
-      }
-    }
-
-    function anyFactory(tests) {
-      var checks = [];
-      var index = -1;
+      );
+    /**
+     * @param {Array.<Type|Props|TestFunctionAnything>} tests
+     * @returns {AssertAnything}
+     */
+    function anyFactory$2(tests) {
+      /** @type {Array.<AssertAnything>} */
+      const checks = [];
+      let index = -1;
 
       while (++index < tests.length) {
-        checks[index] = convert(tests[index]);
+        checks[index] = convert$2(tests[index]);
       }
 
-      return any
+      return castFactory$1(any)
 
-      function any() {
-        var index = -1;
+      /**
+       * @this {unknown}
+       * @param {unknown[]} parameters
+       * @returns {boolean}
+       */
+      function any(...parameters) {
+        let index = -1;
 
         while (++index < checks.length) {
-          if (checks[index].apply(this, arguments)) {
-            return true
-          }
+          if (checks[index].call(this, ...parameters)) return true
         }
 
         return false
       }
     }
 
-    // Utility to convert a string into a function which checks a given node’s type
-    // for said string.
-    function typeFactory(test) {
-      return type
+    /**
+     * Utility to assert each property in `test` is represented in `node`, and each
+     * values are strictly equal.
+     *
+     * @param {Props} check
+     * @returns {AssertAnything}
+     */
+    function propsFactory$1(check) {
+      return castFactory$1(all)
 
-      function type(node) {
-        return Boolean(node && node.type === test)
-      }
-    }
+      /**
+       * @param {Node} node
+       * @returns {boolean}
+       */
+      function all(node) {
+        /** @type {string} */
+        let key;
 
-    // Utility to return true.
-    function ok() {
-      return true
-    }
+        for (key in check) {
+          // @ts-expect-error: hush, it sure works as an index.
+          if (node[key] !== check[key]) return false
+        }
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var color_1 = color;
-    function color(d) {
-      return '\u001B[33m' + d + '\u001B[39m'
+        return true
+      }
     }
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
-    var unistUtilVisitParents$1 = visitParents$1;
+    /**
+     * Utility to convert a string into a function which checks a given node’s type
+     * for said string.
+     *
+     * @param {Type} check
+     * @returns {AssertAnything}
+     */
+    function typeFactory$2(check) {
+      return castFactory$1(type)
 
+      /**
+       * @param {Node} node
+       */
+      function type(node) {
+        return node && node.type === check
+      }
+    }
 
+    /**
+     * Utility to convert a string into a function which checks a given node’s type
+     * for said string.
+     * @param {TestFunctionAnything} check
+     * @returns {AssertAnything}
+     */
+    function castFactory$1(check) {
+      return assertion
 
+      /**
+       * @this {unknown}
+       * @param {Array.<unknown>} parameters
+       * @returns {boolean}
+       */
+      function assertion(...parameters) {
+        // @ts-expect-error: spreading is fine.
+        return Boolean(check.call(this, ...parameters))
+      }
+    }
 
-    var CONTINUE$1 = true;
-    var SKIP$1 = 'skip';
-    var EXIT$1 = false;
+    // Utility to return true.
+    function ok$2() {
+      return true
+    }
 
-    visitParents$1.CONTINUE = CONTINUE$1;
-    visitParents$1.SKIP = SKIP$1;
-    visitParents$1.EXIT = EXIT$1;
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};/**
+     * @param {string} d
+     * @returns {string}
+     */
+    function color$1(d) {
+      return d
+    }
 
-    function visitParents$1(tree, test, visitor, reverse) {
-      var step;
-      var is;
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};/**
+     * @typedef {import('unist').Node} Node
+     * @typedef {import('unist').Parent} Parent
+     * @typedef {import('unist-util-is').Test} Test
+     * @typedef {import('./complex-types').Action} Action
+     * @typedef {import('./complex-types').Index} Index
+     * @typedef {import('./complex-types').ActionTuple} ActionTuple
+     * @typedef {import('./complex-types').VisitorResult} VisitorResult
+     * @typedef {import('./complex-types').Visitor} Visitor
+     */
 
-      if (typeof test === 'function' && typeof visitor !== 'function') {
-        reverse = visitor;
-        visitor = test;
-        test = null;
-      }
+    /**
+     * Continue traversing as normal
+     */
+    const CONTINUE$2 = true;
+    /**
+     * Do not traverse this node’s children
+     */
+    const SKIP$2 = 'skip';
+    /**
+     * Stop traversing immediately
+     */
+    const EXIT$2 = false;
 
-      is = convert_1(test);
-      step = reverse ? -1 : 1;
+    /**
+     * Visit children of tree which pass a test
+     *
+     * @param tree Abstract syntax tree to walk
+     * @param test Test node, optional
+     * @param visitor Function to run for each node
+     * @param reverse Visit the tree in reverse order, defaults to false
+     */
+    const visitParents$2 =
+      /**
+       * @type {(
+       *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
+       *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)
+       * )}
+       */
+      (
+        /**
+         * @param {Node} tree
+         * @param {Test} test
+         * @param {import('./complex-types').Visitor<Node>} visitor
+         * @param {boolean} [reverse]
+         */
+        function (tree, test, visitor, reverse) {
+          if (typeof test === 'function' && typeof visitor !== 'function') {
+            reverse = visitor;
+            // @ts-expect-error no visitor given, so `visitor` is test.
+            visitor = test;
+            test = null;
+          }
 
-      factory(tree, null, [])();
+          const is = convert$2(test);
+          const step = reverse ? -1 : 1;
 
-      function factory(node, index, parents) {
-        var value = typeof node === 'object' && node !== null ? node : {};
-        var name;
+          factory(tree, null, [])();
 
-        if (typeof value.type === 'string') {
-          name =
-            typeof value.tagName === 'string'
-              ? value.tagName
-              : typeof value.name === 'string'
-              ? value.name
-              : undefined;
+          /**
+           * @param {Node} node
+           * @param {number?} index
+           * @param {Array.<Parent>} parents
+           */
+          function factory(node, index, parents) {
+            /** @type {Object.<string, unknown>} */
+            // @ts-expect-error: hush
+            const value = typeof node === 'object' && node !== null ? node : {};
+            /** @type {string|undefined} */
+            let name;
+
+            if (typeof value.type === 'string') {
+              name =
+                typeof value.tagName === 'string'
+                  ? value.tagName
+                  : typeof value.name === 'string'
+                  ? value.name
+                  : undefined;
+
+              Object.defineProperty(visit, 'name', {
+                value:
+                  'node (' +
+                  color$1(value.type + (name ? '<' + name + '>' : '')) +
+                  ')'
+              });
+            }
 
-          visit.displayName =
-            'node (' + color_1(value.type + (name ? '<' + name + '>' : '')) + ')';
-        }
+            return visit
 
-        return visit
+            function visit() {
+              /** @type {ActionTuple} */
+              let result = [];
+              /** @type {ActionTuple} */
+              let subresult;
+              /** @type {number} */
+              let offset;
+              /** @type {Array.<Parent>} */
+              let grandparents;
 
-        function visit() {
-          var grandparents = parents.concat(node);
-          var result = [];
-          var subresult;
-          var offset;
+              if (!test || is(node, index, parents[parents.length - 1] || null)) {
+                result = toResult$1(visitor(node, parents));
 
-          if (!test || is(node, index, parents[parents.length - 1] || null)) {
-            result = toResult(visitor(node, parents));
+                if (result[0] === EXIT$2) {
+                  return result
+                }
+              }
 
-            if (result[0] === EXIT$1) {
-              return result
-            }
-          }
+              // @ts-expect-error looks like a parent.
+              if (node.children && result[0] !== SKIP$2) {
+                // @ts-expect-error looks like a parent.
+                offset = (reverse ? node.children.length : -1) + step;
+                // @ts-expect-error looks like a parent.
+                grandparents = parents.concat(node);
 
-          if (node.children && result[0] !== SKIP$1) {
-            offset = (reverse ? node.children.length : -1) + step;
+                // @ts-expect-error looks like a parent.
+                while (offset > -1 && offset < node.children.length) {
+                  // @ts-expect-error looks like a parent.
+                  subresult = factory(node.children[offset], offset, grandparents)();
 
-            while (offset > -1 && offset < node.children.length) {
-              subresult = factory(node.children[offset], offset, grandparents)();
+                  if (subresult[0] === EXIT$2) {
+                    return subresult
+                  }
 
-              if (subresult[0] === EXIT$1) {
-                return subresult
+                  offset =
+                    typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+                }
               }
 
-              offset =
-                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+              return result
             }
           }
-
-          return result
         }
-      }
-    }
+      );
 
-    function toResult(value) {
-      if (value !== null && typeof value === 'object' && 'length' in value) {
+    /**
+     * @param {VisitorResult} value
+     * @returns {ActionTuple}
+     */
+    function toResult$1(value) {
+      if (Array.isArray(value)) {
         return value
       }
 
       if (typeof value === 'number') {
-        return [CONTINUE$1, value]
+        return [CONTINUE$2, value]
       }
 
       return [value]
     }
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
-    var escapeStringRegexp = string => {
-    	if (typeof string !== 'string') {
-    		throw new TypeError('Expected a string');
-    	}
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};/**
+     * @typedef {import('unist').Node} Node
+     * @typedef {import('unist').Parent} Parent
+     *
+     * @typedef {string} Type
+     * @typedef {Object<string, unknown>} Props
+     *
+     * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test
+     */
 
-    	// Escape characters with special meaning either inside or outside character sets.
-    	// Use a simple backslash escape when it’s always valid, and a \unnnn escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-    	return string
-    		.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
-    		.replace(/-/g, '\\x2d');
-    };
+    const convert$1 =
+      /**
+       * @type {(
+       *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
+       *   ((test?: Test) => AssertAnything)
+       * )}
+       */
+      (
+        /**
+         * Generate an assertion from a check.
+         * @param {Test} [test]
+         * When nullish, checks if `node` is a `Node`.
+         * When `string`, works like passing `function (node) {return node.type === test}`.
+         * When `function` checks if function passed the node is true.
+         * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
+         * When `array`, checks any one of the subtests pass.
+         * @returns {AssertAnything}
+         */
+        function (test) {
+          if (test === undefined || test === null) {
+            return ok$1
+          }
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
-    var mdastUtilFindAndReplace = findAndReplace;
+          if (typeof test === 'string') {
+            return typeFactory$1(test)
+          }
 
+          if (typeof test === 'object') {
+            return Array.isArray(test) ? anyFactory$1(test) : propsFactory(test)
+          }
 
+          if (typeof test === 'function') {
+            return castFactory(test)
+          }
 
+          throw new Error('Expected function, string, or object as test')
+        }
+      );
+    /**
+     * @param {Array.<Type|Props|TestFunctionAnything>} tests
+     * @returns {AssertAnything}
+     */
+    function anyFactory$1(tests) {
+      /** @type {Array.<AssertAnything>} */
+      const checks = [];
+      let index = -1;
+
+      while (++index < tests.length) {
+        checks[index] = convert$1(tests[index]);
+      }
+
+      return castFactory(any)
 
+      /**
+       * @this {unknown}
+       * @param {unknown[]} parameters
+       * @returns {boolean}
+       */
+      function any(...parameters) {
+        let index = -1;
 
-    var splice$2 = [].splice;
+        while (++index < checks.length) {
+          if (checks[index].call(this, ...parameters)) return true
+        }
 
-    function findAndReplace(tree, find, replace, options) {
-      var settings;
-      var schema;
+        return false
+      }
+    }
 
-      if (typeof find === 'string' || (find && typeof find.exec === 'function')) {
-        schema = [[find, replace]];
-      } else {
-        schema = find;
-        options = replace;
+    /**
+     * Utility to assert each property in `test` is represented in `node`, and each
+     * values are strictly equal.
+     *
+     * @param {Props} check
+     * @returns {AssertAnything}
+     */
+    function propsFactory(check) {
+      return castFactory(all)
+
+      /**
+       * @param {Node} node
+       * @returns {boolean}
+       */
+      function all(node) {
+        /** @type {string} */
+        let key;
+
+        for (key in check) {
+          // @ts-expect-error: hush, it sure works as an index.
+          if (node[key] !== check[key]) return false
+        }
+
+        return true
       }
+    }
 
-      settings = options || {};
+    /**
+     * Utility to convert a string into a function which checks a given node’s type
+     * for said string.
+     *
+     * @param {Type} check
+     * @returns {AssertAnything}
+     */
+    function typeFactory$1(check) {
+      return castFactory(type)
 
-      search$2(tree, settings, handlerFactory(toPairs$1(schema)));
+      /**
+       * @param {Node} node
+       */
+      function type(node) {
+        return node && node.type === check
+      }
+    }
+
+    /**
+     * Utility to convert a string into a function which checks a given node’s type
+     * for said string.
+     * @param {TestFunctionAnything} check
+     * @returns {AssertAnything}
+     */
+    function castFactory(check) {
+      return assertion
+
+      /**
+       * @this {unknown}
+       * @param {Array.<unknown>} parameters
+       * @returns {boolean}
+       */
+      function assertion(...parameters) {
+        // @ts-expect-error: spreading is fine.
+        return Boolean(check.call(this, ...parameters))
+      }
+    }
+
+    // Utility to return true.
+    function ok$1() {
+      return true
+    }
 
-      return tree
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};/**
+     * @typedef Options
+     *   Configuration (optional).
+     * @property {Test} [ignore]
+     *   `unist-util-is` test used to assert parents
+     *
+     * @typedef {import('mdast').Root} Root
+     * @typedef {import('mdast').Content} Content
+     * @typedef {import('mdast').PhrasingContent} PhrasingContent
+     * @typedef {import('mdast').Text} Text
+     * @typedef {Content|Root} Node
+     * @typedef {Exclude<Extract<Node, import('mdast').Parent>, Root>} Parent
+     *
+     * @typedef {import('unist-util-visit-parents').Test} Test
+     * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
+     *
+     * @typedef RegExpMatchObject
+     * @property {number} index
+     * @property {string} input
+     * @property {[Root, ...Array<Parent>, Text]} stack
+     *
+     * @typedef {string|RegExp} Find
+     * @typedef {string|ReplaceFunction} Replace
+     *
+     * @typedef {[Find, Replace]} FindAndReplaceTuple
+     * @typedef {Record<string, Replace>} FindAndReplaceSchema
+     * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
+     *
+     * @typedef {[RegExp, ReplaceFunction]} Pair
+     * @typedef {Array<Pair>} Pairs
+     */
 
-      function handlerFactory(pairs) {
-        var pair = pairs[0];
+    const own$5 = {}.hasOwnProperty;
 
-        return handler
+    /**
+     * @param tree mdast tree
+     * @param find Value to find and remove. When `string`, escaped and made into a global `RegExp`
+     * @param [replace] Value to insert.
+     *   * When `string`, turned into a Text node.
+     *   * When `Function`, called with the results of calling `RegExp.exec` as
+     *     arguments, in which case it can return a single or a list of `Node`,
+     *     a `string` (which is wrapped in a `Text` node), or `false` to not replace
+     * @param [options] Configuration.
+     */
+    const findAndReplace =
+      /**
+       * @type {(
+       *   ((tree: Node, find: Find, replace?: Replace, options?: Options) => Node) &
+       *   ((tree: Node, schema: FindAndReplaceSchema|FindAndReplaceList, options?: Options) => Node)
+       * )}
+       **/
+      (
+        /**
+         * @param {Node} tree
+         * @param {Find|FindAndReplaceSchema|FindAndReplaceList} find
+         * @param {Replace|Options} [replace]
+         * @param {Options} [options]
+         */
+        function (tree, find, replace, options) {
+          /** @type {Options|undefined} */
+          let settings;
+          /** @type {FindAndReplaceSchema|FindAndReplaceList} */
+          let schema;
+
+          if (typeof find === 'string' || find instanceof RegExp) {
+            // @ts-expect-error don’t expect options twice.
+            schema = [[find, replace]];
+            settings = options;
+          } else {
+            schema = find;
+            // @ts-expect-error don’t expect replace twice.
+            settings = replace;
+          }
 
-        function handler(node, parent) {
-          var find = pair[0];
-          var replace = pair[1];
-          var nodes = [];
-          var start = 0;
-          var index = parent.children.indexOf(node);
-          var position;
-          var match;
-          var subhandler;
-          var value;
+          if (!settings) {
+            settings = {};
+          }
 
-          find.lastIndex = 0;
+          const ignored = convert$1(settings.ignore || []);
+          const pairs = toPairs$1(schema);
+          let pairIndex = -1;
 
-          match = find.exec(node.value);
+          while (++pairIndex < pairs.length) {
+            visitParents$2(tree, 'text', visitor);
+          }
 
-          while (match) {
-            position = match.index;
-            value = replace.apply(
-              null,
-              [].concat(match, {index: match.index, input: match.input})
-            );
+          return tree
 
-            if (value !== false) {
-              if (start !== position) {
-                nodes.push({type: 'text', value: node.value.slice(start, position)});
-              }
+          /** @type {import('unist-util-visit-parents/complex-types').BuildVisitor<Root, 'text'>} */
+          function visitor(node, parents) {
+            let index = -1;
+            /** @type {Parent|undefined} */
+            let grandparent;
 
-              if (typeof value === 'string' && value.length > 0) {
-                value = {type: 'text', value: value};
-              }
+            while (++index < parents.length) {
+              const parent = /** @type {Parent} */ (parents[index]);
 
-              if (value) {
-                nodes = [].concat(nodes, value);
+              if (
+                ignored(
+                  parent,
+                  // @ts-expect-error mdast vs. unist parent.
+                  grandparent ? grandparent.children.indexOf(parent) : undefined,
+                  grandparent
+                )
+              ) {
+                return
               }
 
-              start = position + match[0].length;
+              grandparent = parent;
             }
 
-            if (!find.global) {
-              break
+            if (grandparent) {
+              // @ts-expect-error: stack is fine.
+              return handler(node, parents)
             }
-
-            match = find.exec(node.value);
           }
 
-          if (position === undefined) {
-            nodes = [node];
-            index--;
-          } else {
-            if (start < node.value.length) {
-              nodes.push({type: 'text', value: node.value.slice(start)});
-            }
+          /**
+           * @param {Text} node
+           * @param {[Root, ...Array<Parent>]} parents
+           * @returns {VisitorResult}
+           */
+          function handler(node, parents) {
+            const parent = parents[parents.length - 1];
+            const find = pairs[pairIndex][0];
+            const replace = pairs[pairIndex][1];
+            let start = 0;
+            // @ts-expect-error: TS is wrong, some of these children can be text.
+            const index = parent.children.indexOf(node);
+            let change = false;
+            /** @type {Array<PhrasingContent>} */
+            let nodes = [];
+            /** @type {number|undefined} */
+            let position;
+
+            find.lastIndex = 0;
+
+            let match = find.exec(node.value);
+
+            while (match) {
+              position = match.index;
+              /** @type {RegExpMatchObject} */
+              const matchObject = {
+                index: match.index,
+                input: match.input,
+                stack: [...parents, node]
+              };
+              let value = replace(...match, matchObject);
 
-            nodes.unshift(index, 1);
-            splice$2.apply(parent.children, nodes);
-          }
+              if (typeof value === 'string') {
+                value = value.length > 0 ? {type: 'text', value} : undefined;
+              }
 
-          if (pairs.length > 1) {
-            subhandler = handlerFactory(pairs.slice(1));
-            position = -1;
+              if (value !== false) {
+                if (start !== position) {
+                  nodes.push({
+                    type: 'text',
+                    value: node.value.slice(start, position)
+                  });
+                }
 
-            while (++position < nodes.length) {
-              node = nodes[position];
+                if (Array.isArray(value)) {
+                  nodes.push(...value);
+                } else if (value) {
+                  nodes.push(value);
+                }
 
-              if (node.type === 'text') {
-                subhandler(node, parent);
-              } else {
-                search$2(node, settings, subhandler);
+                start = position + match[0].length;
+                change = true;
               }
-            }
-          }
-
-          return index + nodes.length + 1
-        }
-      }
-    }
-
-    function search$2(tree, settings, handler) {
-      var ignored = convert_1(settings.ignore || []);
-      var result = [];
 
-      unistUtilVisitParents$1(tree, 'text', visitor);
+              if (!find.global) {
+                break
+              }
 
-      return result
+              match = find.exec(node.value);
+            }
 
-      function visitor(node, parents) {
-        var index = -1;
-        var parent;
-        var grandparent;
+            if (change) {
+              if (start < node.value.length) {
+                nodes.push({type: 'text', value: node.value.slice(start)});
+              }
 
-        while (++index < parents.length) {
-          parent = parents[index];
+              parent.children.splice(index, 1, ...nodes);
+            } else {
+              nodes = [node];
+            }
 
-          if (
-            ignored(
-              parent,
-              grandparent ? grandparent.children.indexOf(parent) : undefined,
-              grandparent
-            )
-          ) {
-            return
+            return index + nodes.length
           }
-
-          grandparent = parent;
         }
+      );
 
-        return handler(node, grandparent)
-      }
-    }
-
+    /**
+     * @param {FindAndReplaceSchema|FindAndReplaceList} schema
+     * @returns {Pairs}
+     */
     function toPairs$1(schema) {
-      var result = [];
-      var key;
-      var index;
+      /** @type {Pairs} */
+      const result = [];
 
       if (typeof schema !== 'object') {
-        throw new Error('Expected array or object as schema')
+        throw new TypeError('Expected array or object as schema')
       }
 
-      if ('length' in schema) {
-        index = -1;
+      if (Array.isArray(schema)) {
+        let index = -1;
 
         while (++index < schema.length) {
           result.push([
@@ -13903,24 +14238,33 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
           ]);
         }
       } else {
+        /** @type {string} */
+        let key;
+
         for (key in schema) {
-          result.push([toExpression(key), toFunction(schema[key])]);
+          if (own$5.call(schema, key)) {
+            result.push([toExpression(key), toFunction(schema[key])]);
+          }
         }
       }
 
       return result
     }
 
+    /**
+     * @param {Find} find
+     * @returns {RegExp}
+     */
     function toExpression(find) {
       return typeof find === 'string' ? new RegExp(escapeStringRegexp(find), 'g') : find
     }
 
+    /**
+     * @param {Replace} replace
+     * @returns {ReplaceFunction}
+     */
     function toFunction(replace) {
-      return typeof replace === 'function' ? replace : returner
-
-      function returner() {
-        return replace
-      }
+      return typeof replace === 'function' ? replace : () => replace
     }
 
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var immutable = extend$1;
@@ -23943,10 +24287,10 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
 
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
     /* Expose. */
-    var unistUtilVisitParents = visitParents;
+    var unistUtilVisitParents$1 = visitParents$1;
 
     /* Visit. */
-    function visitParents(tree, type, visitor) {
+    function visitParents$1(tree, type, visitor) {
       var stack = [];
 
       if (typeof type === 'function') {
@@ -23996,7 +24340,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
     function addListMetadata() {
       return function (ast) {
-        unistUtilVisitParents(ast, 'list', function (listNode, parents) {
+        unistUtilVisitParents$1(ast, 'list', function (listNode, parents) {
           var depth = 0, i, n;
           for (i = 0, n = parents.length; i < n; i++) {
             if (parents[i].type === 'list') depth += 1;
@@ -24014,14 +24358,189 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
 
     var mdastAddListMetadata = addListMetadata;
 
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
+    var convert_1 = convert;
+
+    function convert(test) {
+      if (test == null) {
+        return ok
+      }
+
+      if (typeof test === 'string') {
+        return typeFactory(test)
+      }
+
+      if (typeof test === 'object') {
+        return 'length' in test ? anyFactory(test) : allFactory(test)
+      }
+
+      if (typeof test === 'function') {
+        return test
+      }
+
+      throw new Error('Expected function, string, or object as test')
+    }
+
+    // Utility assert each property in `test` is represented in `node`, and each
+    // values are strictly equal.
+    function allFactory(test) {
+      return all
+
+      function all(node) {
+        var key;
+
+        for (key in test) {
+          if (node[key] !== test[key]) return false
+        }
+
+        return true
+      }
+    }
+
+    function anyFactory(tests) {
+      var checks = [];
+      var index = -1;
+
+      while (++index < tests.length) {
+        checks[index] = convert(tests[index]);
+      }
+
+      return any
+
+      function any() {
+        var index = -1;
+
+        while (++index < checks.length) {
+          if (checks[index].apply(this, arguments)) {
+            return true
+          }
+        }
+
+        return false
+      }
+    }
+
+    // Utility to convert a string into a function which checks a given node’s type
+    // for said string.
+    function typeFactory(test) {
+      return type
+
+      function type(node) {
+        return Boolean(node && node.type === test)
+      }
+    }
+
+    // Utility to return true.
+    function ok() {
+      return true
+    }
+
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var color_1 = color;
+    function color(d) {
+      return '\u001B[33m' + d + '\u001B[39m'
+    }
+
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
+    var unistUtilVisitParents = visitParents;
+
+
+
+
+    var CONTINUE$1 = true;
+    var SKIP$1 = 'skip';
+    var EXIT$1 = false;
+
+    visitParents.CONTINUE = CONTINUE$1;
+    visitParents.SKIP = SKIP$1;
+    visitParents.EXIT = EXIT$1;
+
+    function visitParents(tree, test, visitor, reverse) {
+      var step;
+      var is;
+
+      if (typeof test === 'function' && typeof visitor !== 'function') {
+        reverse = visitor;
+        visitor = test;
+        test = null;
+      }
+
+      is = convert_1(test);
+      step = reverse ? -1 : 1;
+
+      factory(tree, null, [])();
+
+      function factory(node, index, parents) {
+        var value = typeof node === 'object' && node !== null ? node : {};
+        var name;
+
+        if (typeof value.type === 'string') {
+          name =
+            typeof value.tagName === 'string'
+              ? value.tagName
+              : typeof value.name === 'string'
+              ? value.name
+              : undefined;
+
+          visit.displayName =
+            'node (' + color_1(value.type + (name ? '<' + name + '>' : '')) + ')';
+        }
+
+        return visit
+
+        function visit() {
+          var grandparents = parents.concat(node);
+          var result = [];
+          var subresult;
+          var offset;
+
+          if (!test || is(node, index, parents[parents.length - 1] || null)) {
+            result = toResult(visitor(node, parents));
+
+            if (result[0] === EXIT$1) {
+              return result
+            }
+          }
+
+          if (node.children && result[0] !== SKIP$1) {
+            offset = (reverse ? node.children.length : -1) + step;
+
+            while (offset > -1 && offset < node.children.length) {
+              subresult = factory(node.children[offset], offset, grandparents)();
+
+              if (subresult[0] === EXIT$1) {
+                return subresult
+              }
+
+              offset =
+                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
+            }
+          }
+
+          return result
+        }
+      }
+    }
+
+    function toResult(value) {
+      if (value !== null && typeof value === 'object' && 'length' in value) {
+        return value
+      }
+
+      if (typeof value === 'number') {
+        return [CONTINUE$1, value]
+      }
+
+      return [value]
+    }
+
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
     var unistUtilVisit = visit;
 
 
 
-    var CONTINUE = unistUtilVisitParents$1.CONTINUE;
-    var SKIP = unistUtilVisitParents$1.SKIP;
-    var EXIT = unistUtilVisitParents$1.EXIT;
+    var CONTINUE = unistUtilVisitParents.CONTINUE;
+    var SKIP = unistUtilVisitParents.SKIP;
+    var EXIT = unistUtilVisitParents.EXIT;
 
     visit.CONTINUE = CONTINUE;
     visit.SKIP = SKIP;
@@ -24034,7 +24553,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
         test = null;
       }
 
-      unistUtilVisitParents$1(tree, test, overload, reverse);
+      unistUtilVisitParents(tree, test, overload, reverse);
 
       function overload(node, parents) {
         var parent = parents[parents.length - 1];
@@ -36573,7 +37092,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
             };
         }
         var transform = function (markdownAST) {
-            mdastUtilFindAndReplace(markdownAST, emojiRegex(), replace);
+            findAndReplace(markdownAST, emojiRegex(), replace);
             return markdownAST;
         };
         return transform;
@@ -36600,7 +37119,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
                 return markdownAST;
             }
             var mentionedUsersRegex = new RegExp(mentioned_usernames.map(function (username) { return "@" + username; }).join('|'), 'g');
-            mdastUtilFindAndReplace(markdownAST, mentionedUsersRegex, replace);
+            findAndReplace(markdownAST, mentionedUsersRegex, replace);
             return markdownAST;
         };
         return transform;
@@ -36631,6 +37150,22 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
             if (noParsingNeeded.length > 0 || linkIsInBlock)
                 return;
             try {
+                // special case for mentions:
+                // it could happen that a user's name matches with an e-mail format pattern.
+                // in that case, we check whether the found e-mail is actually a mention
+                // by naively checking for an existence of @ sign in front of it.
+                if (type === 'email' && mentioned_users) {
+                    var emailMatchesWithName = mentioned_users.some(function (u) { return u.name === value; });
+                    if (emailMatchesWithName) {
+                        newText = newText.replace(new RegExp(escapeRegExp(value), 'g'), function (match, position) {
+                            var isMention = newText.charAt(position - 1) === '@';
+                            // in case of mention, we leave the match in its original form,
+                            // and we let `mentionsMarkdownPlugin` to do its job
+                            return isMention ? match : "[" + match + "](" + encodeDecode(href) + ")";
+                        });
+                        return;
+                    }
+                }
                 var displayLink = type === 'email' ? value : formatUrlForDisplay(href);
                 newText = newText.replace(new RegExp(escapeRegExp(value), 'g'), "[" + displayLink + "](" + encodeDecode(href) + ")");
             }
@@ -42774,7 +43309,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, editMessage(__assign$2(__assign$2({}, message), updatedMessage))];
+                        return [4 /*yield*/, editMessage(__assign$2(__assign$2(__assign$2({}, message), updatedMessage), customMessageData))];
                     case 2:
                         _a.sent();
                         clearEditingState === null || clearEditingState === void 0 ? void 0 : clearEditingState();
@@ -45150,7 +45685,7 @@ var StreamChatReact = (function (exports, React, streamChat, reactDom) {
 
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};
 
-    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var version = '9.3.0';
+    window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var version = '9.4.0';
 
     window.StreamChat.StreamChat=StreamChat;window.StreamChat.logChatPromiseExecution=logChatPromiseExecution;window.StreamChat.Channel=Channel;window.ICAL=window.ICAL||{};var useChat = function (_a) {
         var _b, _c;