@sendbird/uikit-react 3.14.11 → 3.14.12-rc.0

package/cjs/chunks/bundle-BIkirlfD.js

@@ -0,0 +1,282 @@
+'use strict';
+
+var _tslib = require('./bundle-CJ4C_lQr.js');
+var React = require('react');
+var SendbirdChat = require('@sendbird/chat');
+var openChannel = require('@sendbird/chat/openChannel');
+var useSendbirdStateContext = require('../useSendbirdStateContext.js');
+require('../withSendbird.js');
+var ui_ContextMenu = require('./bundle-6P-e5JVH.js');
+require('react-dom');
+var ui_IconButton = require('../ui/IconButton.js');
+require('./bundle-C5OtWVnd.js');
+var LocalizationContext = require('./bundle-DnchMcYp.js');
+var utils = require('./bundle-CxcGHjPH.js');
+var ui_Icon = require('../ui/Icon.js');
+
+// Utility function to handle processing state and promise execution
+var processToggleAction = function (isProcessing, action, errorHandler) { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+    var error_1;
+    return _tslib.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (isProcessing.current) {
+                    errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(new Error('Processing in progress'));
+                    return [2 /*return*/];
+                }
+                isProcessing.current = true;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, 4, 5]);
+                return [4 /*yield*/, action()];
+            case 2:
+                _a.sent();
+                return [3 /*break*/, 5];
+            case 3:
+                error_1 = _a.sent();
+                errorHandler === null || errorHandler === void 0 ? void 0 : errorHandler(error_1);
+                return [3 /*break*/, 5];
+            case 4:
+                isProcessing.current = false;
+                return [7 /*endfinally*/];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+var getInitialIsOperator = function (channel, user) {
+    if (!channel)
+        return false;
+    if (channel instanceof openChannel.OpenChannel) {
+        return channel.isOperator(user);
+    }
+    return (user === null || user === void 0 ? void 0 : user.role) === SendbirdChat.Role.OPERATOR;
+};
+var getInitialIsMuted = function (channel, user) {
+    return channel ? user === null || user === void 0 ? void 0 : user.isMuted : false;
+};
+var useToggleOperator = function (_a) {
+    var channel = _a.channel, user = _a.user, onToggleOperatorState = _a.onToggleOperatorState, _isOperator = _a.isOperator;
+    var _b = React.useState(_isOperator !== null && _isOperator !== void 0 ? _isOperator : getInitialIsOperator(channel, user)), isOperator = _b[0], setIsOperator = _b[1];
+    var isProcessing = React.useRef(false);
+    var toggleOperator = React.useCallback(function () {
+        // If channel is undefined, resolve immediately
+        if (!channel)
+            return Promise.resolve();
+        return processToggleAction(isProcessing, function () { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+            var togglePromise, newStatus;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        togglePromise = isOperator
+                            ? channel.removeOperators([user.userId])
+                            : channel.addOperators([user.userId]);
+                        return [4 /*yield*/, togglePromise];
+                    case 1:
+                        _a.sent();
+                        newStatus = !isOperator;
+                        setIsOperator(newStatus);
+                        onToggleOperatorState === null || onToggleOperatorState === void 0 ? void 0 : onToggleOperatorState({ user: user, newStatus: newStatus });
+                        return [2 /*return*/];
+                }
+            });
+        }); }, function (error) {
+            onToggleOperatorState === null || onToggleOperatorState === void 0 ? void 0 : onToggleOperatorState({ user: user, newStatus: isOperator, error: error });
+        });
+    }, [isOperator, channel.url, user.userId, onToggleOperatorState]);
+    return {
+        isOperator: isOperator,
+        toggleOperator: toggleOperator,
+    };
+};
+var useToggleMute = function (_a) {
+    var channel = _a.channel, user = _a.user, onToggleMuteState = _a.onToggleMuteState, _isMuted = _a.isMuted;
+    var _b = React.useState(_isMuted !== null && _isMuted !== void 0 ? _isMuted : getInitialIsMuted(channel, user)), isMuted = _b[0], setIsMuted = _b[1];
+    var isProcessing = React.useRef(false);
+    var toggleMute = React.useCallback(function () {
+        // If channel is undefined, resolve immediately
+        if (!channel)
+            return Promise.resolve();
+        return processToggleAction(isProcessing, function () { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+            var togglePromise, newStatus;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        togglePromise = isMuted
+                            ? channel.unmuteUser(user)
+                            : channel.muteUser(user);
+                        return [4 /*yield*/, togglePromise];
+                    case 1:
+                        _a.sent();
+                        newStatus = !isMuted;
+                        setIsMuted(newStatus);
+                        onToggleMuteState === null || onToggleMuteState === void 0 ? void 0 : onToggleMuteState({ user: user, newStatus: newStatus });
+                        return [2 /*return*/];
+                }
+            });
+        }); }, function (error) {
+            onToggleMuteState === null || onToggleMuteState === void 0 ? void 0 : onToggleMuteState({ user: user, newStatus: isMuted, error: error });
+        });
+    }, [isMuted, channel.url, user.userId, onToggleMuteState]);
+    return {
+        isMuted: isMuted,
+        toggleMute: toggleMute,
+    };
+};
+var useToggleBan = function (_a) {
+    var channel = _a.channel, user = _a.user, onToggleBanState = _a.onToggleBanState, _isBanned = _a.isBanned;
+    var _b = React.useState(_isBanned !== null && _isBanned !== void 0 ? _isBanned : false), isBanned = _b[0], setIsBanned = _b[1]; // Initially starting with false
+    var isProcessing = React.useRef(false);
+    var toggleBan = React.useCallback(function () {
+        // If channel is undefined, resolve immediately
+        if (!channel)
+            return Promise.resolve();
+        return processToggleAction(isProcessing, function () { return _tslib.__awaiter(void 0, void 0, void 0, function () {
+            var togglePromise, newStatus;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        togglePromise = isBanned
+                            ? channel.unbanUser(user)
+                            : channel.banUser(user);
+                        return [4 /*yield*/, togglePromise];
+                    case 1:
+                        _a.sent();
+                        newStatus = !isBanned;
+                        setIsBanned(newStatus);
+                        onToggleBanState === null || onToggleBanState === void 0 ? void 0 : onToggleBanState({ user: user, newStatus: newStatus });
+                        return [2 /*return*/];
+                }
+            });
+        }); }, function (error) {
+            onToggleBanState === null || onToggleBanState === void 0 ? void 0 : onToggleBanState({ user: user, newStatus: isBanned, error: error });
+        });
+    }, [isBanned, channel.url, user.userId, onToggleBanState]);
+    return {
+        isBanned: isBanned,
+        toggleBan: toggleBan,
+    };
+};
+
+var UserListItemMenuContext = React.createContext(undefined);
+var UserListItemMenuProvider = function (_a) {
+    var children = _a.children, values = _tslib.__rest(_a, ["children"]);
+    var config = useSendbirdStateContext.useSendbirdStateContext().config;
+    var currentUserId = config.userId;
+    var channel = values.channel, user = values.user;
+    var isCurrentUser = user.userId === currentUserId;
+    var isCurrentUserOperator = (function () {
+        if (!channel)
+            return false;
+        return channel instanceof openChannel.OpenChannel
+            ? channel.isOperator(currentUserId)
+            : channel.myRole === SendbirdChat.Role.OPERATOR;
+    })();
+    var operatorState = useToggleOperator(values);
+    var muteState = useToggleMute(values);
+    var banState = useToggleBan(values);
+    return (React.createElement(UserListItemMenuContext.Provider, { value: _tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign(_tslib.__assign({}, values), operatorState), muteState), banState), { isCurrentUser: isCurrentUser, isCurrentUserOperator: isCurrentUserOperator }) }, children));
+};
+var useUserListItemMenuContext = function () {
+    var context = React.useContext(UserListItemMenuContext);
+    if (!context) {
+        throw new Error('useUserListItemMenuContext must be used within a UserListItemMenuProvider.');
+    }
+    return context;
+};
+
+var OperatorToggleMenuItem = function (props) {
+    var _a;
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var _b = useUserListItemMenuContext(), isOperator = _b.isOperator, toggleOperator = _b.toggleOperator, isCurrentUser = _b.isCurrentUser, isCurrentUserOperator = _b.isCurrentUserOperator, hideMenu = _b.hideMenu;
+    if (!isCurrentUserOperator)
+        return React.createElement(React.Fragment, null);
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+            var _a;
+            (_a = props === null || props === void 0 ? void 0 : props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            toggleOperator();
+            hideMenu();
+        }, disabled: isCurrentUser }), (_a = props === null || props === void 0 ? void 0 : props.children) !== null && _a !== void 0 ? _a : (isOperator
+        ? stringSet.CHANNEL_SETTING__MODERATION__UNREGISTER_OPERATOR
+        : stringSet.CHANNEL_SETTING__MODERATION__REGISTER_AS_OPERATOR)));
+};
+var MuteToggleMenuItem = function (props) {
+    var _a;
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var _b = useUserListItemMenuContext(), isMuted = _b.isMuted, toggleMute = _b.toggleMute, isCurrentUserOperator = _b.isCurrentUserOperator, hideMenu = _b.hideMenu, channel = _b.channel;
+    if (!isCurrentUserOperator || (channel === null || channel === void 0 ? void 0 : channel.isBroadcast))
+        return React.createElement(React.Fragment, null);
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+            var _a;
+            (_a = props === null || props === void 0 ? void 0 : props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            toggleMute();
+            hideMenu();
+        } }), (_a = props === null || props === void 0 ? void 0 : props.children) !== null && _a !== void 0 ? _a : (isMuted
+        ? stringSet.CHANNEL_SETTING__MODERATION__UNMUTE
+        : stringSet.CHANNEL_SETTING__MODERATION__MUTE)));
+};
+var BanToggleMenuItem = function (props) {
+    var _a;
+    var stringSet = LocalizationContext.useLocalization().stringSet;
+    var _b = useUserListItemMenuContext(), isBanned = _b.isBanned, toggleBan = _b.toggleBan, isCurrentUserOperator = _b.isCurrentUserOperator, hideMenu = _b.hideMenu;
+    if (!isCurrentUserOperator)
+        return React.createElement(React.Fragment, null);
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+            var _a;
+            (_a = props === null || props === void 0 ? void 0 : props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, e);
+            toggleBan();
+            hideMenu();
+        } }), (_a = props === null || props === void 0 ? void 0 : props.children) !== null && _a !== void 0 ? _a : (isBanned
+        ? stringSet.CHANNEL_SETTING__MODERATION__UNBAN
+        : stringSet.CHANNEL_SETTING__MODERATION__BAN)));
+};
+
+var TriggerIcon = function (_a) {
+    var toggleMenu = _a.toggleMenu, ref = _a.ref;
+    return (React.createElement(ui_IconButton, { ref: ref, className: "sendbird-user-message__more__menu", width: "32px", height: "32px", onClick: toggleMenu },
+        React.createElement(ui_Icon.default, { width: "24px", height: "24px", type: ui_Icon.IconTypes.MORE, fillColor: ui_Icon.IconColors.CONTENT_INVERSE })));
+};
+var DefaultMenuItems = function (_a) {
+    var items = _a.items;
+    var OperatorToggleMenuItem = items.OperatorToggleMenuItem, MuteToggleMenuItem = items.MuteToggleMenuItem, BanToggleMenuItem = items.BanToggleMenuItem;
+    return (React.createElement(React.Fragment, null,
+        React.createElement(OperatorToggleMenuItem, null),
+        React.createElement(MuteToggleMenuItem, null),
+        React.createElement(BanToggleMenuItem, null)));
+};
+
+var UserListItemMenu = function (props) {
+    var user = props.user, className = props.className, _a = props.renderTrigger, renderTrigger = _a === void 0 ? TriggerIcon : _a, _b = props.renderMenuItems, renderMenuItems = _b === void 0 ? DefaultMenuItems : _b;
+    var _c = React.useState(false), isMenuVisible = _c[0], setMenuVisibility = _c[1];
+    var containerRef = React.useRef(null);
+    var triggerRef = React.useRef(null);
+    var config = useSendbirdStateContext.useSendbirdStateContext().config;
+    var currentUserId = config.userId;
+    var toggleMenu = function () {
+        setMenuVisibility(function (prev) { return !prev; });
+    };
+    var hideMenu = function () {
+        setMenuVisibility(false);
+    };
+    if (user.userId === currentUserId) {
+        return null;
+    }
+    return (React.createElement("div", { className: utils.classnames('sendbird-user-list-item-menu', className), ref: containerRef },
+        React.createElement(UserListItemMenuProvider, _tslib.__assign({}, props, { hideMenu: hideMenu, toggleMenu: toggleMenu }),
+            renderTrigger({ ref: triggerRef, toggleMenu: toggleMenu }),
+            isMenuVisible && (React.createElement(ui_ContextMenu.MenuItems
+            // TODO: Add id using getObservingId for useElementObserver
+            , { 
+                // TODO: Add id using getObservingId for useElementObserver
+                parentRef: triggerRef, parentContainRef: containerRef, closeDropdown: hideMenu }, renderMenuItems({
+                items: {
+                    OperatorToggleMenuItem: OperatorToggleMenuItem,
+                    MuteToggleMenuItem: MuteToggleMenuItem,
+                    BanToggleMenuItem: BanToggleMenuItem,
+                },
+            }))))));
+};
+
+exports.UserListItemMenu = UserListItemMenu;
+exports.UserListItemMenuProvider = UserListItemMenuProvider;
+exports.useUserListItemMenuContext = useUserListItemMenuContext;
+//# sourceMappingURL=bundle-BIkirlfD.js.map

