@sendbird/uikit-react 3.16.4-rc → 3.16.5-rc

package/chunks/{bundle-_B8tqfKV.js → bundle-BOY8Xuzt.js}

@@ -10,4 +10,4 @@ var uuidv4 = function () { return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace
 }); };
 
 export { uuidv4 as u };
-//# sourceMappingURL=bundle-_B8tqfKV.js.map
+//# sourceMappingURL=bundle-BOY8Xuzt.js.map

package/chunks/bundle-BOY8Xuzt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-BOY8Xuzt.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/chunks/{bundle-D8H0ZPrd.js → bundle-BTjBE2da.js}

@@ -1,19 +1,19 @@
-import { _ as __assign, b as __awaiter, c as __generator, a as __spreadArray } from './bundle-BnjNXxxS.js';
+import { _ as __assign, b as __awaiter, c as __generator, a as __spreadArray } from './bundle-x29pMq_W.js';
 import React__default, { useCallback, useContext, useMemo, useEffect, useRef } from 'react';
-import { s as scrollIntoLast, u as useSendMultipleFilesMessage, c as compareIds, g as getParentMessageFrom, a as getNicknamesMapFromMembers } from './bundle-C0Bexvs3.js';
-import { U as UserProfileProvider } from './bundle-CgvBBPYd.js';
-import { s as shimExports, u as useStore, c as createStore } from './bundle-CJh1zVrG.js';
+import { s as scrollIntoLast, c as compareIds, u as useSendMultipleFilesMessage, g as getParentMessageFrom, a as getNicknamesMapFromMembers } from './bundle-C8SwQMRM.js';
+import { U as UserProfileProvider } from './bundle-BBDSHxmx.js';
+import { s as shimExports, u as useStore, c as createStore } from './bundle-Jsvq60lQ.js';
 import { ChannelType } from '@sendbird/chat';
-import { p as pubSubTopics, b as PublishingModuleType, a as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-Abf-s1Rv.js';
+import { p as pubSubTopics, b as PublishingModuleType, a as shouldPubSubPublishToThread, P as PUBSUB_TOPICS } from './bundle-BCj8grTA.js';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-_B8tqfKV.js';
-import { c as compareIds$1 } from './bundle-DvOO0iYB.js';
-import { ThreadListStateTypes, ChannelStateTypes, ParentMessageStateTypes } from '../Thread/context/types.js';
-import { u as useSendbird } from './bundle-BLEoxeBg.js';
-import { u as useDeepCompareEffect } from './bundle-D2seSPWh.js';
+import { u as uuidv4 } from './bundle-BOY8Xuzt.js';
+import { c as compareIds$1 } from './bundle-bEPz_Nb8.js';
+import { ThreadListStateTypes, ParentMessageStateTypes, ChannelStateTypes } from '../Thread/context/types.js';
+import { u as useSendbird } from './bundle-Docu4wr7.js';
+import { u as useDeepCompareEffect } from './bundle-DmY-yaEG.js';
 import { SendingStatus, MessageMetaArray, MessageType } from '@sendbird/chat/message';
-import './bundle-BmiS1Peo.js';
-import { e as SCROLL_BOTTOM_DELAY_FOR_SEND, a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE, i as META_ARRAY_VOICE_DURATION_KEY, j as META_ARRAY_MESSAGE_TYPE_KEY, k as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE } from './bundle-CfyNporr.js';
+import './bundle-B8hofb8v.js';
+import { e as SCROLL_BOTTOM_DELAY_FOR_SEND, a as VOICE_MESSAGE_FILE_NAME, b as VOICE_MESSAGE_MIME_TYPE, i as META_ARRAY_VOICE_DURATION_KEY, j as META_ARRAY_MESSAGE_TYPE_KEY, k as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE } from './bundle-8ZKWSC0K.js';
 
 var PREV_THREADS_FETCH_SIZE = 30;
 var NEXT_THREADS_FETCH_SIZE = 30;
@@ -79,7 +79,13 @@ function useSendUserMessageCallback(_a, _b) {
                 });
             });
         }
