@sendbird/uikit-react 3.18.4 → 3.19.0

package/chunks/{bundle-DcY3XClN.js → bundle-zr05FGgg.js}

@@ -1,19 +1,19 @@
-import { _ as __assign } from './bundle-hebhB-lR.js';
+import { a as __awaiter, c as __generator, _ as __assign } from './bundle-CgNaGvyD.js';
 import React__default, { useCallback, useMemo, useContext, useEffect, useRef } from 'react';
 import { MessageMetaArray, SendingStatus } from '@sendbird/chat/message';
-import { s as scrollIntoLast, c as compareIds, g as getNicknamesMapFromMembers, a as getParentMessageFrom } from './bundle-ma_Oj1DB.js';
-import { U as UserProfileProvider } from './bundle-AgXwAoAz.js';
-import { s as shimExports, a as createStore, b as useStore } from './bundle-BJVFYe-E.js';
+import { s as scrollIntoLast, c as compareIds, g as getNicknamesMapFromMembers, a as getParentMessageFrom } from './bundle-CGp1krs6.js';
+import { U as UserProfileProvider } from './bundle-DYdKHGhi.js';
+import { s as shimExports, a as createStore, b as useStore } from './bundle-CEkjWC64.js';
 import { ChannelType } from '@sendbird/chat';
 import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
-import { u as uuidv4 } from './bundle-lPT-nUNk.js';
-import { c as compareIds$1 } from './bundle-C4-sXsFT.js';
+import { u as uuidv4 } from './bundle-DcmkI5sy.js';
+import { c as compareIds$1 } from './bundle-e9cQcqMK.js';
 import { useGroupChannelThreadMessages } from '@sendbird/uikit-tools';
 import { ParentMessageStateTypes, ThreadListStateTypes, ChannelStateTypes } from '../Thread/context/types.js';