package/cjs/chunks/bundle-BIkirlfD.js.map

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

package/cjs/chunks/{bundle-BJhptwu1.js → bundle-BJ05z7T7.js}

@@ -1,15 +1,14 @@
 'use strict';
 
 var React = require('react');
-var utils = require('./bundle-Cslxj9Oh.js');
+var utils = require('./bundle-CxcGHjPH.js');
 var useSendbirdStateContext = require('../useSendbirdStateContext.js');
-var ui_ContextMenu = require('../ui/ContextMenu.js');
-var _tslib = require('./bundle-BOmwadBI.js');
+var ui_ContextMenu = require('./bundle-6P-e5JVH.js');
+var _tslib = require('./bundle-CJ4C_lQr.js');
 var ui_IconButton = require('../ui/IconButton.js');
 var ui_Icon = require('../ui/Icon.js');
-var index = require('./bundle-CuZz1sho.js');
-var LocalizationContext = require('./bundle-NcZ2-bR4.js');
-var BasicItems = require('./bundle-CFvyDIVa.js');
+var index = require('./bundle-C5OtWVnd.js');
+var LocalizationContext = require('./bundle-DnchMcYp.js');
 var SendbirdChat = require('@sendbird/chat');
 
 var TriggerIcon = function (_a) {
@@ -24,8 +23,8 @@ var TriggerIcon = function (_a) {
 var CopyMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
             var _a;
             if (index.isUserMessage(message))
                 index.copyToClipboard(message.message);
@@ -36,8 +35,8 @@ var CopyMenuItem = function (props) {
 var ReplyMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, setQuoteMessage = _b.setQuoteMessage;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { disabled: message.parentMessageId > 0, onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, setQuoteMessage = _b.setQuoteMessage;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { disabled: message.parentMessageId > 0, onClick: function (e) {
             var _a;
             setQuoteMessage(message);
             hideMenu();
@@ -47,8 +46,8 @@ var ReplyMenuItem = function (props) {
 var ThreadMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, onReplyInThread = _b.onReplyInThread;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, onReplyInThread = _b.onReplyInThread;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
             var _a;
             onReplyInThread({ message: message });
             hideMenu();
@@ -58,8 +57,8 @@ var ThreadMenuItem = function (props) {
 var OpenInChannelMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), hideMenu = _b.hideMenu, onMoveToParentMessage = _b.onMoveToParentMessage;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), hideMenu = _b.hideMenu, onMoveToParentMessage = _b.onMoveToParentMessage;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
             var _a;
             onMoveToParentMessage();
             hideMenu();
@@ -69,8 +68,8 @@ var OpenInChannelMenuItem = function (props) {
 var EditMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), hideMenu = _b.hideMenu, showEdit = _b.showEdit, isOnline = _b.isOnline;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), hideMenu = _b.hideMenu, showEdit = _b.showEdit, isOnline = _b.isOnline;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
             var _a;
             if (isOnline) {
                 showEdit(true);
@@ -82,8 +81,8 @@ var EditMenuItem = function (props) {
 var ResendMenuItem = function (props) {
     var _a;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _b = BasicItems.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, resendMessage = _b.resendMessage, isOnline = _b.isOnline;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
+    var _b = ui_ContextMenu.useMessageMenuContext(), message = _b.message, hideMenu = _b.hideMenu, resendMessage = _b.resendMessage, isOnline = _b.isOnline;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { onClick: function (e) {
             var _a;
             if (isOnline) {
                 resendMessage(message);
@@ -95,8 +94,8 @@ var ResendMenuItem = function (props) {
 var DeleteMenuItem = function (props) {
     var _a, _b, _c;
     var stringSet = LocalizationContext.useLocalization().stringSet;
-    var _d = BasicItems.useMessageMenuContext(), message = _d.message, hideMenu = _d.hideMenu, deleteMessage = _d.deleteMessage, showRemove = _d.showRemove, isOnline = _d.isOnline, disableDeleteMessage = _d.disableDeleteMessage;
-    return (React.createElement(BasicItems.MenuItem, _tslib.__assign({}, props, { disabled: typeof disableDeleteMessage === 'boolean'
+    var _d = ui_ContextMenu.useMessageMenuContext(), message = _d.message, hideMenu = _d.hideMenu, deleteMessage = _d.deleteMessage, showRemove = _d.showRemove, isOnline = _d.isOnline, disableDeleteMessage = _d.disableDeleteMessage;
+    return (React.createElement(ui_ContextMenu.MenuItem, _tslib.__assign({}, props, { disabled: typeof disableDeleteMessage === 'boolean'
             ? disableDeleteMessage
             : ((_b = (_a = message.threadInfo) === null || _a === void 0 ? void 0 : _a.replyCount) !== null && _b !== void 0 ? _b : 0) > 0, onClick: function (e) {
             var _a;
@@ -175,7 +174,7 @@ var MessageMenu = function (_a) {
         onMoveToParentMessage: onMoveToParentMessage,
     };
     return (React.createElement("div", { className: utils.classnames('sendbird-message-menu', className), ref: containerRef },
-        React.createElement(BasicItems.MessageMenuProvider, { value: {
+        React.createElement(ui_ContextMenu.MessageMenuProvider, { value: {
                 message: message,
                 hideMenu: hideMenu,
                 showMenu: showMenu,
@@ -214,4 +213,4 @@ var MessageMenu = function (_a) {
 };
 
 exports.MessageMenu = MessageMenu;
-//# sourceMappingURL=bundle-BJhptwu1.js.map
+//# sourceMappingURL=bundle-BJ05z7T7.js.map

package/cjs/chunks/bundle-BJ05z7T7.js.map

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

package/cjs/chunks/{bundle-BmEsvEI0.js → bundle-BJ4ap5Wm.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var index = require('./bundle-_ghqr1tN.js');
-var index$1 = require('./bundle-DSebafRU.js');
+var index = require('./bundle-CTGjIAK4.js');
+var index$1 = require('./bundle-BR99z-80.js');
 
 /**
  * @name isDate
@@ -1648,4 +1648,4 @@ function cleanEscapedString(input) {
 
 exports.format = format;
 exports.toInteger = toInteger;
-//# sourceMappingURL=bundle-BmEsvEI0.js.map
+//# sourceMappingURL=bundle-BJ4ap5Wm.js.map