-    }, [isMentionEnabled, currentChannel]);
+    }, [
+        isMentionEnabled,
+        currentChannel,
+        onBeforeSendUserMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
     return sendMessage;
 }
 
@@ -131,7 +137,12 @@ function useSendFileMessageCallback(_a, _b) {
                 });
             }
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onBeforeSendFileMessage,
+        sendMessageStart,
+        sendMessageFailure,
+    ]);
 }
 
 var useSendVoiceMessageCallback = function (_a, _b) {
@@ -183,6 +194,8 @@ var useSendVoiceMessageCallback = function (_a, _b) {
     }, [
         currentChannel,
         onBeforeSendVoiceMessage,
+        sendMessageStart,
+        sendMessageFailure,
     ]);
     return sendMessage;
 };
@@ -292,7 +305,12 @@ function useResendMessageCallback(_a, _b) {
             failedMessage.sendingStatus = SendingStatus.FAILED;
             sendMessageFailure(failedMessage);
         }
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        resendMessageStart,
+        sendMessageSuccess,
+        sendMessageFailure,
+    ]);
 }
 
 function useUpdateMessageCallback(_a, _b) {
@@ -332,7 +350,11 @@ function useUpdateMessageCallback(_a, _b) {
                 publishingModules: [PublishingModuleType.THREAD],
             });
         });
-    }, [currentChannel, isMentionEnabled]);
+    }, [
+        currentChannel,
+        isMentionEnabled,
+        onMessageUpdated,
+    ]);
 }
 
 function useDeleteMessageCallback(_a, _b) {
@@ -364,7 +386,11 @@ function useDeleteMessageCallback(_a, _b) {
                 reject(err);
             });
         });
-    }, [currentChannel]);
+    }, [
+        currentChannel,
+        onMessageDeletedByReqId,
+        onMessageDeleted,
+    ]);
 }
 
 function getThreadMessageListParams(params) {
@@ -402,7 +428,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [stores.sdkStore.initialized, staleParentMessage, anchorMessage, isReactionEnabled]);
+    }); }, [
+        stores.sdkStore.initialized,
+        staleParentMessage,
+        anchorMessage,
+        isReactionEnabled,
+        initializeThreadListStart,
+        initializeThreadListSuccess,
+        initializeThreadListFailure,
+    ]);
     var loadPrevious = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_2, parentMessage, error_2;
         return __generator(this, function (_b) {
@@ -430,7 +464,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [threadListState, oldestMessageTimeStamp, isReactionEnabled, staleParentMessage]);
+    }); }, [
+        threadListState,
+        oldestMessageTimeStamp,
+        isReactionEnabled,
+        staleParentMessage,
+        getPrevMessagesStart,
+        getPrevMessagesSuccess,
+        getPrevMessagesFailure,
+    ]);
     var loadNext = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
         var params, _a, threadedMessages_3, parentMessage, error_3;
         return __generator(this, function (_b) {
@@ -458,7 +500,15 @@ var useThreadFetchers = function (_a) {
                 case 4: return [2 /*return*/];
             }
         });
-    }); }, [threadListState, latestMessageTimeStamp, isReactionEnabled, staleParentMessage]);
+    }); }, [
+        threadListState,
+        latestMessageTimeStamp,
+        isReactionEnabled,
+        staleParentMessage,
+        getNextMessagesStart,
+        getNextMessagesSuccess,
+        getNextMessagesFailure,
+    ]);
     return {
         initializeThreadFetcher: initialize,
         fetchPrevThreads: loadPrevious,
@@ -475,33 +525,33 @@ var useThread = function () {
     if (!store)
         throw new Error('useThread must be used within a ThreadProvider');
     // SendbirdStateContext config
-    var _c = useSendbird().state, stores = _c.stores, config = _c.config;
+    var config = useSendbird().state.config;
     var logger = config.logger, pubSub = config.pubSub;
     var isMentionEnabled = config.groupChannel.enableMention;
     var isReactionEnabled = config.groupChannel.enableReactions;
     var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var message = state.message, parentMessage = state.parentMessage, currentChannel = state.currentChannel, threadListState = state.threadListState, allThreadMessages = state.allThreadMessages, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage;
     var sendMessageStatusActions = {
-        sendMessageStart: function (message) { return store.setState(function (state) {
+        sendMessageStart: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: __spreadArray(__spreadArray([], state.localThreadMessages, true), [
                     message,
                 ], false) });
-        }); },
-        sendMessageSuccess: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        sendMessageSuccess: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { allThreadMessages: __spreadArray(__spreadArray([], state.allThreadMessages.filter(function (m) { return (!compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)); }), true), [
                     message,
                 ], false), localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)); }) });
