@omnitron-dev/prism 0.1.1

package/dist/chunk-E3XANPTO.js

@@ -0,0 +1,2319 @@
+import { useIsClient } from './chunk-WC2WM2JD.js';
+import { PRESET_NAMES } from './chunk-DXXZ3ITR.js';
+import { useLayoutEffect, useEffect, useState, useRef, useCallback, useMemo, useSyncExternalStore } from 'react';
+import Popover from '@mui/material/Popover';
+import { styled, alpha } from '@mui/material/styles';
+import { listClasses } from '@mui/material/List';
+import { menuItemClasses } from '@mui/material/MenuItem';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function useAsync(asyncFn, options = {}) {
+  const { initialData = null, immediate = false, onSuccess, onError } = options;
+  const [state, setState] = useState({
+    data: initialData,
+    loading: immediate,
+    error: null
+  });
+  const isMounted = useRef(true);
+  const executingRef = useRef(false);
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  const execute = useCallback(
+    async (...args) => {
+      if (executingRef.current) {
+        return Promise.reject(new Error("Operation already in progress"));
+      }
+      executingRef.current = true;
+      if (isMounted.current) {
+        setState((prev) => ({ ...prev, loading: true, error: null }));
+      }
+      try {
+        const result = await asyncFn(...args);
+        if (isMounted.current) {
+          setState({ data: result, loading: false, error: null });
+          onSuccess?.(result);
+        }
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (isMounted.current) {
+          setState((prev) => ({ ...prev, loading: false, error }));
+          onError?.(error);
+        }
+        throw error;
+      } finally {
+        executingRef.current = false;
+      }
+    },
+    [asyncFn, onSuccess, onError]
+  );
+  const reset = useCallback(() => {
+    setState({ data: initialData, loading: false, error: null });
+  }, [initialData]);
+  const setData = useCallback((data) => {
+    setState((prev) => ({ ...prev, data }));
+  }, []);
+  const setError = useCallback((error) => {
+    setState((prev) => ({ ...prev, error }));
+  }, []);
+  useEffect(() => {
+    if (immediate) {
+      execute(...[]).catch(() => {
+      });
+    }
+  }, []);
+  return useMemo(
+    () => ({
+      ...state,
+      execute,
+      reset,
+      setData,
+      setError
+    }),
+    [state, execute, reset, setData, setError]
+  );
+}
+function useAsyncFn(asyncFn) {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const isMounted = useRef(true);
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  const execute = useCallback(
+    async (...args) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await asyncFn(...args);
+        if (isMounted.current) {
+          setLoading(false);
+        }
+        return result;
+      } catch (err) {
+        const caughtError = err instanceof Error ? err : new Error(String(err));
+        if (isMounted.current) {
+          setLoading(false);
+          setError(caughtError);
+        }
+        return void 0;
+      }
+    },
+    [asyncFn]
+  );
+  return { execute, loading, error };
+}
+function useScrollPosition(options = {}) {
+  const { element = null, throttle = 100, threshold = 0, bottomOffset = 10 } = options;
+  const [position, setPosition] = useState({
+    x: 0,
+    y: 0,
+    directionX: 0,
+    directionY: 0,
+    isScrolled: false,
+    isAtTop: true,
+    isAtBottom: false
+  });
+  const lastPosition = useRef({ x: 0, y: 0 });
+  const ticking = useRef(false);
+  const updatePosition = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const scrollX = element ? element.scrollLeft : window.scrollX;
+    const scrollY = element ? element.scrollTop : window.scrollY;
+    const maxScrollY = element ? element.scrollHeight - element.clientHeight : document.documentElement.scrollHeight - window.innerHeight;
+    const directionX = scrollX > lastPosition.current.x ? 1 : scrollX < lastPosition.current.x ? -1 : 0;
+    const directionY = scrollY > lastPosition.current.y ? 1 : scrollY < lastPosition.current.y ? -1 : 0;
+    lastPosition.current = { x: scrollX, y: scrollY };
+    setPosition({
+      x: scrollX,
+      y: scrollY,
+      directionX,
+      directionY,
+      isScrolled: scrollY > threshold,
+      isAtTop: scrollY <= 0,
+      isAtBottom: scrollY >= maxScrollY - bottomOffset
+    });
+    ticking.current = false;
+  }, [element, threshold, bottomOffset]);
+  const handleScroll = useCallback(() => {
+    if (!ticking.current) {
+      if (throttle > 0) {
+        window.requestAnimationFrame(() => {
+          updatePosition();
+        });
+      } else {
+        updatePosition();
+      }
+      ticking.current = true;
+      if (throttle > 0) {
+        setTimeout(() => {
+          ticking.current = false;
+        }, throttle);
+      }
+    }
+  }, [throttle, updatePosition]);
+  useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    const target = element ?? window;
+    updatePosition();
+    target.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      target.removeEventListener("scroll", handleScroll);
+    };
+  }, [element, handleScroll, updatePosition]);
+  return position;
+}
+function useScrollToTop(options = {}) {
+  const { threshold = 300 } = options;
+  const { y } = useScrollPosition({ threshold });
+  const scrollToTop = useCallback(() => {
+    window.scrollTo({ top: 0, behavior: "smooth" });
+  }, []);
+  return {
+    scrollToTop,
+    showButton: y > threshold
+  };
+}
+function useScrollLock() {
+  const [isLocked, setIsLocked] = useState(false);
+  const scrollY = useRef(0);
+  const lock = useCallback(() => {
+    if (typeof document === "undefined") return;
+    scrollY.current = window.scrollY;
+    document.body.style.position = "fixed";
+    document.body.style.top = `-${scrollY.current}px`;
+    document.body.style.width = "100%";
+    document.body.style.overflow = "hidden";
+    setIsLocked(true);
+  }, []);
+  const unlock = useCallback(() => {
+    if (typeof document === "undefined") return;
+    document.body.style.position = "";
+    document.body.style.top = "";
+    document.body.style.width = "";
+    document.body.style.overflow = "";
+    window.scrollTo(0, scrollY.current);
+    setIsLocked(false);
+  }, []);
+  useEffect(
+    () => () => {
+      if (isLocked) {
+        document.body.style.position = "";
+        document.body.style.top = "";
+        document.body.style.width = "";
+        document.body.style.overflow = "";
+      }
+    },
+    [isLocked]
+  );
+  return { lock, unlock, isLocked };
+}
+var defaultBreakpoints = {
+  xs: 0,
+  sm: 600,
+  md: 900,
+  lg: 1200,
+  xl: 1536
+};
+function useWindowSize(options = {}) {
+  const { breakpoints: customBreakpoints, debounce = 100, initialWidth = 1200, initialHeight = 800 } = options;
+  const breakpoints = { ...defaultBreakpoints, ...customBreakpoints };
+  const getSize = useCallback(() => {
+    if (typeof window === "undefined") {
+      return {
+        width: initialWidth,
+        height: initialHeight,
+        isMobile: initialWidth < breakpoints.sm,
+        isTablet: initialWidth >= breakpoints.sm && initialWidth < breakpoints.md,
+        isDesktop: initialWidth >= breakpoints.md,
+        isLargeDesktop: initialWidth >= breakpoints.lg
+      };
+    }
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    return {
+      width,
+      height,
+      isMobile: width < breakpoints.sm,
+      isTablet: width >= breakpoints.sm && width < breakpoints.md,
+      isDesktop: width >= breakpoints.md,
+      isLargeDesktop: width >= breakpoints.lg
+    };
+  }, [breakpoints.sm, breakpoints.md, breakpoints.lg, initialWidth, initialHeight]);
+  const [size, setSize] = useState(getSize);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    const handleResize = () => {
+      if (debounce > 0) {
+        if (timeoutRef.current) {
+          clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+          setSize(getSize());
+        }, debounce);
+      } else {
+        setSize(getSize());
+      }
+    };
+    setSize(getSize());
+    window.addEventListener("resize", handleResize);
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [debounce, getSize]);
+  return size;
+}
+function useResponsiveQuery(query) {
+  const [matches, setMatches] = useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query).matches;
+  });
+  useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    const mediaQuery = window.matchMedia(query);
+    const handleChange = (event) => {
+      setMatches(event.matches);
+    };
+    setMatches(mediaQuery.matches);
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handleChange);
+      return () => mediaQuery.removeEventListener("change", handleChange);
+    }
+    mediaQuery.addListener(handleChange);
+    return () => mediaQuery.removeListener(handleChange);
+  }, [query]);
+  return matches;
+}
+function useBreakpoint(customBreakpoints) {
+  const breakpoints = { ...defaultBreakpoints, ...customBreakpoints };
+  const { width } = useWindowSize({ breakpoints: customBreakpoints });
+  if (width >= breakpoints.xl) return "xl";
+  if (width >= breakpoints.lg) return "lg";
+  if (width >= breakpoints.md) return "md";
+  if (width >= breakpoints.sm) return "sm";
+  return "xs";
+}
+function useBreakpointChecks(customBreakpoints) {
+  const breakpoints = useMemo(() => ({ ...defaultBreakpoints, ...customBreakpoints }), [customBreakpoints]);
+  const { width } = useWindowSize({ breakpoints: customBreakpoints });
+  const orderedBreakpoints = ["xs", "sm", "md", "lg", "xl"];
+  const getNextBreakpoint = (bp) => {
+    const index = orderedBreakpoints.indexOf(bp);
+    return index < orderedBreakpoints.length - 1 ? orderedBreakpoints[index + 1] : null;
+  };
+  const isUp = useCallback(
+    (breakpoint) => width >= breakpoints[breakpoint],
+    [width, breakpoints]
+  );
+  const isDown = useCallback(
+    (breakpoint) => width < breakpoints[breakpoint],
+    [width, breakpoints]
+  );
+  const isOnly = useCallback(
+    (breakpoint) => {
+      const next = getNextBreakpoint(breakpoint);
+      const min = breakpoints[breakpoint];
+      const max = next ? breakpoints[next] : Infinity;
+      return width >= min && width < max;
+    },
+    [width, breakpoints]
+  );
+  const isBetween = useCallback(
+    (start, end) => width >= breakpoints[start] && width < breakpoints[end],
+    [width, breakpoints]
+  );
+  return { isUp, isDown, isOnly, isBetween };
+}
+var defaultValues = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  scrollWidth: 0,
+  scrollHeight: 0
+};
+function useClientRect(inputRef, eventType) {
+  const internalRef = useRef(null);
+  const elementRef = inputRef ?? internalRef;
+  const [rect, setRect] = useState(defaultValues);
+  const update = useCallback(() => {
+    const element = elementRef.current;
+    if (!element) {
+      setRect(defaultValues);
+      return;
+    }
+    const domRect = element.getBoundingClientRect();
+    setRect({
+      top: domRect.top,
+      right: domRect.right,
+      bottom: domRect.bottom,
+      left: domRect.left,
+      x: domRect.x,
+      y: domRect.y,
+      width: domRect.width,
+      height: domRect.height,
+      scrollWidth: element.scrollWidth,
+      scrollHeight: element.scrollHeight
+    });
+  }, [elementRef]);
+  useEffect(() => {
+    const element = elementRef.current;
+    update();
+    if (!element || typeof window === "undefined") return void 0;
+    const resizeObserver = new ResizeObserver(() => {
+      update();
+    });
+    resizeObserver.observe(element);
+    const target = eventType === "scroll" ? element : window;
+    const event = eventType ?? "resize";
+    const handleEvent = () => {
+      update();
+    };
+    target.addEventListener(event, handleEvent, { passive: true });
+    return () => {
+      resizeObserver.disconnect();
+      target.removeEventListener(event, handleEvent);
+    };
+  }, [elementRef, eventType, update]);
+  return {
+    ...rect,
+    elementRef,
+    update
+  };
+}
+function usePopoverHover(inputRef) {
+  const internalRef = useRef(null);
+  const elementRef = inputRef ?? internalRef;
+  const [open, setOpen] = useState(false);
+  const onOpen = useCallback(() => {
+    setOpen(true);
+  }, []);
+  const onClose = useCallback(() => {
+    setOpen(false);
+  }, []);
+  const anchorEl = open ? elementRef.current : null;
+  return {
+    open,
+    anchorEl,
+    onOpen,
+    onClose,
+    elementRef,
+    setOpen
+  };
+}
+var POPOVER_DISTANCE = 0.75;
+function calculateAnchorOrigin(arrow = "top-right") {
+  const configs = {
+    "top-left": {
+      paperStyles: { ml: -POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "bottom", horizontal: "left" },
+      transformOrigin: { vertical: "top", horizontal: "left" }
+    },
+    "top-center": {
+      paperStyles: void 0,
+      anchorOrigin: { vertical: "bottom", horizontal: "center" },
+      transformOrigin: { vertical: "top", horizontal: "center" }
+    },
+    "top-right": {
+      paperStyles: { ml: POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "bottom", horizontal: "right" },
+      transformOrigin: { vertical: "top", horizontal: "right" }
+    },
+    "bottom-left": {
+      paperStyles: { ml: -POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "top", horizontal: "left" },
+      transformOrigin: { vertical: "bottom", horizontal: "left" }
+    },
+    "bottom-center": {
+      paperStyles: void 0,
+      anchorOrigin: { vertical: "top", horizontal: "center" },
+      transformOrigin: { vertical: "bottom", horizontal: "center" }
+    },
+    "bottom-right": {
+      paperStyles: { ml: POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "top", horizontal: "right" },
+      transformOrigin: { vertical: "bottom", horizontal: "right" }
+    },
+    "left-top": {
+      paperStyles: { mt: -POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "top", horizontal: "right" },
+      transformOrigin: { vertical: "top", horizontal: "left" }
+    },
+    "left-center": {
+      paperStyles: void 0,
+      anchorOrigin: { vertical: "center", horizontal: "right" },
+      transformOrigin: { vertical: "center", horizontal: "left" }
+    },
+    "left-bottom": {
+      paperStyles: { mt: POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "bottom", horizontal: "right" },
+      transformOrigin: { vertical: "bottom", horizontal: "left" }
+    },
+    "right-top": {
+      paperStyles: { mt: -POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "top", horizontal: "left" },
+      transformOrigin: { vertical: "top", horizontal: "right" }
+    },
+    "right-center": {
+      paperStyles: void 0,
+      anchorOrigin: { vertical: "center", horizontal: "left" },
+      transformOrigin: { vertical: "center", horizontal: "right" }
+    },
+    "right-bottom": {
+      paperStyles: { mt: POPOVER_DISTANCE },
+      anchorOrigin: { vertical: "bottom", horizontal: "left" },
+      transformOrigin: { vertical: "bottom", horizontal: "right" }
+    }
+  };
+  return configs[arrow] || configs["top-right"];
+}
+var Arrow = styled("span", {
+  shouldForwardProp: (prop) => prop !== "ownerState"
+})(({ theme, ownerState }) => {
+  const { size, offset, placement } = ownerState;
+  const directions = {
+    top: { top: 0, rotate: "135deg", translate: "0 -50%" },
+    bottom: { bottom: 0, rotate: "-45deg", translate: "0 50%" },
+    left: { left: 0, rotate: "45deg", translate: "-50% 0" },
+    right: { right: 0, rotate: "-135deg", translate: "50% 0" }
+  };
+  const getDirection = () => {
+    if (placement.startsWith("top-")) return directions.top;
+    if (placement.startsWith("bottom-")) return directions.bottom;
+    if (placement.startsWith("left-")) return directions.left;
+    if (placement.startsWith("right-")) return directions.right;
+    return {};
+  };
+  const getPosition = () => {
+    if (placement.endsWith("-left")) return { left: offset };
+    if (placement.endsWith("-right")) return { right: offset };
+    if (placement.endsWith("-top")) return { top: offset };
+    if (placement.endsWith("-bottom")) return { bottom: offset };
+    if (placement.endsWith("-center")) {
+      if (placement.startsWith("top-") || placement.startsWith("bottom-")) {
+        return { left: 0, right: 0, margin: "auto" };
+      }
+      return { top: 0, bottom: 0, margin: "auto" };
+    }
+    return {};
+  };
+  return {
+    width: size,
+    height: size,
+    position: "absolute",
+    borderBottomLeftRadius: size / 4,
+    clipPath: "polygon(0% 0%, 100% 100%, 0% 100%)",
+    backgroundColor: theme.palette.background.paper,
+    border: `solid 1px ${alpha(theme.palette.grey[500], 0.12)}`,
+    ...getDirection(),
+    ...getPosition()
+  };
+});
+function CustomPopover({
+  open,
+  onClose,
+  children,
+  anchorEl,
+  arrow,
+  minWidth = 140,
+  slotProps,
+  ...other
+}) {
+  const arrowSize = arrow?.size ?? 14;
+  const arrowOffset = arrow?.offset ?? 17;
+  const arrowPlacement = arrow?.placement ?? "top-right";
+  const hideArrow = arrow?.hide ?? false;
+  const { paperStyles, anchorOrigin, transformOrigin } = calculateAnchorOrigin(arrowPlacement);
+  const isOpen = Boolean(open);
+  return /* @__PURE__ */ jsxs(
+    Popover,
+    {
+      open: isOpen,
+      anchorEl,
+      onClose,
+      anchorOrigin,
+      transformOrigin,
+      slotProps: {
+        ...slotProps,
+        paper: {
+          ...typeof slotProps?.paper === "object" ? slotProps.paper : {},
+          sx: [
+            paperStyles,
+            {
+              overflow: "inherit",
+              [`& .${listClasses.root}`]: { minWidth },
+              [`& .${menuItemClasses.root}`]: { gap: 2 }
+            },
+            ...typeof slotProps?.paper === "object" && slotProps.paper && "sx" in slotProps.paper ? Array.isArray(slotProps.paper.sx) ? slotProps.paper.sx : [slotProps.paper.sx] : []
+          ]
+        }
+      },
+      ...other,
+      children: [
+        !hideArrow && /* @__PURE__ */ jsx(
+          Arrow,
+          {
+            ownerState: {
+              size: arrowSize,
+              offset: arrowOffset,
+              placement: arrowPlacement
+            },
+            sx: arrow?.sx
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+function usePopover() {
+  const [anchorEl, setAnchorEl] = useState(null);
+  const onOpen = useCallback((event) => {
+    setAnchorEl(event.currentTarget);
+  }, []);
+  const onClose = useCallback(() => {
+    setAnchorEl(null);
+  }, []);
+  return {
+    open: Boolean(anchorEl),
+    anchorEl,
+    onOpen,
+    onClose,
+    setAnchorEl
+  };
+}
+
+// src/utils/cookies.ts
+function cookiesAvailable() {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  try {
+    document.cookie = "__test__=1";
+    const result = document.cookie.includes("__test__=1");
+    document.cookie = "__test__=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+    return result;
+  } catch {
+    return false;
+  }
+}
+function getCookie(key) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  try {
+    const name = `${key}=`;
+    const decodedCookie = decodeURIComponent(document.cookie);
+    const cookies = decodedCookie.split(";");
+    for (const cookie of cookies) {
+      const c = cookie.trim();
+      if (c.startsWith(name)) {
+        const value = c.substring(name.length);
+        return JSON.parse(value);
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setCookie(key, value, options = {}) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const { secure = false, daysUntilExpiration = 30, sameSite = "lax", domain, path = "/" } = options;
+  try {
+    const serializedValue = JSON.stringify(value);
+    let cookieString = `${key}=${encodeURIComponent(serializedValue)}`;
+    if (daysUntilExpiration) {
+      const date = /* @__PURE__ */ new Date();
+      date.setTime(date.getTime() + daysUntilExpiration * 24 * 60 * 60 * 1e3);
+      cookieString += `; expires=${date.toUTCString()}`;
+    }
+    cookieString += `; path=${path}`;
+    cookieString += `; SameSite=${sameSite}`;
+    if (secure) {
+      cookieString += "; Secure";
+    }
+    if (domain) {
+      cookieString += `; domain=${domain}`;
+    }
+    document.cookie = cookieString;
+  } catch (error) {
+    console.warn(`Failed to set cookie "${key}":`, error);
+  }
+}
+function removeCookie(key, options = {}) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const { domain, path = "/" } = options;
+  let cookieString = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path}`;
+  if (domain) {
+    cookieString += `; domain=${domain}`;
+  }
+  document.cookie = cookieString;
+}
+
+// src/hooks/use-cookies.ts
+function useCookies(key, initialState, options) {
+  const { initializeWithValue = true, ...cookieOptions } = options ?? {};
+  const [state, setStateInternal] = useState(initialState);
+  useEffect(() => {
+    const storedValue = getCookie(key);
+    const isObject = initialState !== null && typeof initialState === "object";
+    if (storedValue !== null) {
+      if (isObject) {
+        setStateInternal((prev) => ({ ...prev, ...storedValue }));
+      } else {
+        setStateInternal(storedValue);
+      }
+    } else if (initializeWithValue) {
+      setCookie(key, initialState, cookieOptions);
+    }
+  }, []);
+  const isObjectState = initialState !== null && typeof initialState === "object";
+  const updateState = useCallback(
+    (newState) => {
+      if (isObjectState) {
+        setStateInternal((prev) => {
+          const updatedState = { ...prev, ...newState };
+          setCookie(key, updatedState, cookieOptions);
+          return updatedState;
+        });
+      } else {
+        setCookie(key, newState, cookieOptions);
+        setStateInternal(newState);
+      }
+    },
+    [cookieOptions, isObjectState, key]
+  );
+  const updateField = useCallback(
+    (fieldName, updateValue) => {
+      if (isObjectState) {
+        updateState({ [fieldName]: updateValue });
+      } else {
+        console.warn("[useCookies] setField is only available for object states. Use setState instead.");
+      }
+    },
+    [isObjectState, updateState]
+  );
+  const resetState = useCallback(
+    (defaultState) => {
+      setStateInternal(defaultState ?? initialState);
+      removeCookie(key, { path: cookieOptions.path, domain: cookieOptions.domain });
+    },
+    [initialState, key, cookieOptions.path, cookieOptions.domain]
+  );
+  return useMemo(
+    () => ({
+      state,
+      setState: updateState,
+      setField: updateField,
+      resetState
+    }),
+    [state, updateState, updateField, resetState]
+  );
+}
+function useDoubleClick({ click, doubleClick, timeout = 250 }) {
+  const clickTimeout = useRef(null);
+  const clearClickTimeout = useCallback(() => {
+    if (clickTimeout.current) {
+      clearTimeout(clickTimeout.current);
+      clickTimeout.current = null;
+    }
+  }, []);
+  const handleEvent = useCallback(
+    (event) => {
+      clearClickTimeout();
+      if (click && event.detail === 1) {
+        clickTimeout.current = setTimeout(() => {
+          click(event);
+        }, timeout);
+      }
+      if (event.detail % 2 === 0) {
+        doubleClick(event);
+      }
+    },
+    [click, doubleClick, timeout, clearClickTimeout]
+  );
+  useEffect(
+    () => () => {
+      clearClickTimeout();
+    },
+    [clearClickTimeout]
+  );
+  return handleEvent;
+}
+function parseThreshold(input) {
+  if (typeof input === "string") {
+    if (!input.endsWith("%")) {
+      throw new Error('[useBackToTop] String threshold must end with % (e.g., "90%")');
+    }
+    const value = Number(input.slice(0, -1));
+    if (isNaN(value)) {
+      throw new Error("[useBackToTop] Invalid percentage value");
+    }
+    return { value, type: "percentage" };
+  }
+  return { value: input, type: "pixels" };
+}
+function useBackToTop(threshold = "90%", debounce = false) {
+  const [isVisible, setIsVisible] = useState(false);
+  const parsedThreshold = useMemo(() => parseThreshold(threshold), [threshold]);
+  const handleScroll = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const windowHeight = window.innerHeight;
+    const scrollY = Math.round(window.scrollY);
+    const documentHeight = document.body.offsetHeight;
+    const maxScroll = documentHeight - windowHeight;
+    const scrollProgress = maxScroll > 0 ? Math.round(scrollY / maxScroll * 100) : 0;
+    if (parsedThreshold.type === "percentage") {
+      setIsVisible(scrollProgress >= parsedThreshold.value);
+    } else {
+      const distanceFromBottom = documentHeight - windowHeight - scrollY;
+      setIsVisible(distanceFromBottom <= parsedThreshold.value);
+    }
+  }, [parsedThreshold]);
+  const debounceTimeoutRef = useRef(null);
+  const debouncedHandleScroll = useCallback(() => {
+    if (debounceTimeoutRef.current !== null) clearTimeout(debounceTimeoutRef.current);
+    debounceTimeoutRef.current = setTimeout(handleScroll, 100);
+  }, [handleScroll]);
+  useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    const scrollHandler = debounce ? debouncedHandleScroll : handleScroll;
+    handleScroll();
+    window.addEventListener("scroll", scrollHandler, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", scrollHandler);
+      if (debounceTimeoutRef.current !== null) clearTimeout(debounceTimeoutRef.current);
+    };
+  }, [debounce, debouncedHandleScroll, handleScroll]);
+  const onBackToTop = useCallback(() => {
+    if (typeof window === "undefined") return;
+    window.scrollTo({ top: 0, behavior: "smooth" });
+  }, []);
+  return { isVisible, onBackToTop, setIsVisible };
+}
+function useCountdownSeconds(initialSeconds) {
+  const [value, setValue] = useState(initialSeconds);
+  const [isCounting, setIsCounting] = useState(false);
+  const start = useCallback(() => {
+    setIsCounting(true);
+  }, []);
+  const reset = useCallback(() => {
+    setIsCounting(false);
+    setValue(initialSeconds);
+  }, [initialSeconds]);
+  useEffect(() => {
+    if (!isCounting) return void 0;
+    const intervalId = setInterval(() => {
+      setValue((prev) => {
+        if (prev <= 1) {
+          setIsCounting(false);
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1e3);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [isCounting]);
+  return useMemo(
+    () => ({
+      value,
+      setValue,
+      isCounting,
+      start,
+      reset
+    }),
+    [value, isCounting, start, reset]
+  );
+}
+function formatTime(value) {
+  return String(value).length === 1 ? `0${value}` : `${value}`;
+}
+function calculateTimeDifference(futureDate, currentDate) {
+  const distance = futureDate.getTime() - currentDate.getTime();
+  if (distance < 0) {
+    return { days: 0, hours: 0, minutes: 0, seconds: 0 };
+  }
+  return {
+    days: Math.floor(distance / (1e3 * 60 * 60 * 24)),
+    hours: Math.floor(distance % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60)),
+    minutes: Math.floor(distance % (1e3 * 60 * 60) / (1e3 * 60)),
+    seconds: Math.floor(distance % (1e3 * 60) / 1e3)
+  };
+}
+function useCountdownDate(targetDate, placeholder = "- -") {
+  const [value, setValue] = useState({
+    days: placeholder,
+    hours: placeholder,
+    minutes: placeholder,
+    seconds: placeholder
+  });
+  const handleUpdate = useCallback(() => {
+    const now = /* @__PURE__ */ new Date();
+    const { days, hours, minutes, seconds } = calculateTimeDifference(targetDate, now);
+    setValue({
+      days: formatTime(days),
+      hours: formatTime(hours),
+      minutes: formatTime(minutes),
+      seconds: formatTime(seconds)
+    });
+  }, [targetDate]);
+  useEffect(() => {
+    handleUpdate();
+    const interval = setInterval(handleUpdate, 1e3);
+    return () => clearInterval(interval);
+  }, [handleUpdate]);
+  return value;
+}
+function useScrollOffsetTop(defaultValue = 0) {
+  const elementRef = useRef(null);
+  const [offsetTop, setOffsetTop] = useState(false);
+  const handleScroll = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const windowScrollY = window.scrollY;
+    if (elementRef.current) {
+      const elementOffsetTop = elementRef.current.offsetTop;
+      setOffsetTop(windowScrollY > elementOffsetTop - defaultValue);
+    } else {
+      setOffsetTop(windowScrollY > defaultValue);
+    }
+  }, [defaultValue]);
+  useEffect(() => {
+    if (typeof window === "undefined") return void 0;
+    handleScroll();
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+    };
+  }, [handleScroll]);
+  return useMemo(
+    () => ({
+      elementRef,
+      offsetTop
+    }),
+    [offsetTop]
+  );
+}
+var DEFAULT_PARAM_NAMES = {
+  preset: "preset",
+  mode: "mode",
+  primary: "primary",
+  direction: "dir",
+  density: "density",
+  contrast: "contrast"
+};
+var VALID_MODES = ["light", "dark", "system"];
+var VALID_DIRECTIONS = ["ltr", "rtl"];
+var VALID_DENSITIES = ["compact", "standard", "comfortable"];
+var VALID_CONTRASTS = ["default", "high"];
+function isValidPreset(value) {
+  return value !== null && PRESET_NAMES.includes(value);
+}
+function isValidMode(value) {
+  return value !== null && VALID_MODES.includes(value);
+}
+function isValidDirection(value) {
+  return value !== null && VALID_DIRECTIONS.includes(value);
+}
+function isValidDensity(value) {
+  return value !== null && VALID_DENSITIES.includes(value);
+}
+function isValidContrast(value) {
+  return value !== null && VALID_CONTRASTS.includes(value);
+}
+function isValidHexColor(value) {
+  if (!value) return false;
+  return /^#[0-9A-Fa-f]{6}$/.test(value);
+}
+function useConfigFromQuery(options = {}) {
+  const { paramNames = DEFAULT_PARAM_NAMES, onConfigChange, syncToUrl = false } = options;
+  const params = { ...DEFAULT_PARAM_NAMES, ...paramNames };
+  const configFromUrl = useMemo(() => {
+    if (typeof window === "undefined") return {};
+    const searchParams = new URLSearchParams(window.location.search);
+    const config = {};
+    const presetValue = searchParams.get(params.preset);
+    if (isValidPreset(presetValue)) {
+      config.preset = presetValue;
+    }
+    const modeValue = searchParams.get(params.mode);
+    if (isValidMode(modeValue)) {
+      config.mode = modeValue;
+    }
+    const primaryValue = searchParams.get(params.primary);
+    if (isValidHexColor(primaryValue)) {
+      config.primary = primaryValue;
+    }
+    const directionValue = searchParams.get(params.direction);
+    if (isValidDirection(directionValue)) {
+      config.direction = directionValue;
+    }
+    const densityValue = searchParams.get(params.density);
+    if (isValidDensity(densityValue)) {
+      config.density = densityValue;
+    }
+    const contrastValue = searchParams.get(params.contrast);
+    if (isValidContrast(contrastValue)) {
+      config.contrast = contrastValue;
+    }
+    return config;
+  }, [params.preset, params.mode, params.primary, params.direction, params.density, params.contrast]);
+  useEffect(() => {
+    if (onConfigChange && Object.keys(configFromUrl).length > 0) {
+      onConfigChange(configFromUrl);
+    }
+  }, [configFromUrl, onConfigChange]);
+  const updateUrl = useCallback(
+    (values) => {
+      if (typeof window === "undefined") return;
+      const searchParams = new URLSearchParams(window.location.search);
+      if (values.preset !== void 0) {
+        if (values.preset) {
+          searchParams.set(params.preset, values.preset);
+        } else {
+          searchParams.delete(params.preset);
+        }
+      }
+      if (values.mode !== void 0) {
+        if (values.mode) {
+          searchParams.set(params.mode, values.mode);
+        } else {
+          searchParams.delete(params.mode);
+        }
+      }
+      if (values.primary !== void 0) {
+        if (values.primary) {
+          searchParams.set(params.primary, values.primary);
+        } else {
+          searchParams.delete(params.primary);
+        }
+      }
+      if (values.direction !== void 0) {
+        if (values.direction) {
+          searchParams.set(params.direction, values.direction);
+        } else {
+          searchParams.delete(params.direction);
+        }
+      }
+      if (values.density !== void 0) {
+        if (values.density) {
+          searchParams.set(params.density, values.density);
+        } else {
+          searchParams.delete(params.density);
+        }
+      }
+      if (values.contrast !== void 0) {
+        if (values.contrast) {
+          searchParams.set(params.contrast, values.contrast);
+        } else {
+          searchParams.delete(params.contrast);
+        }
+      }
+      const newUrl = searchParams.toString() ? `${window.location.pathname}?${searchParams.toString()}` : window.location.pathname;
+      window.history.replaceState({}, "", newUrl);
+    },
+    [params]
+  );
+  const clearUrl = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const searchParams = new URLSearchParams(window.location.search);
+    searchParams.delete(params.preset);
+    searchParams.delete(params.mode);
+    searchParams.delete(params.primary);
+    searchParams.delete(params.direction);
+    searchParams.delete(params.density);
+    searchParams.delete(params.contrast);
+    const newUrl = searchParams.toString() ? `${window.location.pathname}?${searchParams.toString()}` : window.location.pathname;
+    window.history.replaceState({}, "", newUrl);
+  }, [params]);
+  const generateUrl = useCallback(
+    (values, baseUrl) => {
+      const base = baseUrl ?? (typeof window !== "undefined" ? window.location.origin + window.location.pathname : "");
+      const searchParams = new URLSearchParams();
+      if (values.preset) {
+        searchParams.set(params.preset, values.preset);
+      }
+      if (values.mode) {
+        searchParams.set(params.mode, values.mode);
+      }
+      if (values.primary) {
+        searchParams.set(params.primary, values.primary);
+      }
+      if (values.direction) {
+        searchParams.set(params.direction, values.direction);
+      }
+      if (values.density) {
+        searchParams.set(params.density, values.density);
+      }
+      if (values.contrast) {
+        searchParams.set(params.contrast, values.contrast);
+      }
+      const queryString = searchParams.toString();
+      return queryString ? `${base}?${queryString}` : base;
+    },
+    [params]
+  );
+  const hasUrlConfig = Object.keys(configFromUrl).length > 0;
+  return {
+    configFromUrl,
+    updateUrl,
+    clearUrl,
+    generateUrl,
+    hasUrlConfig
+  };
+}
+function useImageDimensions(src, options = {}) {
+  const { crossOrigin, timeout = 1e4, immediate = true } = options;
+  const [dimensions, setDimensions] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadImage = useCallback(() => {
+    if (!src) {
+      setDimensions(null);
+      setLoading(false);
+      setError(null);
+      return void 0;
+    }
+    setLoading(true);
+    setError(null);
+    const img = new Image();
+    let timeoutId = null;
+    let cancelled = false;
+    const cleanup = () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      img.onload = null;
+      img.onerror = null;
+    };
+    img.onload = () => {
+      if (cancelled) return;
+      cleanup();
+      const { naturalWidth: width, naturalHeight: height } = img;
+      setDimensions({
+        width,
+        height,
+        aspectRatio: height > 0 ? width / height : 1
+      });
+      setLoading(false);
+      setError(null);
+    };
+    img.onerror = () => {
+      if (cancelled) return;
+      cleanup();
+      setDimensions(null);
+      setLoading(false);
+      setError(new Error(`Failed to load image: ${src}`));
+    };
+    timeoutId = setTimeout(() => {
+      if (cancelled) return;
+      cleanup();
+      setDimensions(null);
+      setLoading(false);
+      setError(new Error(`Image load timeout: ${src}`));
+    }, timeout);
+    if (crossOrigin) {
+      img.crossOrigin = crossOrigin;
+    }
+    img.src = src;
+    return cleanup;
+  }, [src, crossOrigin, timeout]);
+  useEffect(() => {
+    if (!immediate) return void 0;
+    return loadImage();
+  }, [loadImage, immediate]);
+  const retry = useCallback(() => {
+    loadImage();
+  }, [loadImage]);
+  return {
+    dimensions,
+    loading,
+    error,
+    retry
+  };
+}
+function useMultipleImageDimensions(urls, options = {}) {
+  const { crossOrigin, timeout = 1e4, immediate = true } = options;
+  const [results, setResults] = useState(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    if (!immediate) return void 0;
+    const cleanups = [];
+    urls.forEach((url) => {
+      if (!url) return;
+      setResults((prev) => {
+        const next = new Map(prev);
+        next.set(url, { dimensions: null, loading: true, error: null });
+        return next;
+      });
+      const img = new Image();
+      let timeoutId = null;
+      let cancelled = false;
+      const cleanup = () => {
+        cancelled = true;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        img.onload = null;
+        img.onerror = null;
+      };
+      cleanups.push(cleanup);
+      img.onload = () => {
+        if (cancelled) return;
+        cleanup();
+        const { naturalWidth: width, naturalHeight: height } = img;
+        setResults((prev) => {
+          const next = new Map(prev);
+          next.set(url, {
+            dimensions: { width, height, aspectRatio: height > 0 ? width / height : 1 },
+            loading: false,
+            error: null
+          });
+          return next;
+        });
+      };
+      img.onerror = () => {
+        if (cancelled) return;
+        cleanup();
+        setResults((prev) => {
+          const next = new Map(prev);
+          next.set(url, {
+            dimensions: null,
+            loading: false,
+            error: new Error(`Failed to load: ${url}`)
+          });
+          return next;
+        });
+      };
+      timeoutId = setTimeout(() => {
+        if (cancelled) return;
+        cleanup();
+        setResults((prev) => {
+          const next = new Map(prev);
+          next.set(url, {
+            dimensions: null,
+            loading: false,
+            error: new Error(`Timeout: ${url}`)
+          });
+          return next;
+        });
+      }, timeout);
+      if (crossOrigin) {
+        img.crossOrigin = crossOrigin;
+      }
+      img.src = url;
+    });
+    return () => {
+      cleanups.forEach((cleanup) => cleanup());
+    };
+  }, [urls.join(","), crossOrigin, timeout, immediate]);
+  return urls.map((url) => {
+    if (!url) {
+      return {
+        dimensions: null,
+        loading: false,
+        error: null,
+        retry: () => {
+        }
+      };
+    }
+    const result = results.get(url);
+    return {
+      dimensions: result?.dimensions ?? null,
+      loading: result?.loading ?? false,
+      error: result?.error ?? null,
+      retry: () => {
+        setResults((prev) => {
+          const next = new Map(prev);
+          next.delete(url);
+          return next;
+        });
+      }
+    };
+  });
+}
+function usePasswordVisibility(options = {}) {
+  const { initialVisible = false } = options;
+  const [visible, setVisible] = useState(initialVisible);
+  const toggle = useCallback(() => {
+    setVisible((prev) => !prev);
+  }, []);
+  const show = useCallback(() => {
+    setVisible(true);
+  }, []);
+  const hide = useCallback(() => {
+    setVisible(false);
+  }, []);
+  return useMemo(
+    () => ({
+      visible,
+      toggle,
+      show,
+      hide,
+      type: visible ? "text" : "password"
+    }),
+    [visible, toggle, show, hide]
+  );
+}
+function useThrottle(value, delay, options = {}) {
+  const { leading = true, trailing = true } = options;
+  const [throttledValue, setThrottledValue] = useState(value);
+  const lastExecuted = useRef(0);
+  const timeoutRef = useRef(null);
+  const lastValue = useRef(value);
+  useEffect(() => {
+    lastValue.current = value;
+    const now = Date.now();
+    const elapsed = now - lastExecuted.current;
+    const execute = () => {
+      lastExecuted.current = Date.now();
+      setThrottledValue(lastValue.current);
+    };
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    if (elapsed >= delay) {
+      if (leading) {
+        execute();
+      } else if (trailing) {
+        timeoutRef.current = setTimeout(execute, delay);
+      }
+    } else if (trailing) {
+      timeoutRef.current = setTimeout(execute, delay - elapsed);
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [value, delay, leading, trailing]);
+  return throttledValue;
+}
+function useThrottleCallback(callback, delay, options = {}) {
+  const { leading = true, trailing = true } = options;
+  const lastExecuted = useRef(0);
+  const timeoutRef = useRef(null);
+  const lastArgs = useRef(null);
+  const callbackRef = useRef(callback);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect(
+    () => () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    },
+    []
+  );
+  return useCallback(
+    ((...args) => {
+      lastArgs.current = args;
+      const now = Date.now();
+      const elapsed = now - lastExecuted.current;
+      const execute = () => {
+        lastExecuted.current = Date.now();
+        if (lastArgs.current) {
+          callbackRef.current(...lastArgs.current);
+        }
+      };
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
+      if (elapsed >= delay) {
+        if (leading) {
+          execute();
+        } else if (trailing) {
+          timeoutRef.current = setTimeout(execute, delay);
+        }
+      } else if (trailing) {
+        timeoutRef.current = setTimeout(execute, delay - elapsed);
+      }
+    }),
+    [delay, leading, trailing]
+  );
+}
+function subscribe(callback) {
+  window.addEventListener("online", callback);
+  window.addEventListener("offline", callback);
+  return () => {
+    window.removeEventListener("online", callback);
+    window.removeEventListener("offline", callback);
+  };
+}
+function getSnapshot() {
+  return navigator.onLine;
+}
+function getServerSnapshot() {
+  return true;
+}
+function useOnlineStatus() {
+  const isOnline = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const [lastChanged, setLastChanged] = useState(null);
+  const handleStatusChange = useCallback(() => {
+    setLastChanged(Date.now());
+  }, []);
+  useEffect(() => {
+    window.addEventListener("online", handleStatusChange);
+    window.addEventListener("offline", handleStatusChange);
+    return () => {
+      window.removeEventListener("online", handleStatusChange);
+      window.removeEventListener("offline", handleStatusChange);
+    };
+  }, [handleStatusChange]);
+  return {
+    isOnline,
+    isOffline: !isOnline,
+    lastChanged
+  };
+}
+function useIntersectionObserver(options = {}) {
+  const { root = null, rootMargin = "0px", threshold = 0, triggerOnce = false, enabled = true } = options;
+  const [entry, setEntry] = useState(null);
+  const elementRef = useRef(null);
+  const observerRef = useRef(null);
+  const frozenRef = useRef(false);
+  const disconnect = useCallback(() => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+      observerRef.current = null;
+    }
+  }, []);
+  const ref = useCallback(
+    (element) => {
+      disconnect();
+      elementRef.current = element;
+      if (!enabled || frozenRef.current || !element) {
+        return;
+      }
+      if (typeof IntersectionObserver === "undefined") {
+        setEntry({
+          isIntersecting: true,
+          intersectionRatio: 1,
+          boundingClientRect: element.getBoundingClientRect(),
+          intersectionRect: element.getBoundingClientRect(),
+          rootBounds: null,
+          target: element,
+          time: Date.now()
+        });
+        return;
+      }
+      observerRef.current = new IntersectionObserver(
+        ([observerEntry]) => {
+          setEntry(observerEntry);
+          if (triggerOnce && observerEntry.isIntersecting) {
+            frozenRef.current = true;
+            disconnect();
+          }
+        },
+        { root, rootMargin, threshold }
+      );
+      observerRef.current.observe(element);
+    },
+    [enabled, root, rootMargin, threshold, triggerOnce, disconnect]
+  );
+  useEffect(
+    () => () => {
+      disconnect();
+    },
+    [disconnect]
+  );
+  return useMemo(
+    () => ({
+      ref,
+      entry,
+      isIntersecting: entry?.isIntersecting ?? false,
+      disconnect
+    }),
+    [entry, disconnect]
+  );
+}
+function isInputElement(element) {
+  if (!element || !(element instanceof HTMLElement)) {
+    return false;
+  }
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
+    return true;
+  }
+  return element.isContentEditable;
+}
+function matchesShortcut(event, shortcut) {
+  const eventKey = event.key.toLowerCase();
+  const shortcutKey = shortcut.key.toLowerCase();
+  if (eventKey !== shortcutKey) {
+    return false;
+  }
+  const ctrlOrMeta = event.ctrlKey || event.metaKey;
+  if (shortcut.ctrl && !ctrlOrMeta) return false;
+  if (shortcut.meta && !event.metaKey) return false;
+  if (shortcut.shift && !event.shiftKey) return false;
+  if (shortcut.alt && !event.altKey) return false;
+  if (!shortcut.ctrl && !shortcut.meta && ctrlOrMeta) return false;
+  if (!shortcut.shift && event.shiftKey) return false;
+  if (!shortcut.alt && event.altKey) return false;
+  return true;
+}
+function useKeyboardShortcut(shortcut, callback, options = {}) {
+  const {
+    enabled = true,
+    preventDefault = true,
+    stopPropagation = false,
+    target = typeof document !== "undefined" ? document : null,
+    event = "keydown",
+    ignoreInputs = false
+  } = options;
+  const callbackRef = useRef(callback);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const handleKeyEvent = useCallback(
+    (e) => {
+      if (!enabled) return;
+      const keyEvent = e;
+      if (ignoreInputs && isInputElement(keyEvent.target)) {
+        return;
+      }
+      if (matchesShortcut(keyEvent, shortcut)) {
+        if (preventDefault) {
+          keyEvent.preventDefault();
+        }
+        if (stopPropagation) {
+          keyEvent.stopPropagation();
+        }
+        callbackRef.current(keyEvent);
+      }
+    },
+    [enabled, shortcut, preventDefault, stopPropagation, ignoreInputs]
+  );
+  useEffect(() => {
+    if (!target || !enabled) return void 0;
+    target.addEventListener(event, handleKeyEvent);
+    return () => {
+      target.removeEventListener(event, handleKeyEvent);
+    };
+  }, [target, event, handleKeyEvent, enabled]);
+}
+function useEscapeKey(callback, options = {}) {
+  useKeyboardShortcut({ key: "Escape" }, callback, {
+    ...options,
+    ignoreInputs: false
+    // Escape should work even in inputs
+  });
+}
+function useEnterKey(callback, options = {}) {
+  useKeyboardShortcut({ key: "Enter" }, callback, options);
+}
+var FOCUSABLE_SELECTOR = [
+  "a[href]",
+  "button:not([disabled])",
+  'input:not([disabled]):not([type="hidden"])',
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])',
+  '[contenteditable="true"]'
+].join(",");
+function useFocusTrap(options = {}) {
+  const { enabled = true, autoFocus = true, restoreFocus = true, focusableSelector = FOCUSABLE_SELECTOR } = options;
+  const containerRef = useRef(null);
+  const previousActiveElement = useRef(null);
+  const getFocusableElements = useCallback(() => {
+    if (!containerRef.current) return [];
+    return Array.from(containerRef.current.querySelectorAll(focusableSelector)).filter(
+      (el) => el.offsetParent !== null
+    );
+  }, [focusableSelector]);
+  const focusFirst = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length > 0) {
+      elements[0].focus();
+    }
+  }, [getFocusableElements]);
+  const focusLast = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length > 0) {
+      elements[elements.length - 1].focus();
+    }
+  }, [getFocusableElements]);
+  useEffect(() => {
+    if (!enabled || !containerRef.current) return void 0;
+    const handleKeyDown = (event) => {
+      if (event.key !== "Tab") return;
+      const elements = getFocusableElements();
+      if (elements.length === 0) return;
+      const firstElement = elements[0];
+      const lastElement = elements[elements.length - 1];
+      const activeElement = document.activeElement;
+      if (event.shiftKey && activeElement === firstElement) {
+        event.preventDefault();
+        lastElement.focus();
+        return;
+      }
+      if (!event.shiftKey && activeElement === lastElement) {
+        event.preventDefault();
+        firstElement.focus();
+      }
+    };
+    const container = containerRef.current;
+    container.addEventListener("keydown", handleKeyDown);
+    return () => {
+      container.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [enabled, getFocusableElements]);
+  useEffect(() => {
+    if (enabled) {
+      if (restoreFocus) {
+        previousActiveElement.current = document.activeElement;
+      }
+      if (autoFocus) {
+        const timeoutId = setTimeout(focusFirst, 0);
+        return () => clearTimeout(timeoutId);
+      }
+    } else if (restoreFocus && previousActiveElement.current) {
+      previousActiveElement.current.focus();
+      previousActiveElement.current = null;
+    }
+    return void 0;
+  }, [enabled, autoFocus, restoreFocus, focusFirst]);
+  const ref = useCallback((node) => {
+    containerRef.current = node;
+  }, []);
+  return { ref, focusFirst, focusLast };
+}
+function useUpdateEffect(effect, deps) {
+  const isFirstMount = useRef(true);
+  useEffect(() => {
+    if (isFirstMount.current) {
+      isFirstMount.current = false;
+      return void 0;
+    }
+    return effect();
+  }, deps);
+}
+function useUpdateLayoutEffect(effect, deps) {
+  const isFirstMount = useRef(true);
+  useEffect(() => {
+    if (isFirstMount.current) {
+      isFirstMount.current = false;
+      return void 0;
+    }
+    return effect();
+  }, deps);
+}
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function getStorageValue(key, defaultValue, deserializer) {
+  if (typeof window === "undefined") {
+    return defaultValue;
+  }
+  try {
+    const item = window.sessionStorage.getItem(key);
+    if (item === null) {
+      return defaultValue;
+    }
+    return deserializer(item);
+  } catch (error) {
+    console.warn(`Error reading sessionStorage key "${key}":`, error);
+    return defaultValue;
+  }
+}
+function useSessionStorage(key, defaultValue, options = {}) {
+  const { serializer = JSON.stringify, deserializer = JSON.parse } = options;
+  const isClient = useIsClient();
+  const [state, setStateInternal] = useState(() => {
+    if (typeof window === "undefined") {
+      return defaultValue;
+    }
+    return getStorageValue(key, defaultValue, deserializer);
+  });
+  const [hasValue, setHasValue] = useState(() => {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    return window.sessionStorage.getItem(key) !== null;
+  });
+  const setState = useCallback(
+    (value) => {
+      try {
+        const newValue = value instanceof Function ? value(state) : value;
+        window.sessionStorage.setItem(key, serializer(newValue));
+        setStateInternal(newValue);
+        setHasValue(true);
+        window.dispatchEvent(
+          new StorageEvent("storage", {
+            key,
+            newValue: serializer(newValue),
+            storageArea: window.sessionStorage
+          })
+        );
+      } catch (error) {
+        console.warn(`Error setting sessionStorage key "${key}":`, error);
+      }
+    },
+    [key, serializer, state]
+  );
+  const remove = useCallback(() => {
+    try {
+      window.sessionStorage.removeItem(key);
+      setStateInternal(defaultValue);
+      setHasValue(false);
+      window.dispatchEvent(
+        new StorageEvent("storage", {
+          key,
+          newValue: null,
+          storageArea: window.sessionStorage
+        })
+      );
+    } catch (error) {
+      console.warn(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, [key, defaultValue]);
+  useEffect(() => {
+    if (!isClient) return void 0;
+    const value = getStorageValue(key, defaultValue, deserializer);
+    setStateInternal(value);
+    setHasValue(window.sessionStorage.getItem(key) !== null);
+    return void 0;
+  }, [key, isClient, defaultValue, deserializer]);
+  useEffect(() => {
+    if (!isClient) return void 0;
+    const handleStorageChange = (event) => {
+      if (event.key === key && event.storageArea === window.sessionStorage) {
+        if (event.newValue === null) {
+          setStateInternal(defaultValue);
+          setHasValue(false);
+        } else {
+          try {
+            setStateInternal(deserializer(event.newValue));
+            setHasValue(true);
+          } catch {
+          }
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [key, isClient, defaultValue, deserializer]);
+  return {
+    state,
+    setState,
+    remove,
+    hasValue
+  };
+}
+function useArray(initialValue = []) {
+  const [value, setValue] = useState(initialValue);
+  const push = useCallback((item) => {
+    setValue((arr) => [...arr, item]);
+  }, []);
+  const pushMany = useCallback((items) => {
+    setValue((arr) => [...arr, ...items]);
+  }, []);
+  const remove = useCallback((itemOrPredicate) => {
+    setValue((arr) => {
+      const predicate = typeof itemOrPredicate === "function" ? itemOrPredicate : (item) => item === itemOrPredicate;
+      const index = arr.findIndex(predicate);
+      if (index === -1) return arr;
+      return [...arr.slice(0, index), ...arr.slice(index + 1)];
+    });
+  }, []);
+  const removeAt = useCallback((index) => {
+    setValue((arr) => {
+      if (index < 0 || index >= arr.length) return arr;
+      return [...arr.slice(0, index), ...arr.slice(index + 1)];
+    });
+  }, []);
+  const removeWhere = useCallback((predicate) => {
+    setValue((arr) => arr.filter((item) => !predicate(item)));
+  }, []);
+  const updateAt = useCallback((index, item) => {
+    setValue((arr) => {
+      if (index < 0 || index >= arr.length) return arr;
+      return [...arr.slice(0, index), item, ...arr.slice(index + 1)];
+    });
+  }, []);
+  const updateAtPartial = useCallback((index, partial) => {
+    setValue((arr) => {
+      if (index < 0 || index >= arr.length) return arr;
+      const item = arr[index];
+      if (typeof item !== "object" || item === null) {
+        console.warn("updateAtPartial only works with object items");
+        return arr;
+      }
+      return [...arr.slice(0, index), { ...item, ...partial }, ...arr.slice(index + 1)];
+    });
+  }, []);
+  const updateWhere = useCallback((predicate, update) => {
+    setValue(
+      (arr) => arr.map((item) => {
+        if (!predicate(item)) return item;
+        return typeof update === "function" ? update(item) : update;
+      })
+    );
+  }, []);
+  const insertAt = useCallback((index, item) => {
+    setValue((arr) => {
+      const normalizedIndex = Math.max(0, Math.min(index, arr.length));
+      return [...arr.slice(0, normalizedIndex), item, ...arr.slice(normalizedIndex)];
+    });
+  }, []);
+  const move = useCallback((fromIndex, toIndex) => {
+    setValue((arr) => {
+      if (fromIndex < 0 || fromIndex >= arr.length || toIndex < 0 || toIndex >= arr.length || fromIndex === toIndex) {
+        return arr;
+      }
+      const newArr = [...arr];
+      const [item] = newArr.splice(fromIndex, 1);
+      newArr.splice(toIndex, 0, item);
+      return newArr;
+    });
+  }, []);
+  const swap = useCallback((indexA, indexB) => {
+    setValue((arr) => {
+      if (indexA < 0 || indexA >= arr.length || indexB < 0 || indexB >= arr.length || indexA === indexB) {
+        return arr;
+      }
+      const newArr = [...arr];
+      [newArr[indexA], newArr[indexB]] = [newArr[indexB], newArr[indexA]];
+      return newArr;
+    });
+  }, []);
+  const clear = useCallback(() => {
+    setValue([]);
+  }, []);
+  const reset = useCallback(() => {
+    setValue(initialValue);
+  }, [initialValue]);
+  const reverse = useCallback(() => {
+    setValue((arr) => [...arr].reverse());
+  }, []);
+  const sort = useCallback((compareFn) => {
+    setValue((arr) => [...arr].sort(compareFn));
+  }, []);
+  const filter = useCallback((predicate) => value.filter(predicate), [value]);
+  const find = useCallback((predicate) => value.find(predicate), [value]);
+  const findIndex = useCallback((predicate) => value.findIndex(predicate), [value]);
+  const includes = useCallback((item) => value.includes(item), [value]);
+  const computed = useMemo(
+    () => ({
+      length: value.length,
+      isEmpty: value.length === 0,
+      first: value[0],
+      last: value[value.length - 1]
+    }),
+    [value]
+  );
+  return {
+    value,
+    setValue,
+    push,
+    pushMany,
+    remove,
+    removeAt,
+    removeWhere,
+    updateAt,
+    updateAtPartial,
+    updateWhere,
+    insertAt,
+    move,
+    swap,
+    clear,
+    reset,
+    reverse,
+    sort,
+    filter,
+    find,
+    findIndex,
+    includes,
+    ...computed
+  };
+}
+var defaultRetryDelay = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
+function useMutation(mutationFn, options = {}) {
+  const { onMutate, onSuccess, onError, onSettled, retry = 0, retryDelay = defaultRetryDelay } = options;
+  const [state, setState] = useState({
+    data: void 0,
+    error: void 0,
+    isLoading: false,
+    isSuccess: false,
+    isError: false,
+    isIdle: true,
+    status: "idle"
+  });
+  const mutationIdRef = useRef(0);
+  const mutate = useCallback(
+    (variables, callOptions) => {
+      const currentId = ++mutationIdRef.current;
+      const executeWithRetry = async (attempt) => {
+        if (mutationIdRef.current !== currentId) return;
+        setState({
+          data: void 0,
+          error: void 0,
+          isLoading: true,
+          isSuccess: false,
+          isError: false,
+          isIdle: false,
+          status: "loading"
+        });
+        try {
+          await onMutate?.(variables);
+          const data = await mutationFn(variables);
+          if (mutationIdRef.current !== currentId) return;
+          setState({
+            data,
+            error: void 0,
+            isLoading: false,
+            isSuccess: true,
+            isError: false,
+            isIdle: false,
+            status: "success"
+          });
+          await onSuccess?.(data, variables);
+          await callOptions?.onSuccess?.(data);
+          await onSettled?.(data, void 0, variables);
+          await callOptions?.onSettled?.(data, void 0);
+        } catch (err) {
+          if (mutationIdRef.current !== currentId) return;
+          const error = err;
+          const maxRetries = typeof retry === "boolean" ? retry ? 3 : 0 : retry;
+          if (attempt < maxRetries) {
+            const delay = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            await executeWithRetry(attempt + 1);
+            return;
+          }
+          setState({
+            data: void 0,
+            error,
+            isLoading: false,
+            isSuccess: false,
+            isError: true,
+            isIdle: false,
+            status: "error"
+          });
+          await onError?.(error, variables);
+          await callOptions?.onError?.(error);
+          await onSettled?.(void 0, error, variables);
+          await callOptions?.onSettled?.(void 0, error);
+        }
+      };
+      executeWithRetry(0);
+    },
+    [mutationFn, onMutate, onSuccess, onError, onSettled, retry, retryDelay]
+  );
+  const mutateAsync = useCallback(
+    (variables) => new Promise((resolve, reject) => {
+      mutate(variables, {
+        onSuccess: resolve,
+        onError: reject
+      });
+    }),
+    [mutate]
+  );
+  const reset = useCallback(() => {
+    mutationIdRef.current++;
+    setState({
+      data: void 0,
+      error: void 0,
+      isLoading: false,
+      isSuccess: false,
+      isError: false,
+      isIdle: true,
+      status: "idle"
+    });
+  }, []);
+  return {
+    ...state,
+    mutate,
+    mutateAsync,
+    reset
+  };
+}
+var defaultRetryDelay2 = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
+function useLazyQuery(queryFn, options = {}) {
+  const {
+    onSuccess,
+    onError,
+    onSettled,
+    cacheTime = 0,
+    staleTime = 0,
+    retry = 0,
+    retryDelay = defaultRetryDelay2,
+    initialData
+  } = options;
+  const [state, setState] = useState({
+    data: initialData,
+    error: void 0,
+    isLoading: false,
+    isSuccess: !!initialData,
+    isError: false,
+    isCalled: !!initialData,
+    isFetching: false,
+    isRefetching: false
+  });
+  const queryIdRef = useRef(0);
+  const lastVariablesRef = useRef(null);
+  const cacheRef = useRef(/* @__PURE__ */ new Map());
+  const getCacheKey = useCallback((variables) => JSON.stringify(variables), []);
+  const isCacheValid = useCallback(
+    (entry) => {
+      if (!entry || cacheTime === 0) return false;
+      const age = Date.now() - entry.timestamp;
+      return age < cacheTime;
+    },
+    [cacheTime]
+  );
+  const isCacheFresh = useCallback(
+    (entry) => {
+      if (!entry || staleTime === 0) return false;
+      const age = Date.now() - entry.timestamp;
+      return age < staleTime;
+    },
+    [staleTime]
+  );
+  const query = useCallback(
+    async (variables) => {
+      const currentId = ++queryIdRef.current;
+      lastVariablesRef.current = variables;
+      const cacheKey = getCacheKey(variables);
+      const cached = cacheRef.current.get(cacheKey);
+      if (isCacheFresh(cached)) {
+        setState((prev) => ({
+          ...prev,
+          data: cached.data,
+          isSuccess: true,
+          isCalled: true
+        }));
+        return cached.data;
+      }
+      if (isCacheValid(cached)) {
+        setState({
+          data: cached.data,
+          error: void 0,
+          isLoading: false,
+          isSuccess: true,
+          isError: false,
+          isCalled: true,
+          isFetching: true,
+          isRefetching: true
+        });
+      } else {
+        setState({
+          data: void 0,
+          error: void 0,
+          isLoading: true,
+          isSuccess: false,
+          isError: false,
+          isCalled: true,
+          isFetching: true,
+          isRefetching: false
+        });
+      }
+      const executeWithRetry = async (attempt) => {
+        try {
+          const data = await queryFn(variables);
+          if (queryIdRef.current !== currentId) {
+            return data;
+          }
+          cacheRef.current.set(cacheKey, {
+            data,
+            timestamp: Date.now(),
+            variables
+          });
+          setState({
+            data,
+            error: void 0,
+            isLoading: false,
+            isSuccess: true,
+            isError: false,
+            isCalled: true,
+            isFetching: false,
+            isRefetching: false
+          });
+          await onSuccess?.(data, variables);
+          await onSettled?.(data, void 0, variables);
+          return data;
+        } catch (err) {
+          if (queryIdRef.current !== currentId) {
+            throw err;
+          }
+          const error = err;
+          const maxRetries = typeof retry === "boolean" ? retry ? 3 : 0 : retry;
+          if (attempt < maxRetries) {
+            const delay = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            return executeWithRetry(attempt + 1);
+          }
+          setState({
+            data: void 0,
+            error,
+            isLoading: false,
+            isSuccess: false,
+            isError: true,
+            isCalled: true,
+            isFetching: false,
+            isRefetching: false
+          });
+          await onError?.(error, variables);
+          await onSettled?.(void 0, error, variables);
+          throw error;
+        }
+      };
+      return executeWithRetry(0);
+    },
+    [queryFn, getCacheKey, isCacheFresh, isCacheValid, onSuccess, onError, onSettled, retry, retryDelay]
+  );
+  const refetch = useCallback(async () => {
+    if (lastVariablesRef.current === null) {
+      return void 0;
+    }
+    return query(lastVariablesRef.current);
+  }, [query]);
+  const reset = useCallback(() => {
+    queryIdRef.current++;
+    lastVariablesRef.current = null;
+    cacheRef.current.clear();
+    setState({
+      data: initialData,
+      error: void 0,
+      isLoading: false,
+      isSuccess: !!initialData,
+      isError: false,
+      isCalled: !!initialData,
+      isFetching: false,
+      isRefetching: false
+    });
+  }, [initialData]);
+  const setData = useCallback((data) => {
+    setState((prev) => {
+      const newData = typeof data === "function" ? data(prev.data) : data;
+      return {
+        ...prev,
+        data: newData,
+        isSuccess: true
+      };
+    });
+  }, []);
+  return {
+    ...state,
+    query,
+    refetch,
+    reset,
+    setData
+  };
+}
+var defaultRetryDelay3 = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
+function useInfiniteScroll(fetchFn, options = {}) {
+  const {
+    onSuccess,
+    onError,
+    initialCursor,
+    pageSize = 20,
+    retry = 0,
+    retryDelay = defaultRetryDelay3,
+    observerOptions = { threshold: 0.1 }
+  } = options;
+  const [state, setState] = useState({
+    items: [],
+    pages: [],
+    error: void 0,
+    isLoading: false,
+    isFetchingMore: false,
+    hasNextPage: true,
+    isEmpty: true,
+    totalCount: void 0
+  });
+  const fetchIdRef = useRef(0);
+  const cursorRef = useRef(initialCursor);
+  const observerRef = useRef(null);
+  const sentinelElementRef = useRef(null);
+  const isMountedRef = useRef(true);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, []);
+  const fetchPage = useCallback(
+    async (cursor, isRefresh = false) => {
+      const currentId = ++fetchIdRef.current;
+      const executeWithRetry = async (attempt) => {
+        if (!isMountedRef.current) return;
+        setState((prev) => ({
+          ...prev,
+          isLoading: isRefresh && prev.pages.length === 0,
+          isFetchingMore: !isRefresh || prev.pages.length > 0,
+          error: void 0
+        }));
+        try {
+          const page = await fetchFn({ cursor, pageSize });
+          if (fetchIdRef.current !== currentId || !isMountedRef.current) return;
+          setState((prev) => {
+            const newPages = isRefresh ? [page] : [...prev.pages, page];
+            const newItems = newPages.flatMap((p) => p.items);
+            return {
+              items: newItems,
+              pages: newPages,
+              error: void 0,
+              isLoading: false,
+              isFetchingMore: false,
+              hasNextPage: page.pageInfo.hasNextPage,
+              isEmpty: newItems.length === 0,
+              totalCount: page.pageInfo.totalCount
+            };
+          });
+          cursorRef.current = page.pageInfo.endCursor;
+          await onSuccess?.(page);
+        } catch (err) {
+          if (fetchIdRef.current !== currentId || !isMountedRef.current) return;
+          const error = err;
+          const maxRetries = typeof retry === "boolean" ? retry ? 3 : 0 : retry;
+          if (attempt < maxRetries) {
+            const delay = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            await executeWithRetry(attempt + 1);
+            return;
+          }
+          setState((prev) => ({
+            ...prev,
+            error,
+            isLoading: false,
+            isFetchingMore: false
+          }));
+          await onError?.(error);
+        }
+      };
+      return executeWithRetry(0);
+    },
+    [fetchFn, pageSize, onSuccess, onError, retry, retryDelay]
+  );
+  const fetchNextPage = useCallback(async () => {
+    if (state.isFetchingMore || state.isLoading || !state.hasNextPage) return;
+    await fetchPage(cursorRef.current);
+  }, [fetchPage, state.isFetchingMore, state.isLoading, state.hasNextPage]);
+  const refresh = useCallback(async () => {
+    cursorRef.current = initialCursor;
+    await fetchPage(initialCursor, true);
+  }, [fetchPage, initialCursor]);
+  const reset = useCallback(() => {
+    fetchIdRef.current++;
+    cursorRef.current = initialCursor;
+    setState({
+      items: [],
+      pages: [],
+      error: void 0,
+      isLoading: false,
+      isFetchingMore: false,
+      hasNextPage: true,
+      isEmpty: true,
+      totalCount: void 0
+    });
+  }, [initialCursor]);
+  const prependItems = useCallback((newItems) => {
+    setState((prev) => ({
+      ...prev,
+      items: [...newItems, ...prev.items],
+      isEmpty: newItems.length === 0 && prev.items.length === 0
+    }));
+  }, []);
+  const appendItems = useCallback((newItems) => {
+    setState((prev) => ({
+      ...prev,
+      items: [...prev.items, ...newItems],
+      isEmpty: prev.items.length === 0 && newItems.length === 0
+    }));
+  }, []);
+  const removeItem = useCallback((predicate) => {
+    setState((prev) => {
+      const newItems = prev.items.filter((item) => !predicate(item));
+      return {
+        ...prev,
+        items: newItems,
+        isEmpty: newItems.length === 0
+      };
+    });
+  }, []);
+  const updateItem = useCallback(
+    (predicate, update) => {
+      setState((prev) => ({
+        ...prev,
+        items: prev.items.map((item) => {
+          if (!predicate(item)) return item;
+          if (typeof update === "function") {
+            return update(item);
+          }
+          return { ...item, ...update };
+        })
+      }));
+    },
+    []
+  );
+  const sentinelRef = useCallback(
+    (element) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+      sentinelElementRef.current = element;
+      if (!element) return;
+      observerRef.current = new IntersectionObserver((entries) => {
+        if (entries[0]?.isIntersecting) {
+          fetchNextPage();
+        }
+      }, observerOptions);
+      observerRef.current.observe(element);
+    },
+    [fetchNextPage, observerOptions]
+  );
+  useEffect(() => {
+    fetchPage(initialCursor, true);
+  }, []);
+  return {
+    items: state.items,
+    pages: state.pages,
+    error: state.error,
+    isLoading: state.isLoading,
+    isFetchingMore: state.isFetchingMore,
+    hasNextPage: state.hasNextPage,
+    isEmpty: state.isEmpty,
+    totalCount: state.totalCount,
+    fetchNextPage,
+    refresh,
+    reset,
+    sentinelRef,
+    prependItems,
+    appendItems,
+    removeItem,
+    updateItem
+  };
+}
+
+export { CustomPopover, cookiesAvailable, getCookie, removeCookie, setCookie, useArray, useAsync, useAsyncFn, useBackToTop, useBreakpoint, useBreakpointChecks, useClientRect, useConfigFromQuery, useCookies, useCountdownDate, useCountdownSeconds, useDoubleClick, useEnterKey, useEscapeKey, useFocusTrap, useImageDimensions, useInfiniteScroll, useIntersectionObserver, useIsomorphicLayoutEffect, useKeyboardShortcut, useLazyQuery, useMultipleImageDimensions, useMutation, useOnlineStatus, usePasswordVisibility, usePopover, usePopoverHover, useResponsiveQuery, useScrollLock, useScrollOffsetTop, useScrollPosition, useScrollToTop, useSessionStorage, useThrottle, useThrottleCallback, useUpdateEffect, useUpdateLayoutEffect, useWindowSize };
+//# sourceMappingURL=chunk-E3XANPTO.js.map
+//# sourceMappingURL=chunk-E3XANPTO.js.map