-import { u as useSendbird } from './bundle-5TPniY9G.js';
-import { u as useDeepCompareEffect } from './bundle-BNP3q1UD.js';
-import { p as pubSubTopics, a as PublishingModuleType } from './bundle-BOLGCL_I.js';
-import { f as META_ARRAY_VOICE_DURATION_KEY, e as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE, d as META_ARRAY_MESSAGE_TYPE_KEY, l as VOICE_MESSAGE_MIME_TYPE, V as VOICE_MESSAGE_FILE_NAME, g as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-wPF3Cnz3.js';
+import { u as useSendbird } from './bundle-Cbl5uBkV.js';
+import { u as useDeepCompareEffect } from './bundle-dMka1A5y.js';
+import { p as pubSubTopics, a as PublishingModuleType } from './bundle-CtPwLWv8.js';
+import { f as META_ARRAY_VOICE_DURATION_KEY, e as META_ARRAY_MESSAGE_TYPE_VALUE__VOICE, d as META_ARRAY_MESSAGE_TYPE_KEY, l as VOICE_MESSAGE_MIME_TYPE, V as VOICE_MESSAGE_FILE_NAME, g as SCROLL_BOTTOM_DELAY_FOR_SEND } from './bundle-DmYOmnB7.js';
 
 function useToggleReactionCallback(_a, _b) {
     var currentChannel = _a.currentChannel;
@@ -39,16 +39,18 @@ function useToggleReactionCallback(_a, _b) {
 var scrollToLastAfterSend = function () {
     setTimeout(function () { return scrollIntoLast(); }, SCROLL_BOTTOM_DELAY_FOR_SEND);
 };
-var attachLocalFilePreview = function (pendingMessage, file) {
+var attachLocalFilePreview = function (pendingMessage, file, localFilePreviews) {
     var localUrl = URL.createObjectURL(file);
     var localFileMessage = pendingMessage;
     localFileMessage.localUrl = localUrl;
     localFileMessage.file = file;
+    if (pendingMessage.reqId)
+        localFilePreviews.set(pendingMessage.reqId, { localUrl: localUrl, file: file });
     return localUrl;
 };
 function useThreadMessageActions(state, _a) {
     var logger = _a.logger, pubSub = _a.pubSub, isMentionEnabled = _a.isMentionEnabled;
-    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage;
+    var currentChannel = state.currentChannel, onBeforeSendUserMessage = state.onBeforeSendUserMessage, onBeforeSendFileMessage = state.onBeforeSendFileMessage, onBeforeSendVoiceMessage = state.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = state.onBeforeSendMultipleFilesMessage, dsSendUserMessage = state.dsSendUserMessage, dsSendFileMessage = state.dsSendFileMessage, dsSendMultipleFilesMessage = state.dsSendMultipleFilesMessage, dsUpdateUserMessage = state.dsUpdateUserMessage, dsResendMessage = state.dsResendMessage, dsDeleteMessage = state.dsDeleteMessage, localFilePreviews = state.localFilePreviews;
     var sendMessage = useCallback(function (props) {
         var _a;
         var message = props.message, quoteMessage = props.quoteMessage, mentionTemplate = props.mentionTemplate, mentionedUsers = props.mentionedUsers;
@@ -86,6 +88,15 @@ function useThreadMessageActions(state, _a) {
     }, [dsSendUserMessage, onBeforeSendUserMessage, currentChannel, isMentionEnabled]);
     var sendFileMessage = useCallback(function (file, quoteMessage) {
         var _a;
+        if (!dsSendFileMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending file message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending file message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendFileMessage: dsSendFileMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {};
             params.file = file;
@@ -96,17 +107,23 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendFileMessage === null || onBeforeSendFileMessage === void 0 ? void 0 : onBeforeSendFileMessage(file, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendFileMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending file message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         return dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -114,7 +131,7 @@ function useThreadMessageActions(state, _a) {
             });
             return sentMessage;
         });
-    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendFileMessage, currentChannel, localFilePreviews]);
     var sendVoiceMessage = useCallback(function (file, duration, quoteMessage) {
         var params = (onBeforeSendVoiceMessage && typeof onBeforeSendVoiceMessage === 'function')
             ? onBeforeSendVoiceMessage(file, quoteMessage)
@@ -135,13 +152,21 @@ function useThreadMessageActions(state, _a) {
             return;
         logger.info('Thread | useThreadMessageActions: Sending voice message start.', params);
         var localPreviewUrl;
+        var pendingReqId;
         dsSendFileMessage(params, function (pendingMessage) {
-            localPreviewUrl = attachLocalFilePreview(pendingMessage, file);
+            pendingReqId = pendingMessage.reqId;
+            localPreviewUrl = attachLocalFilePreview(pendingMessage, file, localFilePreviews);
             scrollToLastAfterSend();
         })
             .then(function (sentMessage) {
-            if (localPreviewUrl)
+            var preview = pendingReqId && localFilePreviews.get(pendingReqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(pendingReqId);
+            }
+            else if (localPreviewUrl) {
                 URL.revokeObjectURL(localPreviewUrl);
+            }
             pubSub.publish(pubSubTopics.SEND_FILE_MESSAGE, {
                 channel: currentChannel,
                 message: sentMessage,
@@ -151,9 +176,23 @@ function useThreadMessageActions(state, _a) {
             .catch(function (error) {
             logger.info('Thread | useThreadMessageActions: Sending voice message failed.', error);
         });
-    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel]);
+    }, [dsSendFileMessage, onBeforeSendVoiceMessage, currentChannel, localFilePreviews]);
     var sendMultipleFilesMessage = useCallback(function (files, quoteMessage) {
         var _a;
+        if (files.length <= 1) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message requires at least two files.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because there are no multiple files.', { files: files, error: error });
+            return Promise.reject(error);
+        }
+        if (!dsSendMultipleFilesMessage || !currentChannel) {
+            var error = new Error('Thread | useThreadMessageActions: Sending multiple files message cannot be sent because current channel or data source is unavailable.');
+            logger.warning('Thread | useThreadMessageActions: Sending multiple files message failed, because current channel or data source is unavailable.', {
+                currentChannel: currentChannel,
+                dsSendMultipleFilesMessage: dsSendMultipleFilesMessage,
+                error: error,
+            });
+            return Promise.reject(error);
+        }
         var createParamsDefault = function () {
             var params = {
                 fileInfoList: files.map(function (file) { return ({
@@ -170,8 +209,6 @@ function useThreadMessageActions(state, _a) {
             return params;
         };
         var params = (_a = onBeforeSendMultipleFilesMessage === null || onBeforeSendMultipleFilesMessage === void 0 ? void 0 : onBeforeSendMultipleFilesMessage(files, quoteMessage)) !== null && _a !== void 0 ? _a : createParamsDefault();
-        if (!dsSendMultipleFilesMessage || !currentChannel)
-            return Promise.resolve(null);
         logger.info('Thread | useThreadMessageActions: Sending multiple files message start.', params);
         return dsSendMultipleFilesMessage(params, function () { return scrollToLastAfterSend(); })
             .then(function (sentMessage) {
@@ -219,8 +256,25 @@ function useThreadMessageActions(state, _a) {
         if (!dsDeleteMessage)
             return Promise.resolve();
         logger.info('Thread | useThreadMessageActions: Deleting message.', message);
-        return dsDeleteMessage(message);
-    }, [dsDeleteMessage]);
+        return dsDeleteMessage(message)
+            .then(function () {
+            var preview = message.reqId && localFilePreviews.get(message.reqId);
+            if (preview) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(message.reqId);
+            }
+        })
+            .catch(function (error) {
+            if (message.sendingStatus !== SendingStatus.SUCCEEDED && currentChannel) {
+                var preview = message.reqId && localFilePreviews.get(message.reqId);
+                if (preview) {
+                    URL.revokeObjectURL(preview.localUrl);
+                    localFilePreviews.delete(message.reqId);
+                }
+            }
+            throw error;
+        });
+    }, [dsDeleteMessage, localFilePreviews, currentChannel]);
     var resendMessage = useCallback(function (failedMessage) {
         if (!(failedMessage === null || failedMessage === void 0 ? void 0 : failedMessage.isResendable) || !dsResendMessage || !currentChannel) {
             logger.warning('Thread | useThreadMessageActions: Message is not resendable.', failedMessage);
@@ -271,36 +325,117 @@ var useThread = function () {
     var state = shimExports.useSyncExternalStore(store.subscribe, store.getState);
     var currentChannel = state.currentChannel;
     var toggleReaction = useToggleReactionCallback({ currentChannel: currentChannel }, { logger: logger });
-    var initializeThreadFetcher = useCallback(function (callback) {
-        var _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
-        if (!resetWithStartingPoint)
-            return;
-        // Mirror ThreadProvider's initial startingPoint: anchor at the specific reply when entering from
-        // one, otherwise open at the latest edge (MAX). parentMessage.createdAt would anchor at the oldest
-        // edge (replies are created after the parent), hiding the latest replies behind hasMoreNext.
-        var startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
-            ? anchorMessage.createdAt
-            : Number.MAX_SAFE_INTEGER;
-        resetWithStartingPoint(startingPoint).then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    var initializeThreadFetcher = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, resetWithStartingPoint, anchorMessage, parentMessage, startingPoint, page, error_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = store.getState(), resetWithStartingPoint = _a.resetWithStartingPoint, anchorMessage = _a.message, parentMessage = _a.parentMessage;
+                    if (!resetWithStartingPoint)
+                        return [2 /*return*/];
+                    startingPoint = (anchorMessage && parentMessage && anchorMessage.messageId !== parentMessage.messageId)
+                        ? anchorMessage.createdAt
+                        : Number.MAX_SAFE_INTEGER;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, resetWithStartingPoint(startingPoint, function (messages) {
+                            page = messages;
+                        })];
+                case 2:
+                    _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _b.sent();
+                    logger.warning('Thread resetWithStartingPoint failed', error_1);
+                    return [2 /*return*/];
+                case 4:
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 5:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _b.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchPrevThreads = useCallback(function (callback) {
-        var loadPrevious = store.getState().loadPrevious;
-        if (!loadPrevious)
-            return;
-        loadPrevious().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store, logger]);
+    var fetchPrevThreads = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var loadPrevious, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadPrevious = store.getState().loadPrevious;
+                    if (!loadPrevious)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadPrevious(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
-    var fetchNextThreads = useCallback(function (callback) {
-        var loadNext = store.getState().loadNext;
-        if (!loadNext)
-            return;
-        loadNext().then(function () {
-            setTimeout(function () { return callback === null || callback === void 0 ? void 0 : callback(store.getState().allThreadMessages); });
+    }); }, [store]);
+    var fetchNextThreads = useCallback(function (callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var loadNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    loadNext = store.getState().loadNext;
+                    if (!loadNext)
+                        return [2 /*return*/];
+                    return [4 /*yield*/, loadNext(function (messages) {
+                            page = messages;
+                        })];
+                case 1:
+                    _a.sent();
+                    // onFetched fires only when the fetch succeeded (an empty page arrives as []), so `undefined`
+                    // means the load failed or was guarded upstream — settle without the callback (pre-v3.18.3 behavior).
+                    if (page === undefined)
+                        return [2 /*return*/];
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    return [4 /*yield*/, new Promise(function (resolve) {
+                            setTimeout(resolve);
+                        })];
+                case 2:
+                    // Deliberate one-tick deferral, do not remove: onFetched fires before the collection state is
+                    // mirrored into this store and before React commits the new replies, and ThreadUI's scroll
+                    // restoration in this callback expects to run after that render.
+                    _a.sent();
+                    callback === null || callback === void 0 ? void 0 : callback(page);
+                    return [2 /*return*/];
+            }
         });
-    }, [store]);
+    }); }, [store]);
     var messageActions = useThreadMessageActions(state, { logger: logger, pubSub: pubSub, isMentionEnabled: isMentionEnabled });
     var simpleActions = {
         setCurrentUserId: useCallback(function (currentUserId) { return store.setState(function (state) { return (__assign(__assign({}, state), { currentUserId: currentUserId })); }); }, [store]),
@@ -613,6 +748,7 @@ var initialState = function () { return ({
     currentUserId: '',
     typingMembers: [],
     nicknamesMap: null,
+    localFilePreviews: new Map(),
 }); };
 var ThreadContext = React__default.createContext(null);
 var createThreadStore = function (props) { return createStore(__assign(__assign({}, initialState()), props)); };
@@ -636,7 +772,7 @@ var InternalThreadProvider = function (props) {
 };
 var ThreadManager = function (props) {
     var message = props.message, channelUrl = props.channelUrl, onHeaderActionClick = props.onHeaderActionClick, onMoveToParentMessage = props.onMoveToParentMessage, onBeforeSendUserMessage = props.onBeforeSendUserMessage, onBeforeSendFileMessage = props.onBeforeSendFileMessage, onBeforeSendVoiceMessage = props.onBeforeSendVoiceMessage, onBeforeSendMultipleFilesMessage = props.onBeforeSendMultipleFilesMessage, onBeforeDownloadFileMessage = props.onBeforeDownloadFileMessage, isMultipleFilesMessageEnabled = props.isMultipleFilesMessageEnabled, filterEmojiCategoryIds = props.filterEmojiCategoryIds;
-    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState;
+    var _a = useThread().state, currentChannel = _a.currentChannel, parentMessage = _a.parentMessage, parentMessageState = _a.parentMessageState, localFilePreviews = _a.localFilePreviews;
     var updateState = useThreadStore().updateState;
     var propsParentMessage = getParentMessageFrom(message);
     // Context from SendbirdProvider
@@ -732,6 +868,13 @@ var ThreadManager = function (props) {
     var hasMorePrev = threadDataSource.hasPrevious();
     var hasMoreNext = threadDataSource.hasNext();
     var store = useContext(ThreadContext);
+    useEffect(function () {
+        return function () {
+            var previews = store === null || store === void 0 ? void 0 : store.getState().localFilePreviews;
+            previews === null || previews === void 0 ? void 0 : previews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            previews === null || previews === void 0 ? void 0 : previews.clear();
+        };
+    }, [store]);
     var messagesSyncKey = threadDataSource.messages
         .map(function (message) {
         var uploadParams = message.messageParams;
@@ -742,12 +885,30 @@ var ThreadManager = function (props) {
     })
         .join('~');
     useEffect(function () {
-        if (!parentMessage)
+        if (!parentMessage) {
+            localFilePreviews.forEach(function (preview) { return URL.revokeObjectURL(preview.localUrl); });
+            localFilePreviews.clear();
             return;
+        }
+        var scopedMessages = threadDataSource.messages;
+        scopedMessages.forEach(function (message) {
+            var _a, _b;
+            var sendableMessage = message;
+            var preview = localFilePreviews.get(sendableMessage.reqId);
+            if (!preview)
+                return;
+            if (sendableMessage.sendingStatus === SendingStatus.SUCCEEDED) {
+                URL.revokeObjectURL(preview.localUrl);
+                localFilePreviews.delete(sendableMessage.reqId);
+                return;
+            }
+            var localFileMessage = message;
+            (_a = localFileMessage.localUrl) !== null && _a !== void 0 ? _a : (localFileMessage.localUrl = preview.localUrl);
+            (_b = localFileMessage.file) !== null && _b !== void 0 ? _b : (localFileMessage.file = preview.file);
+        });
         // core-ts scopes the collection to this thread's replies (belongsToThread on the event/fetch and
         // send/resend paths), so mirror them as-is. Split into the legacy public shape: allThreadMessages =
         // succeeded (server) messages, localThreadMessages = pending/failed; threadMessages = all of them.
-        var scopedMessages = threadDataSource.messages;
         var localThreadMessages = scopedMessages.filter(function (m) {
             var sendingStatus = m.sendingStatus;
             return sendingStatus === SendingStatus.PENDING || sendingStatus === SendingStatus.FAILED;
@@ -809,4 +970,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-DcY3XClN.js.map
+//# sourceMappingURL=bundle-zr05FGgg.js.map

package/chunks/{bundle-DBi1PUnk.js.map → bundle-zr05FGgg.js.map}

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