-        }); },
-        sendMessageFailure: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        sendMessageFailure: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)
                     ? message
                     : m); }) });
-        }); },
-        resendMessageStart: function (message) { return store.setState(function (state) {
+        }); }, [store]),
+        resendMessageStart: useCallback(function (message) { return store.setState(function (state) {
             return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.map(function (m) { return (compareIds(m === null || m === void 0 ? void 0 : m.reqId, message === null || message === void 0 ? void 0 : message.reqId)
                     ? message
                     : m); }) });
-        }); },
+        }); }, [store]),
     };
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
     var sendMessageActions = {
@@ -549,28 +599,34 @@ var useThread = function () {
         }, { logger: logger, pubSub: pubSub }),
     };
     var messageModifiedActions = {
-        onMessageUpdated: function (channel, message) { return store.setState(function (state) {
-            var _a, _b, _c;
-            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
-                return state;
-            }
-            return __assign(__assign({}, state), { parentMessage: ((_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)
-                    ? message
-                    : state.parentMessage, allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.map(function (msg) { return (((msg === null || msg === void 0 ? void 0 : msg.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)) ? message : msg); }) });
-        }); },
-        onMessageDeleted: function (channel, messageId) { return store.setState(function (state) {
-            var _a, _b, _c, _d;
-            if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
-                return state;
-            }
-            if (((_b = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === messageId) {
-                return __assign(__assign({}, state), { parentMessage: null, parentMessageState: ParentMessageStateTypes.NIL, allThreadMessages: [] });
-            }
-            return __assign(__assign({}, state), { allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }), localThreadMessages: (_d = state.localThreadMessages) === null || _d === void 0 ? void 0 : _d.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }) });
-        }); },
-        onMessageDeletedByReqId: function (reqId) { return store.setState(function (state) {
-            return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m.reqId, reqId)); }) });
-        }); },
+        onMessageUpdated: useCallback(function (channel, message) {
+            store.setState(function (state) {
+                var _a, _b, _c;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                return __assign(__assign({}, state), { parentMessage: ((_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)
+                        ? message
+                        : state.parentMessage, allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.map(function (msg) { return (((msg === null || msg === void 0 ? void 0 : msg.messageId) === (message === null || message === void 0 ? void 0 : message.messageId)) ? message : msg); }) });
+            });
+        }, [store]),
+        onMessageDeleted: useCallback(function (channel, messageId) {
+            store.setState(function (state) {
+                var _a, _b, _c, _d;
+                if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)) {
+                    return state;
+                }
+                if (((_b = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _b === void 0 ? void 0 : _b.messageId) === messageId) {
+                    return __assign(__assign({}, state), { parentMessage: null, parentMessageState: ParentMessageStateTypes.NIL, allThreadMessages: [] });
+                }
+                return __assign(__assign({}, state), { allThreadMessages: (_c = state.allThreadMessages) === null || _c === void 0 ? void 0 : _c.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }), localThreadMessages: (_d = state.localThreadMessages) === null || _d === void 0 ? void 0 : _d.filter(function (msg) { return ((msg === null || msg === void 0 ? void 0 : msg.messageId) !== messageId); }) });
+            });
+        }, [store]),
+        onMessageDeletedByReqId: useCallback(function (reqId) {
+            store.setState(function (state) {
+                return __assign(__assign({}, state), { localThreadMessages: state.localThreadMessages.filter(function (m) { return (!compareIds(m.reqId, reqId)); }) });
+            });
+        }, [store]),
     };
     var modifyMessageActions = {
         updateMessage: useUpdateMessageCallback({
@@ -585,40 +641,40 @@ var useThread = function () {
         }, { logger: logger }),
     };
     var threadFetcherStatusActions = {
-        initializeThreadListStart: function () { return store.setState(function (state) {
+        initializeThreadListStart: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        initializeThreadListSuccess: function (parentMessage, anchorMessage, threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        initializeThreadListSuccess: useCallback(function (parentMessage, anchorMessage, threadedMessages) { return store.setState(function (state) {
             var anchorMessageCreatedAt = (!(anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.messageId)) ? parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.createdAt : anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.createdAt;
             var anchorIndex = threadedMessages.findIndex(function (message) { return (message === null || message === void 0 ? void 0 : message.createdAt) > anchorMessageCreatedAt; });
             var prevThreadMessages = anchorIndex > -1 ? threadedMessages.slice(0, anchorIndex) : threadedMessages;
             var anchorThreadMessage = (anchorMessage === null || anchorMessage === void 0 ? void 0 : anchorMessage.messageId) ? [anchorMessage] : [];
             var nextThreadMessages = anchorIndex > -1 ? threadedMessages.slice(anchorIndex) : [];
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.INITIALIZED, hasMorePrev: anchorIndex === -1 || anchorIndex === PREV_THREADS_FETCH_SIZE, hasMoreNext: threadedMessages.length - anchorIndex === NEXT_THREADS_FETCH_SIZE, allThreadMessages: [prevThreadMessages, anchorThreadMessage, nextThreadMessages].flat() });
-        }); },
-        initializeThreadListFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        initializeThreadListFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { threadListState: ThreadListStateTypes.LOADING, allThreadMessages: [] });
-        }); },
-        getPrevMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesStart: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); },
-        getPrevMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesSuccess: useCallback(function (threadedMessages) { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMorePrev: threadedMessages.length === PREV_THREADS_FETCH_SIZE, allThreadMessages: __spreadArray(__spreadArray([], threadedMessages, true), state.allThreadMessages, true) });
-        }); },
-        getPrevMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getPrevMessagesFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMorePrev: false });
-        }); },
-        getNextMessagesStart: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesStart: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); },
-        getNextMessagesSuccess: function (threadedMessages) { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesSuccess: useCallback(function (threadedMessages) { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMoreNext: threadedMessages.length === NEXT_THREADS_FETCH_SIZE, allThreadMessages: __spreadArray(__spreadArray([], state.allThreadMessages, true), threadedMessages, true) });
-        }); },
-        getNextMessagesFailure: function () { return store.setState(function (state) {
+        }); }, [store]),
+        getNextMessagesFailure: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { hasMoreNext: false });
-        }); },
+        }); }, [store]),
     };
