mal-ui 0.1.3

package/dist/notifications/index.js

@@ -0,0 +1,1122 @@
+"use client";
+import {
+  require_prop_types
+} from "../chunks/index-w9ekv5h5.js";
+import {
+  createStore,
+  useStore
+} from "../chunks/index-6tm93gww.js";
+import {
+  Box,
+  Combination_default,
+  Notification,
+  OptionalPortal,
+  createVarsResolver,
+  factory,
+  getDefaultZIndex,
+  getStyleObject,
+  rem,
+  useMantineTheme,
+  useProps,
+  useStyles
+} from "../chunks/index-3ffbn0gc.js";
+import {
+  randomId,
+  useDidUpdate,
+  useDrag,
+  useForceUpdate,
+  useMergedRef,
+  useReducedMotion
+} from "../chunks/index-syjq3515.js";
+import {
+  __toESM
+} from "../chunks/index-mc01z7m9.js";
+
+// node_modules/@mantine/notifications/esm/notifications.store.mjs
+
+function getDistributedNotifications(data, defaultPosition, limit) {
+  const queue = [];
+  const notifications = [];
+  const count = {};
+  for (const item of data) {
+    const position = item.position || defaultPosition;
+    count[position] = count[position] || 0;
+    count[position] += 1;
+    if (count[position] <= limit)
+      notifications.push(item);
+    else
+      queue.push(item);
+  }
+  return {
+    notifications,
+    queue
+  };
+}
+var createNotificationsStore = () => createStore({
+  notifications: [],
+  queue: [],
+  defaultPosition: "bottom-right",
+  limit: 5
+});
+var notificationsStore = createNotificationsStore();
+var useNotifications = (store = notificationsStore) => useStore(store);
+function updateNotificationsState(store, update) {
+  const state = store.getState();
+  const updated = getDistributedNotifications(update([...state.notifications, ...state.queue]), state.defaultPosition, state.limit);
+  store.setState({
+    notifications: updated.notifications,
+    queue: updated.queue,
+    limit: state.limit,
+    defaultPosition: state.defaultPosition
+  });
+}
+function showNotification(notification, store = notificationsStore) {
+  const id = notification.id || randomId();
+  updateNotificationsState(store, (notifications) => {
+    if (notification.id && notifications.some((n) => n.id === notification.id))
+      return notifications;
+    return [...notifications, {
+      ...notification,
+      id
+    }];
+  });
+  return id;
+}
+function hideNotification(id, store = notificationsStore) {
+  updateNotificationsState(store, (notifications) => notifications.filter((notification) => {
+    if (notification.id === id) {
+      notification.onClose?.(notification);
+      return false;
+    }
+    return true;
+  }));
+  return id;
+}
+function updateNotification(notification, store = notificationsStore) {
+  updateNotificationsState(store, (notifications) => notifications.map((item) => {
+    if (item.id === notification.id)
+      return {
+        ...item,
+        ...notification
+      };
+    return item;
+  }));
+  return notification.id;
+}
+function cleanNotifications(store = notificationsStore) {
+  updateNotificationsState(store, () => []);
+}
+function cleanNotificationsQueue(store = notificationsStore) {
+  updateNotificationsState(store, (notifications) => notifications.slice(0, store.getState().limit));
+}
+var notifications = {
+  show: showNotification,
+  hide: hideNotification,
+  update: updateNotification,
+  clean: cleanNotifications,
+  cleanQueue: cleanNotificationsQueue,
+  updateState: updateNotificationsState
+};
+
+// node_modules/@mantine/notifications/esm/get-grouped-notifications/get-grouped-notifications.mjs
+
+var positions = [
+  "bottom-center",
+  "bottom-left",
+  "bottom-right",
+  "top-center",
+  "top-left",
+  "top-right"
+];
+function getGroupedNotifications(notifications2, defaultPosition) {
+  return notifications2.reduce((acc, notification) => {
+    acc[notification.position || defaultPosition].push(notification);
+    return acc;
+  }, positions.reduce((acc, item) => {
+    acc[item] = [];
+    return acc;
+  }, {}));
+}
+
+// node_modules/@mantine/notifications/esm/get-notification-state-styles.mjs
+
+var transforms = {
+  left: "translateX(-100%)",
+  right: "translateX(100%)",
+  "top-center": "translateY(-100%)",
+  "bottom-center": "translateY(100%)"
+};
+var noTransform = {
+  left: "translateX(0)",
+  right: "translateX(0)",
+  "top-center": "translateY(0)",
+  "bottom-center": "translateY(0)"
+};
+function getNotificationStateStyles({ state, maxHeight, position, transitionDuration }) {
+  const [vertical, horizontal] = position.split("-");
+  const property = horizontal === "center" ? `${vertical}-center` : horizontal;
+  const commonStyles = {
+    opacity: 0,
+    maxHeight,
+    transform: transforms[property],
+    transitionDuration: `${transitionDuration}ms, ${transitionDuration}ms, ${transitionDuration}ms`,
+    transitionTimingFunction: "cubic-bezier(.51,.3,0,1.21), cubic-bezier(.51,.3,0,1.21), linear",
+    transitionProperty: "opacity, transform, max-height"
+  };
+  const inState = {
+    opacity: 1,
+    transform: noTransform[property]
+  };
+  const outState = {
+    opacity: 0,
+    maxHeight: 0,
+    transform: transforms[property]
+  };
+  const transitionStyles = {
+    entering: inState,
+    entered: inState,
+    exiting: outState,
+    exited: outState
+  };
+  return {
+    ...commonStyles,
+    ...transitionStyles[state]
+  };
+}
+
+// node_modules/@mantine/notifications/esm/get-auto-close/get-auto-close.mjs
+
+function getAutoClose(autoClose, notificationAutoClose) {
+  if (typeof notificationAutoClose === "number")
+    return notificationAutoClose;
+  if (notificationAutoClose === false || autoClose === false)
+    return false;
+  return autoClose;
+}
+
+// node_modules/@mantine/notifications/esm/NotificationContainer.mjs
+import { useEffect, useEffectEvent, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+var SCROLL_DISMISS_RESET_TIMEOUT = 120;
+function NotificationContainer({ data, onHide, autoClose, transitionDuration, allowDragDismiss, allowScrollDismiss, paused, onHoverStart, onHoverEnd, ref, style, ...others }) {
+  const [offset, setOffset] = useState(0);
+  const [dismissed, setDismissed] = useState(false);
+  const [dismissDirection, setDismissDirection] = useState(1);
+  const [scrollDismissActive, setScrollDismissActive] = useState(false);
+  const theme = useMantineTheme();
+  const { autoClose: _autoClose, message, allowClose, position: _position, style: dataStyle, withCloseButton, onOpen: _onOpen, ...notificationProps } = data;
+  const autoCloseDuration = getAutoClose(autoClose, data.autoClose);
+  const autoCloseTimeout = useRef(-1);
+  const hideTimeout = useRef(-1);
+  const scrollDismissTimeout = useRef(-1);
+  const notificationRef = useRef(null);
+  const hoveredRef = useRef(false);
+  const offsetRef = useRef(0);
+  const isCloseDisabled = allowClose === false;
+  const cancelAutoClose = () => window.clearTimeout(autoCloseTimeout.current);
+  const cancelHide = () => window.clearTimeout(hideTimeout.current);
+  const cancelScrollDismissReset = () => window.clearTimeout(scrollDismissTimeout.current);
+  const setSwipeOffset = (value) => {
+    offsetRef.current = value;
+    setOffset(value);
+  };
+  const handleHide = () => {
+    onHide(data.id);
+    cancelAutoClose();
+    cancelHide();
+    cancelScrollDismissReset();
+  };
+  const handleAutoClose = () => {
+    if (dismissed || active || paused || hoveredRef.current || typeof autoCloseDuration !== "number")
+      return;
+    autoCloseTimeout.current = window.setTimeout(handleHide, autoCloseDuration);
+  };
+  const getExitOffset = (direction) => {
+    return direction * ((notificationRef.current?.offsetWidth ?? 440) + 40);
+  };
+  const shouldDismiss = (movement, velocity) => {
+    const width = notificationRef.current?.offsetWidth ?? 440;
+    return Math.abs(movement) > width * 0.35 || velocity > 0.5;
+  };
+  const resetSwipe = () => {
+    cancelScrollDismissReset();
+    setScrollDismissActive(false);
+    setSwipeOffset(0);
+  };
+  const dismissNotification = (direction) => {
+    setDismissDirection(direction);
+    setDismissed(true);
+    setScrollDismissActive(false);
+    setSwipeOffset(getExitOffset(direction));
+    cancelAutoClose();
+    cancelHide();
+    cancelScrollDismissReset();
+    hideTimeout.current = window.setTimeout(handleHide, transitionDuration);
+  };
+  const scheduleScrollDismissReset = () => {
+    cancelScrollDismissReset();
+    scrollDismissTimeout.current = window.setTimeout(() => {
+      setScrollDismissActive(false);
+      setSwipeOffset(0);
+      handleAutoClose();
+    }, SCROLL_DISMISS_RESET_TIMEOUT);
+  };
+  const { ref: dragRef, active } = useDrag((state) => {
+    if (dismissed)
+      return;
+    if (state.first)
+      cancelAutoClose();
+    if (state.last) {
+      if (state.tap || state.canceled) {
+        setSwipeOffset(0);
+        handleAutoClose();
+        return;
+      }
+      const movement = state.movement[0];
+      const direction = movement === 0 ? state.direction[0] === -1 ? -1 : 1 : movement > 0 ? 1 : -1;
+      if (shouldDismiss(movement, state.velocity[0]))
+        dismissNotification(direction);
+      else {
+        setSwipeOffset(0);
+        handleAutoClose();
+      }
+    } else
+      setSwipeOffset(state.movement[0]);
+  }, {
+    axis: "x",
+    threshold: 5,
+    filterTaps: true,
+    enabled: allowDragDismiss && !isCloseDisabled && !dismissed
+  });
+  const mergedRef = useMergedRef(ref, notificationRef, dragRef);
+  const resolvedStyle = getStyleObject(style, theme);
+  const resolvedDataStyle = getStyleObject(dataStyle, theme);
+  const baseStyle = {
+    ...resolvedStyle,
+    ...resolvedDataStyle
+  };
+  const baseOpacity = typeof baseStyle.opacity === "number" ? baseStyle.opacity : 1;
+  const swipeOpacity = dismissed ? 0 : 1 - Math.min(Math.abs(offset) / 200, 1) * 0.6;
+  const resolvedTransitionDuration = baseStyle.transitionDuration ?? `${transitionDuration}ms, ${transitionDuration}ms, ${transitionDuration}ms`;
+  const notificationStyle = {
+    ...baseStyle,
+    ["--notifications-state-transform"]: typeof baseStyle.transform === "string" ? baseStyle.transform : "translateX(0)",
+    ["--notifications-state-opacity"]: String(baseOpacity),
+    ["--notifications-swipe-offset"]: `${offset}px`,
+    ["--notifications-swipe-opacity"]: String(swipeOpacity),
+    transform: "var(--notifications-state-transform) translate3d(var(--notifications-swipe-offset), 0, 0)",
+    opacity: "calc(var(--notifications-state-opacity) * var(--notifications-swipe-opacity))",
+    transitionDuration: active || scrollDismissActive ? "0ms, 0ms, 0ms" : resolvedTransitionDuration,
+    cursor: "default",
+    touchAction: "pan-y"
+  };
+  const handleMouseEnter = () => {
+    hoveredRef.current = true;
+    cancelAutoClose();
+    onHoverStart?.();
+  };
+  const handleMouseLeave = () => {
+    hoveredRef.current = false;
+    if (!scrollDismissActive) {
+      resetSwipe();
+      handleAutoClose();
+    }
+    onHoverEnd?.();
+  };
+  const handleWheel = useEffectEvent((event) => {
+    if (dismissed || active)
+      return;
+    const isDocumentEvent = event.currentTarget === document;
+    if (!isDocumentEvent && !hoveredRef.current)
+      return;
+    const { deltaX, deltaY } = event;
+    if (Math.abs(deltaX) <= Math.abs(deltaY) || deltaX === 0)
+      return;
+    if (!allowScrollDismiss || isCloseDisabled)
+      return;
+    if (!isDocumentEvent) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    cancelAutoClose();
+    setScrollDismissActive(true);
+    const nextOffset = offsetRef.current - deltaX;
+    const direction = nextOffset > 0 ? 1 : -1;
+    if (shouldDismiss(nextOffset, 0)) {
+      dismissNotification(direction);
+      return;
+    }
+    setSwipeOffset(nextOffset);
+    scheduleScrollDismissReset();
+  });
+  useEffect(() => {
+    if (!scrollDismissActive)
+      return;
+    document.addEventListener("wheel", handleWheel, { passive: false });
+    return () => document.removeEventListener("wheel", handleWheel, { passive: false });
+  }, [scrollDismissActive]);
+  useEffect(() => {
+    const handleResize = () => {
+      if (dismissed)
+        setSwipeOffset(getExitOffset(dismissDirection));
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [dismissDirection, dismissed]);
+  useEffect(() => {
+    const node = notificationRef.current;
+    if (!node)
+      return;
+    node.addEventListener("wheel", handleWheel, { passive: false });
+    return () => node.removeEventListener("wheel", handleWheel, { passive: false });
+  }, []);
+  useEffect(() => {
+    return () => {
+      cancelHide();
+      cancelScrollDismissReset();
+    };
+  }, []);
+  useEffect(() => {
+    data.onOpen?.(data);
+  }, []);
+  useEffect(() => {
+    handleAutoClose();
+    return cancelAutoClose;
+  }, [
+    autoCloseDuration,
+    active,
+    dismissed
+  ]);
+  useEffect(() => {
+    if (paused)
+      cancelAutoClose();
+    else
+      handleAutoClose();
+    return cancelAutoClose;
+  }, [paused]);
+  return /* @__PURE__ */ jsx(Notification, {
+    ref: mergedRef,
+    ...others,
+    style: notificationStyle,
+    ...notificationProps,
+    withCloseButton: isCloseDisabled ? false : withCloseButton,
+    onClose: handleHide,
+    onMouseEnter: handleMouseEnter,
+    onMouseLeave: handleMouseLeave,
+    children: message
+  });
+}
+NotificationContainer.displayName = "@mantine/notifications/NotificationContainer";
+
+// node_modules/@mantine/notifications/esm/Notifications.module.mjs
+
+var Notifications_module_default = {
+  root: "m_b37d9ac7",
+  notification: "m_5ed0edd0"
+};
+
+// node_modules/@mantine/notifications/esm/Notifications.mjs
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+// node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+  if (r == null)
+    return {};
+  var t = {};
+  for (var n in r)
+    if ({}.hasOwnProperty.call(r, n)) {
+      if (e.indexOf(n) !== -1)
+        continue;
+      t[n] = r[n];
+    }
+  return t;
+}
+
+// node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1;e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t)
+        ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+// node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
+function _assertThisInitialized(e) {
+  if (e === undefined)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+
+// node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+    return t2.__proto__ = e2, t2;
+  }, _setPrototypeOf(t, e);
+}
+
+// node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+
+// node_modules/react-transition-group/esm/TransitionGroup.js
+var import_prop_types = __toESM(require_prop_types(), 1);
+import React2 from "react";
+
+// node_modules/react-transition-group/esm/TransitionGroupContext.js
+import React from "react";
+var TransitionGroupContext_default = React.createContext(null);
+
+// node_modules/react-transition-group/esm/utils/ChildMapping.js
+import { Children, cloneElement, isValidElement } from "react";
+function getChildMapping(children, mapFn) {
+  var mapper = function mapper2(child) {
+    return mapFn && isValidElement(child) ? mapFn(child) : child;
+  };
+  var result = Object.create(null);
+  if (children)
+    Children.map(children, function(c) {
+      return c;
+    }).forEach(function(child) {
+      result[child.key] = mapper(child);
+    });
+  return result;
+}
+function mergeChildMappings(prev, next) {
+  prev = prev || {};
+  next = next || {};
+  function getValueForKey(key) {
+    return key in next ? next[key] : prev[key];
+  }
+  var nextKeysPending = Object.create(null);
+  var pendingKeys = [];
+  for (var prevKey in prev) {
+    if (prevKey in next) {
+      if (pendingKeys.length) {
+        nextKeysPending[prevKey] = pendingKeys;
+        pendingKeys = [];
+      }
+    } else {
+      pendingKeys.push(prevKey);
+    }
+  }
+  var i;
+  var childMapping = {};
+  for (var nextKey in next) {
+    if (nextKeysPending[nextKey]) {
+      for (i = 0;i < nextKeysPending[nextKey].length; i++) {
+        var pendingNextKey = nextKeysPending[nextKey][i];
+        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
+      }
+    }
+    childMapping[nextKey] = getValueForKey(nextKey);
+  }
+  for (i = 0;i < pendingKeys.length; i++) {
+    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
+  }
+  return childMapping;
+}
+function getProp(child, prop, props) {
+  return props[prop] != null ? props[prop] : child.props[prop];
+}
+function getInitialChildMapping(props, onExited) {
+  return getChildMapping(props.children, function(child) {
+    return cloneElement(child, {
+      onExited: onExited.bind(null, child),
+      in: true,
+      appear: getProp(child, "appear", props),
+      enter: getProp(child, "enter", props),
+      exit: getProp(child, "exit", props)
+    });
+  });
+}
+function getNextChildMapping(nextProps, prevChildMapping, onExited) {
+  var nextChildMapping = getChildMapping(nextProps.children);
+  var children = mergeChildMappings(prevChildMapping, nextChildMapping);
+  Object.keys(children).forEach(function(key) {
+    var child = children[key];
+    if (!isValidElement(child))
+      return;
+    var hasPrev = key in prevChildMapping;
+    var hasNext = key in nextChildMapping;
+    var prevChild = prevChildMapping[key];
+    var isLeaving = isValidElement(prevChild) && !prevChild.props.in;
+    if (hasNext && (!hasPrev || isLeaving)) {
+      children[key] = cloneElement(child, {
+        onExited: onExited.bind(null, child),
+        in: true,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    } else if (!hasNext && hasPrev && !isLeaving) {
+      children[key] = cloneElement(child, {
+        in: false
+      });
+    } else if (hasNext && hasPrev && isValidElement(prevChild)) {
+      children[key] = cloneElement(child, {
+        onExited: onExited.bind(null, child),
+        in: prevChild.props.in,
+        exit: getProp(child, "exit", nextProps),
+        enter: getProp(child, "enter", nextProps)
+      });
+    }
+  });
+  return children;
+}
+
+// node_modules/react-transition-group/esm/TransitionGroup.js
+var values = Object.values || function(obj) {
+  return Object.keys(obj).map(function(k) {
+    return obj[k];
+  });
+};
+var defaultProps = {
+  component: "div",
+  childFactory: function childFactory(child) {
+    return child;
+  }
+};
+var TransitionGroup = /* @__PURE__ */ function(_React$Component) {
+  _inheritsLoose(TransitionGroup2, _React$Component);
+  function TransitionGroup2(props, context) {
+    var _this;
+    _this = _React$Component.call(this, props, context) || this;
+    var handleExited = _this.handleExited.bind(_assertThisInitialized(_this));
+    _this.state = {
+      contextValue: {
+        isMounting: true
+      },
+      handleExited,
+      firstRender: true
+    };
+    return _this;
+  }
+  var _proto = TransitionGroup2.prototype;
+  _proto.componentDidMount = function componentDidMount() {
+    this.mounted = true;
+    this.setState({
+      contextValue: {
+        isMounting: false
+      }
+    });
+  };
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.mounted = false;
+  };
+  TransitionGroup2.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
+    var { children: prevChildMapping, handleExited, firstRender } = _ref;
+    return {
+      children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),
+      firstRender: false
+    };
+  };
+  _proto.handleExited = function handleExited(child, node) {
+    var currentChildMapping = getChildMapping(this.props.children);
+    if (child.key in currentChildMapping)
+      return;
+    if (child.props.onExited) {
+      child.props.onExited(node);
+    }
+    if (this.mounted) {
+      this.setState(function(state) {
+        var children = _extends({}, state.children);
+        delete children[child.key];
+        return {
+          children
+        };
+      });
+    }
+  };
+  _proto.render = function render() {
+    var _this$props = this.props, Component = _this$props.component, childFactory2 = _this$props.childFactory, props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]);
+    var contextValue = this.state.contextValue;
+    var children = values(this.state.children).map(childFactory2);
+    delete props.appear;
+    delete props.enter;
+    delete props.exit;
+    if (Component === null) {
+      return /* @__PURE__ */ React2.createElement(TransitionGroupContext_default.Provider, {
+        value: contextValue
+      }, children);
+    }
+    return /* @__PURE__ */ React2.createElement(TransitionGroupContext_default.Provider, {
+      value: contextValue
+    }, /* @__PURE__ */ React2.createElement(Component, props, children));
+  };
+  return TransitionGroup2;
+}(React2.Component);
+TransitionGroup.propTypes = {
+  component: import_prop_types.default.any,
+  children: import_prop_types.default.node,
+  appear: import_prop_types.default.bool,
+  enter: import_prop_types.default.bool,
+  exit: import_prop_types.default.bool,
+  childFactory: import_prop_types.default.func
+};
+TransitionGroup.defaultProps = defaultProps;
+var TransitionGroup_default = TransitionGroup;
+// node_modules/react-transition-group/esm/Transition.js
+var import_prop_types3 = __toESM(require_prop_types(), 1);
+import React3 from "react";
+import ReactDOM from "react-dom";
+
+// node_modules/react-transition-group/esm/config.js
+var config_default = {
+  disabled: false
+};
+
+// node_modules/react-transition-group/esm/utils/PropTypes.js
+var import_prop_types2 = __toESM(require_prop_types(), 1);
+var timeoutsShape = import_prop_types2.default.oneOfType([import_prop_types2.default.number, import_prop_types2.default.shape({
+  enter: import_prop_types2.default.number,
+  exit: import_prop_types2.default.number,
+  appear: import_prop_types2.default.number
+}).isRequired]);
+var classNamesShape = import_prop_types2.default.oneOfType([import_prop_types2.default.string, import_prop_types2.default.shape({
+  enter: import_prop_types2.default.string,
+  exit: import_prop_types2.default.string,
+  active: import_prop_types2.default.string
+}), import_prop_types2.default.shape({
+  enter: import_prop_types2.default.string,
+  enterDone: import_prop_types2.default.string,
+  enterActive: import_prop_types2.default.string,
+  exit: import_prop_types2.default.string,
+  exitDone: import_prop_types2.default.string,
+  exitActive: import_prop_types2.default.string
+})]);
+
+// node_modules/react-transition-group/esm/utils/reflow.js
+var forceReflow = function forceReflow2(node) {
+  return node.scrollTop;
+};
+
+// node_modules/react-transition-group/esm/Transition.js
+var UNMOUNTED = "unmounted";
+var EXITED = "exited";
+var ENTERING = "entering";
+var ENTERED = "entered";
+var EXITING = "exiting";
+var Transition = /* @__PURE__ */ function(_React$Component) {
+  _inheritsLoose(Transition2, _React$Component);
+  function Transition2(props, context) {
+    var _this;
+    _this = _React$Component.call(this, props, context) || this;
+    var parentGroup = context;
+    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
+    var initialStatus;
+    _this.appearStatus = null;
+    if (props.in) {
+      if (appear) {
+        initialStatus = EXITED;
+        _this.appearStatus = ENTERING;
+      } else {
+        initialStatus = ENTERED;
+      }
+    } else {
+      if (props.unmountOnExit || props.mountOnEnter) {
+        initialStatus = UNMOUNTED;
+      } else {
+        initialStatus = EXITED;
+      }
+    }
+    _this.state = {
+      status: initialStatus
+    };
+    _this.nextCallback = null;
+    return _this;
+  }
+  Transition2.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
+    var nextIn = _ref.in;
+    if (nextIn && prevState.status === UNMOUNTED) {
+      return {
+        status: EXITED
+      };
+    }
+    return null;
+  };
+  var _proto = Transition2.prototype;
+  _proto.componentDidMount = function componentDidMount() {
+    this.updateStatus(true, this.appearStatus);
+  };
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var nextStatus = null;
+    if (prevProps !== this.props) {
+      var status = this.state.status;
+      if (this.props.in) {
+        if (status !== ENTERING && status !== ENTERED) {
+          nextStatus = ENTERING;
+        }
+      } else {
+        if (status === ENTERING || status === ENTERED) {
+          nextStatus = EXITING;
+        }
+      }
+    }
+    this.updateStatus(false, nextStatus);
+  };
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.cancelNextCallback();
+  };
+  _proto.getTimeouts = function getTimeouts() {
+    var timeout = this.props.timeout;
+    var exit, enter, appear;
+    exit = enter = appear = timeout;
+    if (timeout != null && typeof timeout !== "number") {
+      exit = timeout.exit;
+      enter = timeout.enter;
+      appear = timeout.appear !== undefined ? timeout.appear : enter;
+    }
+    return {
+      exit,
+      enter,
+      appear
+    };
+  };
+  _proto.updateStatus = function updateStatus(mounting, nextStatus) {
+    if (mounting === undefined) {
+      mounting = false;
+    }
+    if (nextStatus !== null) {
+      this.cancelNextCallback();
+      if (nextStatus === ENTERING) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
+          if (node)
+            forceReflow(node);
+        }
+        this.performEnter(mounting);
+      } else {
+        this.performExit();
+      }
+    } else if (this.props.unmountOnExit && this.state.status === EXITED) {
+      this.setState({
+        status: UNMOUNTED
+      });
+    }
+  };
+  _proto.performEnter = function performEnter(mounting) {
+    var _this2 = this;
+    var enter = this.props.enter;
+    var appearing = this.context ? this.context.isMounting : mounting;
+    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing], maybeNode = _ref2[0], maybeAppearing = _ref2[1];
+    var timeouts = this.getTimeouts();
+    var enterTimeout = appearing ? timeouts.appear : timeouts.enter;
+    if (!mounting && !enter || config_default.disabled) {
+      this.safeSetState({
+        status: ENTERED
+      }, function() {
+        _this2.props.onEntered(maybeNode);
+      });
+      return;
+    }
+    this.props.onEnter(maybeNode, maybeAppearing);
+    this.safeSetState({
+      status: ENTERING
+    }, function() {
+      _this2.props.onEntering(maybeNode, maybeAppearing);
+      _this2.onTransitionEnd(enterTimeout, function() {
+        _this2.safeSetState({
+          status: ENTERED
+        }, function() {
+          _this2.props.onEntered(maybeNode, maybeAppearing);
+        });
+      });
+    });
+  };
+  _proto.performExit = function performExit() {
+    var _this3 = this;
+    var exit = this.props.exit;
+    var timeouts = this.getTimeouts();
+    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this);
+    if (!exit || config_default.disabled) {
+      this.safeSetState({
+        status: EXITED
+      }, function() {
+        _this3.props.onExited(maybeNode);
+      });
+      return;
+    }
+    this.props.onExit(maybeNode);
+    this.safeSetState({
+      status: EXITING
+    }, function() {
+      _this3.props.onExiting(maybeNode);
+      _this3.onTransitionEnd(timeouts.exit, function() {
+        _this3.safeSetState({
+          status: EXITED
+        }, function() {
+          _this3.props.onExited(maybeNode);
+        });
+      });
+    });
+  };
+  _proto.cancelNextCallback = function cancelNextCallback() {
+    if (this.nextCallback !== null) {
+      this.nextCallback.cancel();
+      this.nextCallback = null;
+    }
+  };
+  _proto.safeSetState = function safeSetState(nextState, callback) {
+    callback = this.setNextCallback(callback);
+    this.setState(nextState, callback);
+  };
+  _proto.setNextCallback = function setNextCallback(callback) {
+    var _this4 = this;
+    var active = true;
+    this.nextCallback = function(event) {
+      if (active) {
+        active = false;
+        _this4.nextCallback = null;
+        callback(event);
+      }
+    };
+    this.nextCallback.cancel = function() {
+      active = false;
+    };
+    return this.nextCallback;
+  };
+  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {
+    this.setNextCallback(handler);
+    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);
+    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;
+    if (!node || doesNotHaveTimeoutOrListener) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback], maybeNode = _ref3[0], maybeNextCallback = _ref3[1];
+      this.props.addEndListener(maybeNode, maybeNextCallback);
+    }
+    if (timeout != null) {
+      setTimeout(this.nextCallback, timeout);
+    }
+  };
+  _proto.render = function render() {
+    var status = this.state.status;
+    if (status === UNMOUNTED) {
+      return null;
+    }
+    var _this$props = this.props, children = _this$props.children, _in = _this$props.in, _mountOnEnter = _this$props.mountOnEnter, _unmountOnExit = _this$props.unmountOnExit, _appear = _this$props.appear, _enter = _this$props.enter, _exit = _this$props.exit, _timeout = _this$props.timeout, _addEndListener = _this$props.addEndListener, _onEnter = _this$props.onEnter, _onEntering = _this$props.onEntering, _onEntered = _this$props.onEntered, _onExit = _this$props.onExit, _onExiting = _this$props.onExiting, _onExited = _this$props.onExited, _nodeRef = _this$props.nodeRef, childProps = _objectWithoutPropertiesLoose(_this$props, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return /* @__PURE__ */ React3.createElement(TransitionGroupContext_default.Provider, {
+      value: null
+    }, typeof children === "function" ? children(status, childProps) : React3.cloneElement(React3.Children.only(children), childProps));
+  };
+  return Transition2;
+}(React3.Component);
+Transition.contextType = TransitionGroupContext_default;
+Transition.propTypes = {
+  nodeRef: import_prop_types3.default.shape({
+    current: typeof Element === "undefined" ? import_prop_types3.default.any : function(propValue, key, componentName, location, propFullName, secret) {
+      var value = propValue[key];
+      return import_prop_types3.default.instanceOf(value && "ownerDocument" in value ? value.ownerDocument.defaultView.Element : Element)(propValue, key, componentName, location, propFullName, secret);
+    }
+  }),
+  children: import_prop_types3.default.oneOfType([import_prop_types3.default.func.isRequired, import_prop_types3.default.element.isRequired]).isRequired,
+  in: import_prop_types3.default.bool,
+  mountOnEnter: import_prop_types3.default.bool,
+  unmountOnExit: import_prop_types3.default.bool,
+  appear: import_prop_types3.default.bool,
+  enter: import_prop_types3.default.bool,
+  exit: import_prop_types3.default.bool,
+  timeout: function timeout(props) {
+    var pt = timeoutsShape;
+    if (!props.addEndListener)
+      pt = pt.isRequired;
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1;_key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return pt.apply(undefined, [props].concat(args));
+  },
+  addEndListener: import_prop_types3.default.func,
+  onEnter: import_prop_types3.default.func,
+  onEntering: import_prop_types3.default.func,
+  onEntered: import_prop_types3.default.func,
+  onExit: import_prop_types3.default.func,
+  onExiting: import_prop_types3.default.func,
+  onExited: import_prop_types3.default.func
+};
+function noop() {}
+Transition.defaultProps = {
+  in: false,
+  mountOnEnter: false,
+  unmountOnExit: false,
+  appear: false,
+  enter: true,
+  exit: true,
+  onEnter: noop,
+  onEntering: noop,
+  onEntered: noop,
+  onExit: noop,
+  onExiting: noop,
+  onExited: noop
+};
+Transition.UNMOUNTED = UNMOUNTED;
+Transition.EXITED = EXITED;
+Transition.ENTERING = ENTERING;
+Transition.ENTERED = ENTERED;
+Transition.EXITING = EXITING;
+var Transition_default = Transition;
+// node_modules/@mantine/notifications/esm/Notifications.mjs
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+
+var Transition$1 = Transition_default;
+var defaultProps2 = {
+  position: "bottom-right",
+  autoClose: 4000,
+  transitionDuration: 250,
+  allowDragDismiss: true,
+  allowScrollDismiss: true,
+  containerWidth: 440,
+  notificationMaxHeight: 200,
+  limit: 5,
+  zIndex: getDefaultZIndex("overlay"),
+  store: notificationsStore,
+  withinPortal: true,
+  pauseResetOnHover: "all"
+};
+var varsResolver = createVarsResolver((_, { zIndex, containerWidth }) => ({ root: {
+  "--notifications-z-index": zIndex?.toString(),
+  "--notifications-container-width": rem(containerWidth)
+} }));
+var Notifications = factory((_props) => {
+  const props = useProps("Notifications", defaultProps2, _props);
+  const { classNames, className, style, styles, unstyled, vars, attributes, position, autoClose, transitionDuration, allowDragDismiss, allowScrollDismiss, containerWidth, notificationMaxHeight, limit, zIndex, store, portalProps, withinPortal, pauseResetOnHover, ...others } = props;
+  const theme = useMantineTheme();
+  const data = useNotifications(store);
+  const forceUpdate = useForceUpdate();
+  const shouldReduceMotion = useReducedMotion();
+  const refs = useRef2({});
+  const previousLength = useRef2(0);
+  const [hoveredCount, setHoveredCount] = useState2(0);
+  const handleHoverStart = useCallback(() => setHoveredCount((c) => c + 1), []);
+  const handleHoverEnd = useCallback(() => setHoveredCount((c) => Math.max(0, c - 1)), []);
+  const duration = (theme.respectReducedMotion ? shouldReduceMotion : false) ? 1 : transitionDuration;
+  const getStyles = useStyles({
+    name: "Notifications",
+    classes: Notifications_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver
+  });
+  useEffect2(() => {
+    store?.updateState((current) => ({
+      ...current,
+      limit: limit || 5,
+      defaultPosition: position
+    }));
+  }, [limit, position]);
+  useDidUpdate(() => {
+    if (data.notifications.length > previousLength.current)
+      setTimeout(() => forceUpdate(), 0);
+    previousLength.current = data.notifications.length;
+  }, [data.notifications]);
+  const grouped = getGroupedNotifications(data.notifications, position);
+  const groupedComponents = positions.reduce((acc, pos) => {
+    acc[pos] = grouped[pos].map(({ style: notificationStyle, ...notification }) => /* @__PURE__ */ jsx2(Transition$1, {
+      timeout: duration,
+      onEnter: () => refs.current[notification.id].offsetHeight,
+      nodeRef: { current: refs.current[notification.id] },
+      children: (state) => /* @__PURE__ */ jsx2(NotificationContainer, {
+        ref: (node) => {
+          if (node)
+            refs.current[notification.id] = node;
+        },
+        data: notification,
+        onHide: (id) => hideNotification(id, store),
+        autoClose,
+        transitionDuration: duration,
+        allowDragDismiss,
+        allowScrollDismiss,
+        paused: pauseResetOnHover === "all" ? hoveredCount > 0 : false,
+        onHoverStart: handleHoverStart,
+        onHoverEnd: handleHoverEnd,
+        ...getStyles("notification", { style: {
+          ...getNotificationStateStyles({
+            state,
+            position: pos,
+            transitionDuration: duration,
+            maxHeight: notificationMaxHeight
+          }),
+          ...notificationStyle
+        } })
+      })
+    }, notification.id));
+    return acc;
+  }, {});
+  return /* @__PURE__ */ jsxs(OptionalPortal, {
+    withinPortal,
+    ...portalProps,
+    children: [
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root"),
+        "data-position": "top-center",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["top-center"] })
+      }),
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root"),
+        "data-position": "top-left",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["top-left"] })
+      }),
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root", { className: Combination_default.classNames.fullWidth }),
+        "data-position": "top-right",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["top-right"] })
+      }),
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root", { className: Combination_default.classNames.fullWidth }),
+        "data-position": "bottom-right",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["bottom-right"] })
+      }),
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root"),
+        "data-position": "bottom-left",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["bottom-left"] })
+      }),
+      /* @__PURE__ */ jsx2(Box, {
+        ...getStyles("root"),
+        "data-position": "bottom-center",
+        ...others,
+        children: /* @__PURE__ */ jsx2(TransitionGroup_default, { children: groupedComponents["bottom-center"] })
+      })
+    ]
+  });
+});
+Notifications.classes = Notifications_module_default;
+Notifications.varsResolver = varsResolver;
+Notifications.displayName = "@mantine/notifications/Notifications";
+Notifications.show = notifications.show;
+Notifications.hide = notifications.hide;
+Notifications.update = notifications.update;
+Notifications.clean = notifications.clean;
+Notifications.cleanQueue = notifications.cleanQueue;
+Notifications.updateState = notifications.updateState;
+export {
+  useNotifications,
+  updateNotificationsState,
+  updateNotification,
+  showNotification,
+  notificationsStore,
+  notifications,
+  hideNotification,
+  createNotificationsStore,
+  cleanNotificationsQueue,
+  cleanNotifications,
+  Notifications
+};
+
+//# debugId=8F224AA7DDC64EF164756E2164756E21