-    var _d = useThreadFetchers({
+    var _c = useThreadFetchers({
         parentMessage: parentMessage,
         // anchorMessage should be null when parentMessage doesn't exist
         anchorMessage: (message === null || message === void 0 ? void 0 : message.messageId) !== (parentMessage === null || parentMessage === void 0 ? void 0 : parentMessage.messageId) ? message || undefined : undefined,
@@ -636,13 +692,22 @@ var useThread = function () {
         getNextMessagesStart: threadFetcherStatusActions.getNextMessagesStart,
         getNextMessagesSuccess: threadFetcherStatusActions.getNextMessagesSuccess,
         getNextMessagesFailure: threadFetcherStatusActions.getNextMessagesFailure,
-    }), initializeThreadFetcher = _d.initializeThreadFetcher, fetchPrevThreads = _d.fetchPrevThreads, fetchNextThreads = _d.fetchNextThreads;
-    var actions = useMemo(function () { return (__assign(__assign(__assign(__assign(__assign(__assign({ setCurrentUserId: function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, getChannelStart: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.LOADING, currentChannel: null })); }); }, getChannelSuccess: function (groupChannel) { return store.setState(function (state) {
+    }), initializeThreadFetcher = _c.initializeThreadFetcher, fetchPrevThreads = _c.fetchPrevThreads, fetchNextThreads = _c.fetchNextThreads;
+    var simpleActions = {
+        setCurrentUserId: useCallback(function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
+        getChannelStart: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.LOADING, currentChannel: null })); }); }, [store]),
+        getChannelSuccess: useCallback(function (groupChannel) { return store.setState(function (state) {
             var _a, _b;
             return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INITIALIZED, currentChannel: groupChannel, 
                 // only support in normal group channel
                 isMuted: ((_b = (_a = groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.members) === null || _a === void 0 ? void 0 : _a.find(function (member) { return (member === null || member === void 0 ? void 0 : member.userId) === state.currentUserId; })) === null || _b === void 0 ? void 0 : _b.isMuted) || false, isChannelFrozen: (groupChannel === null || groupChannel === void 0 ? void 0 : groupChannel.isFrozen) || false }));
-        }); }, getChannelFailure: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INVALID, currentChannel: null })); }); }, getParentMessageStart: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, getParentMessageSuccess: function (parentMessage) { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, getParentMessageFailure: function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, setEmojiContainer: function (emojiContainer) { return store.setState(function (state) { return (__assign(__assign({}, state), { emojiContainer: emojiContainer })); }); }, onMessageReceived: function (channel, message) { return store.setState(function (state) {
+        }); }, [store]),
+        getChannelFailure: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { channelState: ChannelStateTypes.INVALID, currentChannel: null })); }); }, [store]),
+        getParentMessageStart: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.LOADING, parentMessage: null })); }); }, [store]),
+        getParentMessageSuccess: useCallback(function (parentMessage) { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INITIALIZED, parentMessage: parentMessage })); }); }, [store]),
+        getParentMessageFailure: useCallback(function () { return store.setState(function (state) { return (__assign(__assign({}, state), { parentMessageState: ParentMessageStateTypes.INVALID, parentMessage: null })); }); }, [store]),
+        setEmojiContainer: useCallback(function (emojiContainer) { return store.setState(function (state) { return (__assign(__assign({}, state), { emojiContainer: emojiContainer })); }); }, [store]),
+        onMessageReceived: useCallback(function (channel, message) { return store.setState(function (state) {
             var _a, _b, _c, _d;
             if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url)
                 || state.hasMoreNext
@@ -655,7 +720,8 @@ var useThread = function () {
                     : __spreadArray(__spreadArray([], state.allThreadMessages.filter(function (m) { return (m === null || m === void 0 ? void 0 : m.reqId) !== (message === null || message === void 0 ? void 0 : message.reqId); }), true), [
                         message,
                     ], false) });
-        }); }, onReactionUpdated: function (reactionEvent) { return store.setState(function (state) {
+        }); }, [store]),
+        onReactionUpdated: useCallback(function (reactionEvent) { return store.setState(function (state) {
             var _a, _b, _c;
             if (((_a = state === null || state === void 0 ? void 0 : state.parentMessage) === null || _a === void 0 ? void 0 : _a.messageId) === (reactionEvent === null || reactionEvent === void 0 ? void 0 : reactionEvent.messageId)) {
                 (_c = (_b = state.parentMessage) === null || _b === void 0 ? void 0 : _b.applyReactionEvent) === null || _c === void 0 ? void 0 : _c.call(_b, reactionEvent);
@@ -668,41 +734,51 @@ var useThread = function () {
                     }
                     return m;
                 }) });
-        }); }, onUserMuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserMuted: useCallback(function (channel, user) { return store.setState(function (state) {
             var _a;
             if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
                 return state;
             }
             return __assign(__assign({}, state), { isMuted: true });
-        }); }, onUserUnmuted: function (channel, user) { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnmuted: useCallback(function (channel, user) { return store.setState(function (state) {
             var _a;
             if (((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url) !== (channel === null || channel === void 0 ? void 0 : channel.url) || state.currentUserId !== (user === null || user === void 0 ? void 0 : user.userId)) {
                 return state;
             }
             return __assign(__assign({}, state), { isMuted: false });
-        }); }, onUserBanned: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserBanned: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, onUserUnbanned: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserUnbanned: useCallback(function () { return store.setState(function (state) {
             return __assign({}, state);
-        }); }, onUserLeft: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onUserLeft: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { channelState: ChannelStateTypes.NIL, threadListState: ThreadListStateTypes.NIL, parentMessageState: ParentMessageStateTypes.NIL, currentChannel: null, parentMessage: null, allThreadMessages: [], hasMorePrev: false, hasMoreNext: false });
-        }); }, onChannelFrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelFrozen: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { isChannelFrozen: true });
-        }); }, onChannelUnfrozen: function () { return store.setState(function (state) {
+        }); }, [store]),
+        onChannelUnfrozen: useCallback(function () { return store.setState(function (state) {
             return __assign(__assign({}, state), { isChannelFrozen: false });
-        }); }, onOperatorUpdated: function (channel) { return store.setState(function (state) {
+        }); }, [store]),
+        onOperatorUpdated: useCallback(function (channel) { return store.setState(function (state) {
             var _a;
             if ((channel === null || channel === void 0 ? void 0 : channel.url) === ((_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
                 return __assign(__assign({}, state), { currentChannel: channel });
             }
             return state;
-        }); }, onTypingStatusUpdated: function (channel, typingMembers) { return store.setState(function (state) {
+        }); }, [store]),
+        onTypingStatusUpdated: useCallback(function (channel, typingMembers) { return store.setState(function (state) {
             var _a;
             if (!compareIds(channel.url, (_a = state.currentChannel) === null || _a === void 0 ? void 0 : _a.url)) {
                 return state;
             }
             return __assign(__assign({}, state), { typingMembers: typingMembers });
-        }); }, onFileInfoUpdated: function (_a) {
+        }); }, [store]),
+        onFileInfoUpdated: useCallback(function (_a) {
             var channelUrl = _a.channelUrl, requestId = _a.requestId, index = _a.index, uploadableFileInfo = _a.uploadableFileInfo, error = _a.error;
             return store.setState(function (state) {
                 var _a, _b;
@@ -724,14 +800,19 @@ var useThread = function () {
                 }
                 return __assign(__assign({}, state), { localThreadMessages: localThreadMessages });
             });
-        }, toggleReaction: toggleReaction }, sendMessageStatusActions), sendMessageActions), messageModifiedActions), modifyMessageActions), threadFetcherStatusActions), { initializeThreadFetcher: initializeThreadFetcher, fetchPrevThreads: fetchPrevThreads, fetchNextThreads: fetchNextThreads })); }, [
-        store,
-        currentChannel,
-        stores.sdkStore.initialized,
-        parentMessage,
-        threadListState,
-        isReactionEnabled,
-        logger,
+        }, [store]),
+    };
+    var actions = useMemo(function () { return (__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, simpleActions), { toggleReaction: toggleReaction }), sendMessageStatusActions), sendMessageActions), messageModifiedActions), modifyMessageActions), threadFetcherStatusActions), { initializeThreadFetcher: initializeThreadFetcher, fetchPrevThreads: fetchPrevThreads, fetchNextThreads: fetchNextThreads })); }, [
+        simpleActions,
+        toggleReaction,
+        sendMessageStatusActions,
+        sendMessageActions,
+        messageModifiedActions,
+        modifyMessageActions,
+        threadFetcherStatusActions,
+        initializeThreadFetcher,
+        fetchPrevThreads,
+        fetchNextThreads,
     ]);
     return { state: state, actions: actions };
 };
@@ -1122,4 +1203,4 @@ var useThreadStore = function () {
 };
 
 export { InternalThreadProvider as I, ThreadContext as T, ThreadManager as a, ThreadProvider as b, useThreadContext as c, useThread as u };
-//# sourceMappingURL=bundle-D8H0ZPrd.js.map
+//# sourceMappingURL=bundle-BTjBE2da.js.map

package/{cjs/chunks/bundle-CcdVj36x.js.map → chunks/bundle-BTjBE2da.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-CcdVj36x.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-BTjBE2da.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-u76Ra-Rv.js → bundle-BYglDD-7.js}

@@ -1,9 +1,9 @@
-import { a as __spreadArray } from './bundle-BnjNXxxS.js';
+import { a as __spreadArray } from './bundle-x29pMq_W.js';
 import React__default from 'react';
 import ImageRenderer from '../ui/ImageRenderer.js';
-import { p as pxToNumber } from './bundle-BR7Yyb8z.js';
+import { p as pxToNumber } from './bundle-aOFNnyou.js';
 import Icon, { IconTypes, IconColors } from '../ui/Icon.js';
-import { c as classnames } from './bundle-BklklHAk.js';
+import { c as classnames } from './bundle-DsJtABvO.js';
 
 var AvatarDefault = function (props) {
     var width = props.width, height = props.height, text = props.text;
@@ -68,4 +68,4 @@ function Avatar(_a, ref) {
 var Avatar$1 = React__default.forwardRef(Avatar);
 
 export { Avatar$1 as A, AvatarDefault as a, AvatarInner as b };
-//# sourceMappingURL=bundle-u76Ra-Rv.js.map
+//# sourceMappingURL=bundle-BYglDD-7.js.map

package/chunks/bundle-BYglDD-7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-BYglDD-7.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-LNWRl39o.js → bundle-Ba9bINJK.js}

@@ -46,4 +46,4 @@ function useElementObserver(selector, targetElement) {
 }
 
 export { useElementObserver as u };
-//# sourceMappingURL=bundle-LNWRl39o.js.map
+//# sourceMappingURL=bundle-Ba9bINJK.js.map

package/chunks/bundle-Ba9bINJK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-Ba9bINJK.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-BOx7rtm2.js → bundle-BcC0QHfO.js}

@@ -1,4 +1,4 @@
 var MENTION_USER_LABEL_CLASSNAME = 'sendbird-mention-user-label';
 
 export { MENTION_USER_LABEL_CLASSNAME as M };
-//# sourceMappingURL=bundle-BOx7rtm2.js.map
+//# sourceMappingURL=bundle-BcC0QHfO.js.map

package/chunks/bundle-BcC0QHfO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-BcC0QHfO.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/chunks/{bundle-X-fgPUu9.js → bundle-BdINhwIh.js}

@@ -1,5 +1,5 @@
-import { c as isFileMessage, d as isMultipleFilesMessage } from './bundle-C_mnPe_T.js';
-import { K } from './bundle-D0HYQlWV.js';
+import { c as isFileMessage, d as isMultipleFilesMessage } from './bundle-DORK67AP.js';
+import { K } from './bundle-DdcnNQO1.js';
 
 function getMessageFirstFileType(message) {
     return K(message)
@@ -66,4 +66,4 @@ function getMessageFirstFileThumbnailUrl(message) {
 }
 
 export { getMessageFirstFileType as a, getMessageFirstFileName as b, getMessageFirstFileThumbnailUrl as c, getMessageFirstFileUrl as g };
-//# sourceMappingURL=bundle-X-fgPUu9.js.map
+//# sourceMappingURL=bundle-BdINhwIh.js.map

package/chunks/bundle-BdINhwIh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-BdINhwIh.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-D1LkTmeh.js → bundle-BhphRDus.js}

@@ -1,12 +1,12 @@
-import { a as __spreadArray, b as __awaiter, c as __generator, _ as __assign } from './bundle-BnjNXxxS.js';
-import { u as useStore, c as createStore, s as shimExports } from './bundle-CJh1zVrG.js';
+import { a as __spreadArray, b as __awaiter, c as __generator, _ as __assign } from './bundle-x29pMq_W.js';
+import { u as useStore, c as createStore, s as shimExports } from './bundle-Jsvq60lQ.js';
 import React__default, { useEffect, createContext, useState, useCallback, useRef, useContext, useMemo } from 'react';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-_B8tqfKV.js';
-import { c as compareIds } from './bundle-DvOO0iYB.js';
-import { c as classnames, d as deleteNullish } from './bundle-BklklHAk.js';
-import { U as UserProfileProvider } from './bundle-CgvBBPYd.js';
-import { u as useSendbird } from './bundle-BLEoxeBg.js';
+import { u as uuidv4 } from './bundle-BOY8Xuzt.js';
+import { c as compareIds } from './bundle-bEPz_Nb8.js';
+import { c as classnames, d as deleteNullish } from './bundle-DsJtABvO.js';
+import { U as UserProfileProvider } from './bundle-BBDSHxmx.js';
+import { u as useSendbird } from './bundle-Docu4wr7.js';
 
 function useSetChannel(_a) {
     var _this = this;
@@ -216,4 +216,4 @@ var useChannelSettings = function () {
 };
 
 export { ChannelSettingsContext as C, ChannelSettingsProvider as a, useChannelSettingsContext as b, useChannelSettings as u };
-//# sourceMappingURL=bundle-D1LkTmeh.js.map
+//# sourceMappingURL=bundle-BhphRDus.js.map

package/chunks/{bundle-D1LkTmeh.js.map → bundle-BhphRDus.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-D1LkTmeh.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-BhphRDus.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/chunks/{bundle-DtO5LHDy.js → bundle-BiLmBW-_.js}

@@ -1,13 +1,13 @@
-import { _ as __assign, d as __rest } from './bundle-BnjNXxxS.js';
+import { _ as __assign, d as __rest } from './bundle-x29pMq_W.js';
 import React__default, { useContext, useCallback, useMemo, useRef, useEffect } from 'react';
 import { GroupChannelFilter } from '@sendbird/chat/groupChannel';
 import { useGroupChannelList as useGroupChannelList$1, useGroupChannelHandler } from '@sendbird/uikit-tools';
-import { U as UserProfileProvider } from './bundle-CgvBBPYd.js';
-import { u as useOnlineStatus, a as useMarkAsDeliveredScheduler } from './bundle-DYVzi09R.js';
-import { s as shimExports, u as useStore, c as createStore } from './bundle-CJh1zVrG.js';
-import { d as deleteNullish, n as noop } from './bundle-BklklHAk.js';
-import { u as useSendbird } from './bundle-BLEoxeBg.js';
-import { u as useDeepCompareEffect } from './bundle-D2seSPWh.js';
+import { U as UserProfileProvider } from './bundle-BBDSHxmx.js';
+import { u as useOnlineStatus, a as useMarkAsDeliveredScheduler } from './bundle-C2tZ94u5.js';
+import { s as shimExports, u as useStore, c as createStore } from './bundle-Jsvq60lQ.js';
+import { d as deleteNullish, n as noop } from './bundle-DsJtABvO.js';
+import { u as useSendbird } from './bundle-Docu4wr7.js';
+import { u as useDeepCompareEffect } from './bundle-DmY-yaEG.js';
 
 var useGroupChannelList = function () {
     var store = useContext(GroupChannelListContext);
@@ -202,4 +202,4 @@ function getCollectionCreator(sdk, channelListQueryParams) {
 }
 
 export { GroupChannelListContext as G, useGroupChannelListStore as a, GroupChannelListManager as b, GroupChannelListProvider as c, useGroupChannelListContext as d, useGroupChannelList as u };
-//# sourceMappingURL=bundle-DtO5LHDy.js.map
+//# sourceMappingURL=bundle-BiLmBW-_.js.map

package/chunks/{bundle-DtO5LHDy.js.map → bundle-BiLmBW-_.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bundle-DtO5LHDy.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"bundle-BiLmBW-_.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}