@exyconn/common 2.1.0 → 2.3.3

package/dist/client/hooks/index.mjs

@@ -0,0 +1,2217 @@
+import { useState, useCallback, useMemo, useRef, useEffect } from 'react';
+
+// src/client/hooks/useToggle.ts
+function useToggle(initialValue = false) {
+  const [value, setValue] = useState(initialValue);
+  const toggle = useCallback(() => setValue((v) => !v), []);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  return {
+    value,
+    toggle,
+    setTrue,
+    setFalse,
+    setValue
+  };
+}
+var useToggle_default = useToggle;
+function useCounter(initialValue = 0, options = {}) {
+  const { min = -Infinity, max = Infinity, step = 1 } = options;
+  const clamp = useCallback(
+    (value) => Math.min(Math.max(value, min), max),
+    [min, max]
+  );
+  const [count, setCount] = useState(clamp(initialValue));
+  const increment = useCallback(() => {
+    setCount((c) => clamp(c + step));
+  }, [clamp, step]);
+  const decrement = useCallback(() => {
+    setCount((c) => clamp(c - step));
+  }, [clamp, step]);
+  const set = useCallback(
+    (value) => {
+      setCount(clamp(value));
+    },
+    [clamp]
+  );
+  const reset = useCallback(() => {
+    setCount(clamp(initialValue));
+  }, [clamp, initialValue]);
+  return { count, increment, decrement, set, reset };
+}
+var useCounter_default = useCounter;
+function useDefault(initialValue, defaultValue) {
+  const [state, setState] = useState(initialValue);
+  const value = useMemo(() => {
+    return state === null || state === void 0 ? defaultValue : state;
+  }, [state, defaultValue]);
+  const setValue = useCallback((newValue) => {
+    setState(newValue);
+  }, []);
+  return [value, setValue];
+}
+var useDefault_default = useDefault;
+function usePrevious(value, initialValue) {
+  const ref = useRef(initialValue);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+var usePrevious_default = usePrevious;
+function useObjectState(initialState) {
+  const [state, setStateInternal] = useState(initialState);
+  const setState = useCallback((update) => {
+    setStateInternal((prev) => {
+      const newState = typeof update === "function" ? update(prev) : update;
+      return { ...prev, ...newState };
+    });
+  }, []);
+  const resetState = useCallback(() => {
+    setStateInternal(initialState);
+  }, [initialState]);
+  const setProperty = useCallback((key, value) => {
+    setStateInternal((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const removeProperty = useCallback((key) => {
+    setStateInternal((prev) => {
+      const newState = { ...prev };
+      delete newState[key];
+      return newState;
+    });
+  }, []);
+  return { state, setState, resetState, setProperty, removeProperty };
+}
+var useObjectState_default = useObjectState;
+function useHistoryState(initialValue, options = {}) {
+  const { maxLength = 100 } = options;
+  const [history, setHistory] = useState([initialValue]);
+  const [pointer, setPointer] = useState(0);
+  const state = useMemo(() => history[pointer], [history, pointer]);
+  const setState = useCallback(
+    (value) => {
+      setHistory((prev) => {
+        const currentValue = prev[pointer];
+        const newValue = typeof value === "function" ? value(currentValue) : value;
+        const newHistory = prev.slice(0, pointer + 1);
+        newHistory.push(newValue);
+        if (newHistory.length > maxLength) {
+          newHistory.shift();
+          return newHistory;
+        }
+        return newHistory;
+      });
+      setPointer((prev) => Math.min(prev + 1, maxLength - 1));
+    },
+    [pointer, maxLength]
+  );
+  const undo = useCallback(() => {
+    setPointer((prev) => Math.max(0, prev - 1));
+  }, []);
+  const redo = useCallback(() => {
+    setPointer((prev) => Math.min(history.length - 1, prev + 1));
+  }, [history.length]);
+  const go = useCallback(
+    (index) => {
+      const targetIndex = Math.max(0, Math.min(history.length - 1, index));
+      setPointer(targetIndex);
+    },
+    [history.length]
+  );
+  const clear = useCallback(
+    (value) => {
+      const resetValue = value ?? initialValue;
+      setHistory([resetValue]);
+      setPointer(0);
+    },
+    [initialValue]
+  );
+  const canUndo = pointer > 0;
+  const canRedo = pointer < history.length - 1;
+  return {
+    state,
+    setState,
+    undo,
+    redo,
+    clear,
+    canUndo,
+    canRedo,
+    history,
+    pointer,
+    go
+  };
+}
+var useHistoryState_default = useHistoryState;
+function useQueue(initialValue = []) {
+  const [queue, setQueue] = useState(initialValue);
+  const enqueue = useCallback((item) => {
+    setQueue((prev) => [...prev, item]);
+  }, []);
+  const enqueueAll = useCallback((items) => {
+    setQueue((prev) => [...prev, ...items]);
+  }, []);
+  const dequeue = useCallback(() => {
+    let dequeuedItem;
+    setQueue((prev) => {
+      if (prev.length === 0) return prev;
+      dequeuedItem = prev[0];
+      return prev.slice(1);
+    });
+    return dequeuedItem;
+  }, []);
+  const peek = useCallback(() => {
+    return queue[0];
+  }, [queue]);
+  const clear = useCallback(() => {
+    setQueue([]);
+  }, []);
+  const size = queue.length;
+  const isEmpty = size === 0;
+  const first = queue[0];
+  const last = queue[queue.length - 1];
+  return {
+    queue,
+    enqueue,
+    enqueueAll,
+    dequeue,
+    peek,
+    clear,
+    size,
+    isEmpty,
+    first,
+    last
+  };
+}
+var useQueue_default = useQueue;
+function useList(initialValue = []) {
+  const [list, setList] = useState(initialValue);
+  const set = useCallback((newList) => {
+    setList(newList);
+  }, []);
+  const push = useCallback((item) => {
+    setList((prev) => [...prev, item]);
+  }, []);
+  const unshift = useCallback((item) => {
+    setList((prev) => [item, ...prev]);
+  }, []);
+  const removeAt = useCallback((index) => {
+    setList((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const remove = useCallback((item) => {
+    setList((prev) => {
+      const index = prev.indexOf(item);
+      if (index === -1) return prev;
+      return prev.filter((_, i) => i !== index);
+    });
+  }, []);
+  const removeWhere = useCallback((predicate) => {
+    setList((prev) => prev.filter((item) => !predicate(item)));
+  }, []);
+  const updateAt = useCallback((index, item) => {
+    setList((prev) => prev.map((v, i) => i === index ? item : v));
+  }, []);
+  const updateWhere = useCallback(
+    (predicate, updater) => {
+      setList((prev) => prev.map((item) => predicate(item) ? updater(item) : item));
+    },
+    []
+  );
+  const insertAt = useCallback((index, item) => {
+    setList((prev) => [...prev.slice(0, index), item, ...prev.slice(index)]);
+  }, []);
+  const move = useCallback((fromIndex, toIndex) => {
+    setList((prev) => {
+      const newList = [...prev];
+      const [item] = newList.splice(fromIndex, 1);
+      newList.splice(toIndex, 0, item);
+      return newList;
+    });
+  }, []);
+  const clear = useCallback(() => {
+    setList([]);
+  }, []);
+  const reset = useCallback(() => {
+    setList(initialValue);
+  }, [initialValue]);
+  const filter = useCallback((predicate) => {
+    setList((prev) => prev.filter(predicate));
+  }, []);
+  const sort = useCallback((compareFn) => {
+    setList((prev) => [...prev].sort(compareFn));
+  }, []);
+  const reverse = useCallback(() => {
+    setList((prev) => [...prev].reverse());
+  }, []);
+  const size = list.length;
+  const isEmpty = size === 0;
+  const first = list[0];
+  const last = list[list.length - 1];
+  return {
+    list,
+    set,
+    push,
+    unshift,
+    removeAt,
+    remove,
+    removeWhere,
+    updateAt,
+    updateWhere,
+    insertAt,
+    move,
+    clear,
+    reset,
+    filter,
+    sort,
+    reverse,
+    size,
+    isEmpty,
+    first,
+    last
+  };
+}
+var useList_default = useList;
+function useMap(initialValue = []) {
+  const [map, setMap] = useState(() => new Map(initialValue));
+  const get = useCallback((key) => {
+    return map.get(key);
+  }, [map]);
+  const set = useCallback((key, value) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      newMap.set(key, value);
+      return newMap;
+    });
+  }, []);
+  const setAll = useCallback((entries2) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      for (const [key, value] of entries2) {
+        newMap.set(key, value);
+      }
+      return newMap;
+    });
+  }, []);
+  const has = useCallback((key) => {
+    return map.has(key);
+  }, [map]);
+  const remove = useCallback((key) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      newMap.delete(key);
+      return newMap;
+    });
+  }, []);
+  const removeAll = useCallback((keys2) => {
+    setMap((prev) => {
+      const newMap = new Map(prev);
+      keys2.forEach((key) => newMap.delete(key));
+      return newMap;
+    });
+  }, []);
+  const clear = useCallback(() => {
+    setMap(/* @__PURE__ */ new Map());
+  }, []);
+  const reset = useCallback(() => {
+    setMap(new Map(initialValue));
+  }, [initialValue]);
+  const size = map.size;
+  const keys = useMemo(() => Array.from(map.keys()), [map]);
+  const values = useMemo(() => Array.from(map.values()), [map]);
+  const entries = useMemo(() => Array.from(map.entries()), [map]);
+  const isEmpty = size === 0;
+  return {
+    map,
+    get,
+    set,
+    setAll,
+    has,
+    remove,
+    removeAll,
+    clear,
+    reset,
+    size,
+    keys,
+    values,
+    entries,
+    isEmpty
+  };
+}
+var useMap_default = useMap;
+function useSet(initialValue = []) {
+  const [set, setSet] = useState(() => new Set(initialValue));
+  const add = useCallback((item) => {
+    setSet((prev) => /* @__PURE__ */ new Set([...prev, item]));
+  }, []);
+  const addAll = useCallback((items) => {
+    setSet((prev) => /* @__PURE__ */ new Set([...prev, ...items]));
+  }, []);
+  const has = useCallback((item) => {
+    return set.has(item);
+  }, [set]);
+  const remove = useCallback((item) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      newSet.delete(item);
+      return newSet;
+    });
+  }, []);
+  const removeAll = useCallback((items) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      for (const item of items) {
+        newSet.delete(item);
+      }
+      return newSet;
+    });
+  }, []);
+  const toggle = useCallback((item) => {
+    setSet((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(item)) {
+        newSet.delete(item);
+      } else {
+        newSet.add(item);
+      }
+      return newSet;
+    });
+  }, []);
+  const clear = useCallback(() => {
+    setSet(/* @__PURE__ */ new Set());
+  }, []);
+  const reset = useCallback(() => {
+    setSet(new Set(initialValue));
+  }, [initialValue]);
+  const size = set.size;
+  const values = useMemo(() => Array.from(set), [set]);
+  const isEmpty = size === 0;
+  return {
+    set,
+    add,
+    addAll,
+    has,
+    remove,
+    removeAll,
+    toggle,
+    clear,
+    reset,
+    size,
+    values,
+    isEmpty
+  };
+}
+var useSet_default = useSet;
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+var useDebounce_default = useDebounce;
+function useThrottle(value, interval = 500) {
+  const [throttledValue, setThrottledValue] = useState(value);
+  const lastUpdated = useRef(Date.now());
+  useEffect(() => {
+    const now = Date.now();
+    const timeSinceLastUpdate = now - lastUpdated.current;
+    if (timeSinceLastUpdate >= interval) {
+      lastUpdated.current = now;
+      setThrottledValue(value);
+      return;
+    } else {
+      const timeoutId = setTimeout(() => {
+        lastUpdated.current = Date.now();
+        setThrottledValue(value);
+      }, interval - timeSinceLastUpdate);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [value, interval]);
+  return throttledValue;
+}
+var useThrottle_default = useThrottle;
+function useTimeout(callback, delay) {
+  const savedCallback = useRef(callback);
+  const timeoutId = useRef(null);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const clear = useCallback(() => {
+    if (timeoutId.current) {
+      clearTimeout(timeoutId.current);
+      timeoutId.current = null;
+    }
+  }, []);
+  const reset = useCallback(() => {
+    clear();
+    if (delay !== null) {
+      timeoutId.current = setTimeout(() => {
+        savedCallback.current();
+      }, delay);
+    }
+  }, [delay, clear]);
+  useEffect(() => {
+    if (delay === null) {
+      return;
+    }
+    timeoutId.current = setTimeout(() => {
+      savedCallback.current();
+    }, delay);
+    return clear;
+  }, [delay, clear]);
+  return { reset, clear };
+}
+var useTimeout_default = useTimeout;
+function useInterval(callback, delay) {
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (delay === null) {
+      return;
+    }
+    const tick = () => savedCallback.current();
+    const id = setInterval(tick, delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+var useInterval_default = useInterval;
+function useIntervalWhen(callback, delay, when, immediate = false) {
+  const savedCallback = useRef(callback);
+  const hasRunImmediate = useRef(false);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (!when) {
+      hasRunImmediate.current = false;
+      return;
+    }
+    if (immediate && !hasRunImmediate.current) {
+      hasRunImmediate.current = true;
+      savedCallback.current();
+    }
+    const id = setInterval(() => {
+      savedCallback.current();
+    }, delay);
+    return () => clearInterval(id);
+  }, [delay, when, immediate]);
+}
+var useIntervalWhen_default = useIntervalWhen;
+function useRandomInterval(callback, minDelay, maxDelay, enabled = true) {
+  const savedCallback = useRef(callback);
+  const timeoutId = useRef(null);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const getRandomDelay = useCallback(() => {
+    return Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
+  }, [minDelay, maxDelay]);
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const tick = () => {
+      savedCallback.current();
+      timeoutId.current = setTimeout(tick, getRandomDelay());
+    };
+    timeoutId.current = setTimeout(tick, getRandomDelay());
+    return () => {
+      if (timeoutId.current) {
+        clearTimeout(timeoutId.current);
+      }
+    };
+  }, [enabled, getRandomDelay]);
+}
+var useRandomInterval_default = useRandomInterval;
+function useCountdown(initialCount, options = {}) {
+  const { interval = 1e3, onComplete, autoStart = false } = options;
+  const [count, setCount] = useState(initialCount);
+  const [isRunning, setIsRunning] = useState(autoStart);
+  const intervalRef = useRef(null);
+  const onCompleteRef = useRef(onComplete);
+  useEffect(() => {
+    onCompleteRef.current = onComplete;
+  }, [onComplete]);
+  const isComplete = count <= 0;
+  const clear = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+  const start = useCallback(() => {
+    if (count <= 0) return;
+    setIsRunning(true);
+  }, [count]);
+  const pause = useCallback(() => {
+    setIsRunning(false);
+    clear();
+  }, [clear]);
+  const resume = useCallback(() => {
+    if (count > 0) {
+      setIsRunning(true);
+    }
+  }, [count]);
+  const reset = useCallback(
+    (newCount) => {
+      clear();
+      setCount(newCount ?? initialCount);
+      setIsRunning(false);
+    },
+    [clear, initialCount]
+  );
+  useEffect(() => {
+    if (!isRunning || count <= 0) {
+      clear();
+      return;
+    }
+    intervalRef.current = setInterval(() => {
+      setCount((prev) => {
+        const newCount = prev - interval;
+        if (newCount <= 0) {
+          setIsRunning(false);
+          onCompleteRef.current?.();
+          return 0;
+        }
+        return newCount;
+      });
+    }, interval);
+    return clear;
+  }, [isRunning, interval, clear, count]);
+  const formatted = {
+    days: Math.floor(count / (1e3 * 60 * 60 * 24)),
+    hours: Math.floor(count % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60)),
+    minutes: Math.floor(count % (1e3 * 60 * 60) / (1e3 * 60)),
+    seconds: Math.floor(count % (1e3 * 60) / 1e3)
+  };
+  return {
+    count,
+    start,
+    pause,
+    resume,
+    reset,
+    isRunning,
+    isComplete,
+    formatted
+  };
+}
+var useCountdown_default = useCountdown;
+function useContinuousRetry(callback, options = {}) {
+  const {
+    maxAttempts = Infinity,
+    delay = 1e3,
+    exponentialBackoff = false,
+    maxDelay = 3e4,
+    autoStart = true
+  } = options;
+  const [attempts, setAttempts] = useState(0);
+  const [error, setError] = useState(null);
+  const [isRetrying, setIsRetrying] = useState(autoStart);
+  const [isSuccess, setIsSuccess] = useState(false);
+  const callbackRef = useRef(callback);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const isMaxAttempts = attempts >= maxAttempts;
+  const calculateDelay = useCallback(
+    (attempt) => {
+      if (!exponentialBackoff) return delay;
+      const exponentialDelay = delay * Math.pow(2, attempt);
+      return Math.min(exponentialDelay, maxDelay);
+    },
+    [delay, exponentialBackoff, maxDelay]
+  );
+  const clear = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const stop = useCallback(() => {
+    clear();
+    setIsRetrying(false);
+  }, [clear]);
+  const reset = useCallback(() => {
+    clear();
+    setAttempts(0);
+    setError(null);
+    setIsRetrying(false);
+    setIsSuccess(false);
+  }, [clear]);
+  const start = useCallback(() => {
+    reset();
+    setIsRetrying(true);
+  }, [reset]);
+  useEffect(() => {
+    if (!isRetrying || isSuccess || isMaxAttempts) {
+      return;
+    }
+    const attemptCallback = async () => {
+      try {
+        setAttempts((prev) => prev + 1);
+        const result = await callbackRef.current();
+        if (result) {
+          setIsSuccess(true);
+          setIsRetrying(false);
+        } else {
+          const currentDelay = calculateDelay(attempts);
+          timeoutRef.current = setTimeout(attemptCallback, currentDelay);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        const currentDelay = calculateDelay(attempts);
+        timeoutRef.current = setTimeout(attemptCallback, currentDelay);
+      }
+    };
+    if (attempts === 0) {
+      attemptCallback();
+    }
+    return clear;
+  }, [isRetrying, isSuccess, isMaxAttempts, attempts, calculateDelay, clear]);
+  return {
+    attempts,
+    error,
+    isRetrying,
+    isSuccess,
+    isMaxAttempts,
+    start,
+    stop,
+    reset
+  };
+}
+var useContinuousRetry_default = useContinuousRetry;
+function useWindowSize(debounceMs = 100) {
+  const getSize = () => ({
+    width: typeof window !== "undefined" ? window.innerWidth : 0,
+    height: typeof window !== "undefined" ? window.innerHeight : 0
+  });
+  const [windowSize, setWindowSize] = useState(getSize);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    let timeoutId;
+    const handleResize = () => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        setWindowSize(getSize());
+      }, debounceMs);
+    };
+    setWindowSize(getSize());
+    window.addEventListener("resize", handleResize);
+    return () => {
+      clearTimeout(timeoutId);
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [debounceMs]);
+  return windowSize;
+}
+var useWindowSize_default = useWindowSize;
+function useWindowScroll() {
+  const [scroll, setScroll] = useState({
+    x: typeof window !== "undefined" ? window.scrollX : 0,
+    y: typeof window !== "undefined" ? window.scrollY : 0,
+    direction: null,
+    isScrolling: false
+  });
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    let prevX = window.scrollX;
+    let prevY = window.scrollY;
+    let scrollTimeout;
+    const handleScroll = () => {
+      const x = window.scrollX;
+      const y = window.scrollY;
+      let direction = null;
+      if (y > prevY) direction = "down";
+      else if (y < prevY) direction = "up";
+      else if (x > prevX) direction = "right";
+      else if (x < prevX) direction = "left";
+      prevX = x;
+      prevY = y;
+      setScroll({ x, y, direction, isScrolling: true });
+      clearTimeout(scrollTimeout);
+      scrollTimeout = setTimeout(() => {
+        setScroll((prev) => ({ ...prev, isScrolling: false }));
+      }, 150);
+    };
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      clearTimeout(scrollTimeout);
+    };
+  }, []);
+  const scrollTo = useCallback((options) => {
+    if (typeof window !== "undefined") {
+      window.scrollTo(options);
+    }
+  }, []);
+  const scrollToTop = useCallback((behavior = "smooth") => {
+    if (typeof window !== "undefined") {
+      window.scrollTo({ top: 0, behavior });
+    }
+  }, []);
+  const scrollToBottom = useCallback((behavior = "smooth") => {
+    if (typeof window !== "undefined") {
+      window.scrollTo({
+        top: document.documentElement.scrollHeight,
+        behavior
+      });
+    }
+  }, []);
+  return {
+    ...scroll,
+    scrollTo,
+    scrollToTop,
+    scrollToBottom
+  };
+}
+var useWindowScroll_default = useWindowScroll;
+function useDocumentTitle(title, options = {}) {
+  const { restoreOnUnmount = true, template } = options;
+  const previousTitle = useRef(null);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    if (previousTitle.current === null) {
+      previousTitle.current = document.title;
+    }
+    const finalTitle = template ? template.replace("%s", title) : title;
+    document.title = finalTitle;
+    return () => {
+      if (restoreOnUnmount && previousTitle.current !== null) {
+        document.title = previousTitle.current;
+      }
+    };
+  }, [title, template, restoreOnUnmount]);
+}
+var useDocumentTitle_default = useDocumentTitle;
+function usePageTitle(title, options = {}) {
+  const { suffix, separator = " | ", restoreOnUnmount = true } = options;
+  useEffect(() => {
+    const originalTitle = document.title;
+    const newTitle = suffix ? `${title}${separator}${suffix}` : title;
+    document.title = newTitle;
+    return () => {
+      if (restoreOnUnmount) {
+        document.title = originalTitle;
+      }
+    };
+  }, [title, suffix, separator, restoreOnUnmount]);
+}
+var usePageTitle_default = usePageTitle;
+function useFavicon(href, restoreOnUnmount = true) {
+  const originalHref = useRef(null);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    const link = document.querySelector("link[rel*='icon']") || document.createElement("link");
+    if (originalHref.current === null) {
+      originalHref.current = link.href;
+    }
+    link.type = "image/x-icon";
+    link.rel = "shortcut icon";
+    link.href = href;
+    document.head.appendChild(link);
+    return () => {
+      if (restoreOnUnmount && originalHref.current) {
+        link.href = originalHref.current;
+      }
+    };
+  }, [href, restoreOnUnmount]);
+}
+var useFavicon_default = useFavicon;
+function useVisibilityChange(onVisibilityChange) {
+  const [state, setState] = useState(() => ({
+    isVisible: typeof document !== "undefined" ? !document.hidden : true,
+    visibilityState: typeof document !== "undefined" ? document.visibilityState : "visible",
+    lastChanged: null
+  }));
+  const handleVisibilityChange = useCallback(() => {
+    const isVisible = !document.hidden;
+    const visibilityState = document.visibilityState;
+    setState({
+      isVisible,
+      visibilityState,
+      lastChanged: /* @__PURE__ */ new Date()
+    });
+    onVisibilityChange?.(isVisible);
+  }, [onVisibilityChange]);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, [handleVisibilityChange]);
+  return state;
+}
+var useVisibilityChange_default = useVisibilityChange;
+function usePageLeave(onLeave, options = {}) {
+  const { showConfirmation = false, confirmationMessage = "" } = options;
+  const onLeaveRef = useRef(onLeave);
+  useEffect(() => {
+    onLeaveRef.current = onLeave;
+  }, [onLeave]);
+  const handleMouseLeave = useCallback((e) => {
+    if (e.clientY <= 0) {
+      onLeaveRef.current?.();
+    }
+  }, []);
+  const handleBeforeUnload = useCallback(
+    (e) => {
+      onLeaveRef.current?.();
+      if (showConfirmation) {
+        e.preventDefault();
+        e.returnValue = confirmationMessage;
+        return confirmationMessage;
+      }
+    },
+    [showConfirmation, confirmationMessage]
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    document.addEventListener("mouseleave", handleMouseLeave);
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      document.removeEventListener("mouseleave", handleMouseLeave);
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+    };
+  }, [handleMouseLeave, handleBeforeUnload]);
+}
+var usePageLeave_default = usePageLeave;
+function useLockBodyScroll(locked = true) {
+  useEffect(() => {
+    if (typeof document === "undefined" || !locked) return;
+    const originalStyle = window.getComputedStyle(document.body).overflow;
+    const originalPaddingRight = window.getComputedStyle(document.body).paddingRight;
+    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    document.body.style.overflow = "hidden";
+    if (scrollbarWidth > 0) {
+      document.body.style.paddingRight = `${scrollbarWidth}px`;
+    }
+    return () => {
+      document.body.style.overflow = originalStyle;
+      document.body.style.paddingRight = originalPaddingRight;
+    };
+  }, [locked]);
+}
+var useLockBodyScroll_default = useLockBodyScroll;
+function useIsClient() {
+  const [isClient, setIsClient] = useState(false);
+  useEffect(() => {
+    setIsClient(true);
+  }, []);
+  return isClient;
+}
+var useIsClient_default = useIsClient;
+function useIsFirstRender() {
+  const isFirst = useRef(true);
+  if (isFirst.current) {
+    isFirst.current = false;
+    return true;
+  }
+  return isFirst.current;
+}
+var useIsFirstRender_default = useIsFirstRender;
+function useEventListener(eventName, handler, element, options) {
+  const savedHandler = useRef(handler);
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  useEffect(() => {
+    const targetElement = element ?? (typeof window !== "undefined" ? window : null);
+    if (!targetElement?.addEventListener) {
+      return;
+    }
+    const eventListener = (event) => {
+      savedHandler.current(event);
+    };
+    targetElement.addEventListener(eventName, eventListener, options);
+    return () => {
+      targetElement.removeEventListener(eventName, eventListener, options);
+    };
+  }, [eventName, element, options]);
+}
+var useEventListener_default = useEventListener;
+function useKeyPress(targetKey, callback, options = {}) {
+  const {
+    target,
+    event: eventType = "keydown",
+    preventDefault = false,
+    stopPropagation = false
+  } = options;
+  const [pressed, setPressed] = useState(false);
+  const [event, setEvent] = useState(null);
+  const keys = Array.isArray(targetKey) ? targetKey : [targetKey];
+  const downHandler = useCallback(
+    (e) => {
+      if (keys.includes(e.key)) {
+        if (preventDefault) e.preventDefault();
+        if (stopPropagation) e.stopPropagation();
+        setPressed(true);
+        setEvent(e);
+        callback?.(e);
+      }
+    },
+    [keys, callback, preventDefault, stopPropagation]
+  );
+  const upHandler = useCallback(
+    (e) => {
+      if (keys.includes(e.key)) {
+        setPressed(false);
+      }
+    },
+    [keys]
+  );
+  useEffect(() => {
+    const targetElement = target ?? (typeof document !== "undefined" ? document : null);
+    if (!targetElement) return;
+    targetElement.addEventListener(eventType, downHandler);
+    targetElement.addEventListener("keyup", upHandler);
+    return () => {
+      targetElement.removeEventListener(eventType, downHandler);
+      targetElement.removeEventListener("keyup", upHandler);
+    };
+  }, [target, eventType, downHandler, upHandler]);
+  return { pressed, event };
+}
+var useKeyPress_default = useKeyPress;
+function useHover(onHoverChange) {
+  const [isHovered, setIsHovered] = useState(false);
+  const ref = useRef(null);
+  const onMouseEnter = useCallback(() => {
+    setIsHovered(true);
+    onHoverChange?.(true);
+  }, [onHoverChange]);
+  const onMouseLeave = useCallback(() => {
+    setIsHovered(false);
+    onHoverChange?.(false);
+  }, [onHoverChange]);
+  return {
+    ref,
+    isHovered,
+    bind: {
+      onMouseEnter,
+      onMouseLeave
+    }
+  };
+}
+var useHover_default = useHover;
+function useClickAway(callback, events = ["mousedown", "touchstart"]) {
+  const ref = useRef(null);
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  const handleClickAway = useCallback((event) => {
+    const el = ref.current;
+    if (!el || el.contains(event.target)) {
+      return;
+    }
+    savedCallback.current(event);
+  }, []);
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+    events.forEach((eventType) => {
+      document.addEventListener(eventType, handleClickAway);
+    });
+    return () => {
+      events.forEach((eventType) => {
+        document.removeEventListener(eventType, handleClickAway);
+      });
+    };
+  }, [events, handleClickAway]);
+  return ref;
+}
+var useClickAway_default = useClickAway;
+function useOnClickOutside(ref, handler, enabled = true) {
+  useEffect(() => {
+    if (!enabled) return;
+    const listener = (event) => {
+      const el = ref?.current;
+      if (!el || el.contains(event.target)) {
+        return;
+      }
+      handler(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref, handler, enabled]);
+}
+var useOnClickOutside_default = useOnClickOutside;
+function useLongPress(options = {}) {
+  const {
+    threshold = 400,
+    onLongPress,
+    onClick,
+    onStart,
+    onFinish,
+    onCancel
+  } = options;
+  const [isPressed, setIsPressed] = useState(false);
+  const [isLongPress, setIsLongPress] = useState(false);
+  const timerRef = useRef(null);
+  const isLongPressRef = useRef(false);
+  const start = useCallback(
+    (event) => {
+      setIsPressed(true);
+      setIsLongPress(false);
+      isLongPressRef.current = false;
+      onStart?.(event);
+      timerRef.current = setTimeout(() => {
+        isLongPressRef.current = true;
+        setIsLongPress(true);
+        onLongPress?.(event);
+      }, threshold);
+    },
+    [threshold, onLongPress, onStart]
+  );
+  const cancel = useCallback(
+    (event) => {
+      setIsPressed(false);
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (!isLongPressRef.current) {
+        onCancel?.(event);
+      }
+    },
+    [onCancel]
+  );
+  const end = useCallback(
+    (event) => {
+      setIsPressed(false);
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (isLongPressRef.current) {
+        onFinish?.(event);
+      } else {
+        onClick?.(event);
+      }
+    },
+    [onClick, onFinish]
+  );
+  return {
+    isPressed,
+    isLongPress,
+    bind: {
+      onMouseDown: start,
+      onMouseUp: end,
+      onMouseLeave: cancel,
+      onTouchStart: start,
+      onTouchEnd: end
+    }
+  };
+}
+var useLongPress_default = useLongPress;
+function useMouse(options = {}) {
+  const { enabled = true } = options;
+  const ref = useRef(null);
+  const [position, setPosition] = useState({
+    x: 0,
+    y: 0,
+    pageX: 0,
+    pageY: 0,
+    elementX: 0,
+    elementY: 0,
+    isInElement: false
+  });
+  const handleMouseMove = useCallback((event) => {
+    let elementX = 0;
+    let elementY = 0;
+    let isInElement = false;
+    if (ref.current) {
+      const rect = ref.current.getBoundingClientRect();
+      elementX = event.clientX - rect.left;
+      elementY = event.clientY - rect.top;
+      isInElement = elementX >= 0 && elementX <= rect.width && elementY >= 0 && elementY <= rect.height;
+    }
+    setPosition({
+      x: event.clientX,
+      y: event.clientY,
+      pageX: event.pageX,
+      pageY: event.pageY,
+      elementX,
+      elementY,
+      isInElement
+    });
+  }, []);
+  useEffect(() => {
+    if (!enabled || typeof window === "undefined") return;
+    window.addEventListener("mousemove", handleMouseMove);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+    };
+  }, [enabled, handleMouseMove]);
+  return {
+    ref,
+    ...position
+  };
+}
+var useMouse_default = useMouse;
+function useCopyToClipboard(resetDelay = 2e3) {
+  const [copied, setCopied] = useState(false);
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setCopied(false);
+    setError(null);
+  }, []);
+  const copy = useCallback(
+    async (text) => {
+      if (!navigator?.clipboard) {
+        try {
+          const textarea = document.createElement("textarea");
+          textarea.value = text;
+          textarea.style.position = "fixed";
+          textarea.style.left = "-999999px";
+          textarea.style.top = "-999999px";
+          document.body.appendChild(textarea);
+          textarea.focus();
+          textarea.select();
+          const successful = document.execCommand("copy");
+          document.body.removeChild(textarea);
+          if (successful) {
+            setCopied(true);
+            setError(null);
+            setTimeout(reset, resetDelay);
+            return true;
+          } else {
+            throw new Error("execCommand failed");
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+          setError(message);
+          setCopied(false);
+          return false;
+        }
+      }
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        setError(null);
+        setTimeout(reset, resetDelay);
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to copy to clipboard";
+        setError(message);
+        setCopied(false);
+        return false;
+      }
+    },
+    [resetDelay, reset]
+  );
+  return { copy, copied, error, reset };
+}
+var useCopyToClipboard_default = useCopyToClipboard;
+function useMediaQuery(query) {
+  const getMatches = (query2) => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query2).matches;
+  };
+  const [matches, setMatches] = useState(getMatches(query));
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia(query);
+    const handleChange = () => setMatches(mediaQuery.matches);
+    handleChange();
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, [query]);
+  return matches;
+}
+var useIsMobile = () => useMediaQuery("(max-width: 767px)");
+var useIsTablet = () => useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
+var useIsDesktop = () => useMediaQuery("(min-width: 1024px)");
+var useIsMobileOrTablet = () => useMediaQuery("(max-width: 1023px)");
+var useMediaQuery_default = useMediaQuery;
+function useOrientation() {
+  const getOrientation = () => {
+    if (typeof window === "undefined" || !window.screen?.orientation) {
+      return {
+        angle: 0,
+        type: "portrait-primary",
+        isPortrait: true,
+        isLandscape: false
+      };
+    }
+    const { angle, type } = window.screen.orientation;
+    const isPortrait = type.includes("portrait");
+    const isLandscape = type.includes("landscape");
+    return { angle, type, isPortrait, isLandscape };
+  };
+  const [orientation, setOrientation] = useState(getOrientation);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleOrientationChange = () => {
+      setOrientation(getOrientation());
+    };
+    if (window.screen?.orientation) {
+      window.screen.orientation.addEventListener("change", handleOrientationChange);
+    }
+    window.addEventListener("orientationchange", handleOrientationChange);
+    window.addEventListener("resize", handleOrientationChange);
+    return () => {
+      if (window.screen?.orientation) {
+        window.screen.orientation.removeEventListener("change", handleOrientationChange);
+      }
+      window.removeEventListener("orientationchange", handleOrientationChange);
+      window.removeEventListener("resize", handleOrientationChange);
+    };
+  }, []);
+  return orientation;
+}
+var useOrientation_default = useOrientation;
+function useBattery() {
+  const [battery, setBattery] = useState({
+    isSupported: false,
+    charging: false,
+    chargingTime: Infinity,
+    dischargingTime: Infinity,
+    level: 1,
+    percentage: 100
+  });
+  useEffect(() => {
+    if (typeof navigator === "undefined") return;
+    const nav = navigator;
+    if (!nav.getBattery) {
+      setBattery((prev) => ({ ...prev, isSupported: false }));
+      return;
+    }
+    let batteryManager = null;
+    const updateBattery = (battery2) => {
+      setBattery({
+        isSupported: true,
+        charging: battery2.charging,
+        chargingTime: battery2.chargingTime,
+        dischargingTime: battery2.dischargingTime,
+        level: battery2.level,
+        percentage: Math.round(battery2.level * 100)
+      });
+    };
+    const handleChange = () => {
+      if (batteryManager) {
+        updateBattery(batteryManager);
+      }
+    };
+    nav.getBattery().then((battery2) => {
+      batteryManager = battery2;
+      updateBattery(battery2);
+      battery2.addEventListener("chargingchange", handleChange);
+      battery2.addEventListener("chargingtimechange", handleChange);
+      battery2.addEventListener("dischargingtimechange", handleChange);
+      battery2.addEventListener("levelchange", handleChange);
+    });
+    return () => {
+      if (batteryManager) {
+        batteryManager.removeEventListener("chargingchange", handleChange);
+        batteryManager.removeEventListener("chargingtimechange", handleChange);
+        batteryManager.removeEventListener("dischargingtimechange", handleChange);
+        batteryManager.removeEventListener("levelchange", handleChange);
+      }
+    };
+  }, []);
+  return battery;
+}
+var useBattery_default = useBattery;
+function useNetworkState() {
+  const getConnection = () => {
+    if (typeof navigator === "undefined") return void 0;
+    const nav = navigator;
+    return nav.connection || nav.mozConnection || nav.webkitConnection;
+  };
+  const getNetworkState = () => {
+    const online = typeof navigator !== "undefined" ? navigator.onLine : true;
+    const connection = getConnection();
+    return {
+      online,
+      offline: !online,
+      downlink: connection?.downlink,
+      effectiveType: connection?.effectiveType,
+      rtt: connection?.rtt,
+      saveData: connection?.saveData,
+      type: connection?.type,
+      since: /* @__PURE__ */ new Date()
+    };
+  };
+  const [state, setState] = useState(getNetworkState);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleOnline = () => {
+      setState((prev) => ({ ...prev, online: true, offline: false, since: /* @__PURE__ */ new Date() }));
+    };
+    const handleOffline = () => {
+      setState((prev) => ({ ...prev, online: false, offline: true, since: /* @__PURE__ */ new Date() }));
+    };
+    const handleConnectionChange = () => {
+      setState(getNetworkState());
+    };
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    const connection = getConnection();
+    if (connection) {
+      connection.addEventListener("change", handleConnectionChange);
+    }
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+      if (connection) {
+        connection.removeEventListener("change", handleConnectionChange);
+      }
+    };
+  }, []);
+  return state;
+}
+var useNetworkState_default = useNetworkState;
+var DEFAULT_EVENTS = [
+  "mousemove",
+  "mousedown",
+  "keydown",
+  "touchstart",
+  "scroll",
+  "wheel"
+];
+function useIdle(options = {}) {
+  const {
+    timeout = 6e4,
+    events = DEFAULT_EVENTS,
+    initialState = false,
+    onIdle,
+    onActive
+  } = options;
+  const [isIdle, setIsIdle] = useState(initialState);
+  const [lastActive, setLastActive] = useState(/* @__PURE__ */ new Date());
+  const [isTracking, setIsTracking] = useState(true);
+  const timeoutRef = useRef(null);
+  const onIdleRef = useRef(onIdle);
+  const onActiveRef = useRef(onActive);
+  useEffect(() => {
+    onIdleRef.current = onIdle;
+    onActiveRef.current = onActive;
+  }, [onIdle, onActive]);
+  const handleActivity = useCallback(() => {
+    if (!isTracking) return;
+    setLastActive(/* @__PURE__ */ new Date());
+    if (isIdle) {
+      setIsIdle(false);
+      onActiveRef.current?.();
+    }
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      setIsIdle(true);
+      onIdleRef.current?.();
+    }, timeout);
+  }, [isIdle, isTracking, timeout]);
+  const reset = useCallback(() => {
+    handleActivity();
+  }, [handleActivity]);
+  const start = useCallback(() => {
+    setIsTracking(true);
+    handleActivity();
+  }, [handleActivity]);
+  const stop = useCallback(() => {
+    setIsTracking(false);
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    if (typeof window === "undefined" || !isTracking) return;
+    timeoutRef.current = setTimeout(() => {
+      setIsIdle(true);
+      onIdleRef.current?.();
+    }, timeout);
+    events.forEach((event) => {
+      window.addEventListener(event, handleActivity, { passive: true });
+    });
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      events.forEach((event) => {
+        window.removeEventListener(event, handleActivity);
+      });
+    };
+  }, [events, handleActivity, isTracking, timeout]);
+  return {
+    isIdle,
+    lastActive,
+    reset,
+    start,
+    stop
+  };
+}
+var useIdle_default = useIdle;
+function useGeolocation(options = {}) {
+  const {
+    enableHighAccuracy = false,
+    maximumAge = 0,
+    timeout = Infinity,
+    watch = false
+  } = options;
+  const isSupported = typeof navigator !== "undefined" && "geolocation" in navigator;
+  const [state, setState] = useState({
+    loading: true,
+    error: null,
+    latitude: null,
+    longitude: null,
+    accuracy: null,
+    altitude: null,
+    altitudeAccuracy: null,
+    heading: null,
+    speed: null,
+    timestamp: null
+  });
+  const handleSuccess = useCallback((position) => {
+    setState({
+      loading: false,
+      error: null,
+      latitude: position.coords.latitude,
+      longitude: position.coords.longitude,
+      accuracy: position.coords.accuracy,
+      altitude: position.coords.altitude,
+      altitudeAccuracy: position.coords.altitudeAccuracy,
+      heading: position.coords.heading,
+      speed: position.coords.speed,
+      timestamp: position.timestamp
+    });
+  }, []);
+  const handleError = useCallback((error) => {
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: error.message
+    }));
+  }, []);
+  const refresh = useCallback(() => {
+    if (!isSupported) return;
+    setState((prev) => ({ ...prev, loading: true }));
+    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, {
+      enableHighAccuracy,
+      maximumAge,
+      timeout
+    });
+  }, [isSupported, enableHighAccuracy, maximumAge, timeout, handleSuccess, handleError]);
+  useEffect(() => {
+    if (!isSupported) {
+      setState((prev) => ({
+        ...prev,
+        loading: false,
+        error: "Geolocation is not supported"
+      }));
+      return;
+    }
+    const positionOptions = {
+      enableHighAccuracy,
+      maximumAge,
+      timeout
+    };
+    navigator.geolocation.getCurrentPosition(
+      handleSuccess,
+      handleError,
+      positionOptions
+    );
+    let watchId = null;
+    if (watch) {
+      watchId = navigator.geolocation.watchPosition(
+        handleSuccess,
+        handleError,
+        positionOptions
+      );
+    }
+    return () => {
+      if (watchId !== null) {
+        navigator.geolocation.clearWatch(watchId);
+      }
+    };
+  }, [isSupported, enableHighAccuracy, maximumAge, timeout, watch, handleSuccess, handleError]);
+  return {
+    ...state,
+    refresh,
+    isSupported
+  };
+}
+var useGeolocation_default = useGeolocation;
+function usePreferredLanguage() {
+  const getLanguageState = () => {
+    if (typeof navigator === "undefined") {
+      return { language: "en", languages: ["en"] };
+    }
+    return {
+      language: navigator.language || "en",
+      languages: navigator.languages || [navigator.language || "en"]
+    };
+  };
+  const [state, setState] = useState(getLanguageState);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleLanguageChange = () => {
+      setState(getLanguageState());
+    };
+    window.addEventListener("languagechange", handleLanguageChange);
+    return () => {
+      window.removeEventListener("languagechange", handleLanguageChange);
+    };
+  }, []);
+  return state;
+}
+var usePreferredLanguage_default = usePreferredLanguage;
+function useThemeDetector() {
+  const getCurrentTheme = () => {
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  };
+  const [theme, setTheme] = useState(getCurrentTheme);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      setTheme(e.matches ? "dark" : "light");
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, []);
+  return theme;
+}
+var useThemeDetector_default = useThemeDetector;
+function useLocalStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    syncTabs = true,
+    debug = false
+  } = options;
+  const log = useCallback(
+    (...args) => {
+      if (debug) console.log(`[useLocalStorage:${key}]`, ...args);
+    },
+    [debug, key]
+  );
+  const readValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      const parsed = deserializer(item);
+      log("Read value:", parsed);
+      return parsed;
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer, log]);
+  const [storedValue, setStoredValue] = useState(readValue);
+  const setValue = useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(`Cannot set localStorage key "${key}" in non-browser environment`);
+        return;
+      }
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        window.localStorage.setItem(key, serializer(valueToStore));
+        log("Set value:", valueToStore);
+        window.dispatchEvent(new StorageEvent("storage", { key, newValue: serializer(valueToStore) }));
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer, log]
+  );
+  const removeValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      window.localStorage.removeItem(key);
+      setStoredValue(initialValue);
+      log("Removed value");
+      window.dispatchEvent(new StorageEvent("storage", { key, newValue: null }));
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [key, initialValue, log]);
+  useEffect(() => {
+    if (!syncTabs || typeof window === "undefined") {
+      return;
+    }
+    const handleStorageChange = (event) => {
+      if (event.key !== key) {
+        return;
+      }
+      log("Storage event received:", event.newValue);
+      if (event.newValue === null) {
+        setStoredValue(initialValue);
+      } else {
+        try {
+          setStoredValue(deserializer(event.newValue));
+        } catch {
+          console.warn(`Error parsing localStorage change for key "${key}"`);
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key, initialValue, syncTabs, deserializer, log]);
+  return [storedValue, setValue, removeValue];
+}
+var useLocalStorage_default = useLocalStorage;
+function useSessionStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    debug = false
+  } = options;
+  const log = useCallback(
+    (...args) => {
+      if (debug) console.log(`[useSessionStorage:${key}]`, ...args);
+    },
+    [debug, key]
+  );
+  const readValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      if (item === null) {
+        return initialValue;
+      }
+      const parsed = deserializer(item);
+      log("Read value:", parsed);
+      return parsed;
+    } catch (error) {
+      console.warn(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer, log]);
+  const [storedValue, setStoredValue] = useState(readValue);
+  const setValue = useCallback(
+    (value) => {
+      if (typeof window === "undefined") {
+        console.warn(`Cannot set sessionStorage key "${key}" in non-browser environment`);
+        return;
+      }
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        window.sessionStorage.setItem(key, serializer(valueToStore));
+        log("Set value:", valueToStore);
+      } catch (error) {
+        console.warn(`Error setting sessionStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer, log]
+  );
+  const removeValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      window.sessionStorage.removeItem(key);
+      setStoredValue(initialValue);
+      log("Removed value");
+    } catch (error) {
+      console.warn(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, [key, initialValue, log]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handleStorageChange = (e) => {
+      if (e.storageArea !== sessionStorage || e.key !== key) {
+        return;
+      }
+      try {
+        if (e.newValue === null) {
+          setStoredValue(initialValue);
+        } else {
+          setStoredValue(deserializer(e.newValue));
+        }
+      } catch (error) {
+        console.warn(`Error handling storage event for key "${key}":`, error);
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [key, initialValue, deserializer]);
+  return [storedValue, setValue, removeValue];
+}
+var useSessionStorage_default = useSessionStorage;
+var cache = /* @__PURE__ */ new Map();
+function useFetch(url, options = {}) {
+  const {
+    skip = false,
+    transform,
+    retries = 0,
+    retryDelay = 1e3,
+    cacheKey,
+    cacheTime = 0,
+    onSuccess,
+    onError,
+    body,
+    ...fetchOptions
+  } = options;
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(!skip && !!url);
+  const [isFetching, setIsFetching] = useState(!skip && !!url);
+  const [error, setError] = useState(null);
+  const [status, setStatus] = useState(null);
+  const abortControllerRef = useRef(null);
+  const retriesRef = useRef(0);
+  const fetchData = useCallback(async () => {
+    if (!url) return null;
+    const key = cacheKey || url;
+    if (cacheTime > 0) {
+      const cached = cache.get(key);
+      if (cached && Date.now() - cached.timestamp < cacheTime) {
+        const cachedData = cached.data;
+        setData(cachedData);
+        setLoading(false);
+        setIsFetching(false);
+        return cachedData;
+      }
+    }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    setIsFetching(true);
+    setError(null);
+    try {
+      let processedBody;
+      if (body !== null && body !== void 0) {
+        if (typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob)) {
+          processedBody = JSON.stringify(body);
+          fetchOptions.headers = {
+            "Content-Type": "application/json",
+            ...fetchOptions.headers
+          };
+        } else {
+          processedBody = body;
+        }
+      }
+      const response = await fetch(url, {
+        ...fetchOptions,
+        body: processedBody,
+        signal: abortControllerRef.current.signal
+      });
+      setStatus(response.status);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const responseData = await response.json();
+      const transformedData = transform ? transform(responseData) : responseData;
+      if (cacheTime > 0) {
+        cache.set(key, { data: transformedData, timestamp: Date.now() });
+      }
+      setData(transformedData);
+      setError(null);
+      setLoading(false);
+      setIsFetching(false);
+      retriesRef.current = 0;
+      onSuccess?.(transformedData);
+      return transformedData;
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return null;
+      }
+      const fetchError = err instanceof Error ? err : new Error(String(err));
+      if (retriesRef.current < retries) {
+        retriesRef.current++;
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        return fetchData();
+      }
+      setError(fetchError);
+      setLoading(false);
+      setIsFetching(false);
+      retriesRef.current = 0;
+      onError?.(fetchError);
+      return null;
+    }
+  }, [url, cacheKey, cacheTime, transform, retries, retryDelay, body, fetchOptions, onSuccess, onError]);
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+  }, []);
+  const refetch = useCallback(async () => {
+    const key = cacheKey || url || "";
+    cache.delete(key);
+    setLoading(true);
+    return fetchData();
+  }, [fetchData, cacheKey, url]);
+  useEffect(() => {
+    if (skip || !url) {
+      setLoading(false);
+      setIsFetching(false);
+      return;
+    }
+    fetchData();
+    return () => {
+      abort();
+    };
+  }, [url, skip]);
+  return {
+    data,
+    loading,
+    error,
+    refetch,
+    abort,
+    isFetching,
+    status
+  };
+}
+var useFetch_default = useFetch;
+var scriptCache = /* @__PURE__ */ new Map();
+function useScript(src, options = {}) {
+  const { shouldLoad = true, removeOnUnmount = false, attributes = {} } = options;
+  const [status, setStatus] = useState(() => {
+    if (!src) return "idle";
+    if (typeof window === "undefined") return "idle";
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      return scriptCache.get(src) || "ready";
+    }
+    return "idle";
+  });
+  const load = useCallback(() => {
+    if (!src || typeof document === "undefined") return;
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      const cachedStatus = scriptCache.get(src);
+      if (cachedStatus) {
+        setStatus(cachedStatus);
+      }
+      return;
+    }
+    setStatus("loading");
+    scriptCache.set(src, "loading");
+    const script = document.createElement("script");
+    script.src = src;
+    script.async = true;
+    Object.entries(attributes).forEach(([key, value]) => {
+      script.setAttribute(key, value);
+    });
+    const handleLoad = () => {
+      setStatus("ready");
+      scriptCache.set(src, "ready");
+    };
+    const handleError = () => {
+      setStatus("error");
+      scriptCache.set(src, "error");
+    };
+    script.addEventListener("load", handleLoad);
+    script.addEventListener("error", handleError);
+    document.body.appendChild(script);
+  }, [src, attributes]);
+  const remove = useCallback(() => {
+    if (!src || typeof document === "undefined") return;
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      document.body.removeChild(existingScript);
+      scriptCache.delete(src);
+      setStatus("idle");
+    }
+  }, [src]);
+  useEffect(() => {
+    if (shouldLoad && status === "idle") {
+      load();
+    }
+  }, [shouldLoad, status, load]);
+  useEffect(() => {
+    return () => {
+      if (removeOnUnmount) {
+        remove();
+      }
+    };
+  }, [removeOnUnmount, remove]);
+  return {
+    status,
+    ready: status === "ready",
+    loading: status === "loading",
+    error: status === "error",
+    load,
+    remove
+  };
+}
+var useScript_default = useScript;
+function useRenderInfo(componentName = "Component") {
+  const renderCount = useRef(0);
+  const lastRenderTime = useRef(Date.now());
+  const currentTime = Date.now();
+  const sinceLastRender = currentTime - lastRenderTime.current;
+  renderCount.current++;
+  const renders = renderCount.current;
+  useEffect(() => {
+    lastRenderTime.current = currentTime;
+  });
+  const info = {
+    name: componentName,
+    renders,
+    sinceLastRender,
+    timestamp: currentTime
+  };
+  if (process.env.NODE_ENV === "development") {
+    console.log(`[${componentName}] Render #${renders} (${sinceLastRender}ms since last)`);
+  }
+  return info;
+}
+var useRenderInfo_default = useRenderInfo;
+function useRenderCount() {
+  const renderCount = useRef(0);
+  renderCount.current++;
+  return renderCount.current;
+}
+var useRenderCount_default = useRenderCount;
+function useLogger(componentName, props, options = {}) {
+  const {
+    logProps = true,
+    logLifecycle = true,
+    logger = console.log
+  } = options;
+  const previousProps = useRef(props);
+  const renderCount = useRef(0);
+  renderCount.current++;
+  useEffect(() => {
+    if (logLifecycle) {
+      logger(`[${componentName}] Mounted`);
+    }
+    return () => {
+      if (logLifecycle) {
+        logger(`[${componentName}] Unmounted (rendered ${renderCount.current} times)`);
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (!logProps || !props || !previousProps.current) {
+      previousProps.current = props;
+      return;
+    }
+    const changedProps = {};
+    let hasChanges = false;
+    Object.keys(props).forEach((key) => {
+      if (previousProps.current?.[key] !== props[key]) {
+        changedProps[key] = {
+          from: previousProps.current?.[key],
+          to: props[key]
+        };
+        hasChanges = true;
+      }
+    });
+    if (previousProps.current) {
+      Object.keys(previousProps.current).forEach((key) => {
+        if (!(key in props)) {
+          changedProps[key] = {
+            from: previousProps.current?.[key],
+            to: void 0
+          };
+          hasChanges = true;
+        }
+      });
+    }
+    if (hasChanges) {
+      logger(`[${componentName}] Props changed:`, changedProps);
+    }
+    previousProps.current = props;
+  }, [componentName, props, logProps, logger]);
+  if (process.env.NODE_ENV === "development") {
+    logger(`[${componentName}] Render #${renderCount.current}`);
+  }
+}
+var useLogger_default = useLogger;
+var defaultDimensions = {
+  width: 0,
+  height: 0,
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0,
+  x: 0,
+  y: 0
+};
+function useMeasure() {
+  const [dimensions, setDimensions] = useState(defaultDimensions);
+  const elementRef = useRef(null);
+  const observerRef = useRef(null);
+  const measure = useCallback(() => {
+    if (!elementRef.current) return;
+    const rect = elementRef.current.getBoundingClientRect();
+    setDimensions({
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      left: rect.left,
+      bottom: rect.bottom,
+      right: rect.right,
+      x: rect.x,
+      y: rect.y
+    });
+  }, []);
+  const ref = useCallback((node) => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+      observerRef.current = null;
+    }
+    if (node) {
+      elementRef.current = node;
+      if (typeof ResizeObserver !== "undefined") {
+        observerRef.current = new ResizeObserver((entries) => {
+          if (entries[0]) {
+            const rect2 = entries[0].target.getBoundingClientRect();
+            setDimensions({
+              width: rect2.width,
+              height: rect2.height,
+              top: rect2.top,
+              left: rect2.left,
+              bottom: rect2.bottom,
+              right: rect2.right,
+              x: rect2.x,
+              y: rect2.y
+            });
+          }
+        });
+        observerRef.current.observe(node);
+      }
+      const rect = node.getBoundingClientRect();
+      setDimensions({
+        width: rect.width,
+        height: rect.height,
+        top: rect.top,
+        left: rect.left,
+        bottom: rect.bottom,
+        right: rect.right,
+        x: rect.x,
+        y: rect.y
+      });
+    } else {
+      elementRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, []);
+  return { ref, dimensions, measure };
+}
+var useMeasure_default = useMeasure;
+function useIntersectionObserver(options = {}) {
+  const {
+    root = null,
+    rootMargin = "0px",
+    threshold = 0,
+    freezeOnceVisible = false,
+    initialIsIntersecting = false,
+    onChange
+  } = options;
+  const [entry, setEntry] = useState(null);
+  const [isIntersecting, setIsIntersecting] = useState(initialIsIntersecting);
+  const elementRef = useRef(null);
+  const observerRef = useRef(null);
+  const frozen = useRef(false);
+  const ref = useCallback(
+    (node) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (frozen.current) return;
+      if (node && typeof IntersectionObserver !== "undefined") {
+        elementRef.current = node;
+        observerRef.current = new IntersectionObserver(
+          ([observerEntry]) => {
+            const newIsIntersecting = observerEntry.isIntersecting;
+            setEntry(observerEntry);
+            setIsIntersecting(newIsIntersecting);
+            onChange?.(newIsIntersecting, observerEntry);
+            if (freezeOnceVisible && newIsIntersecting) {
+              frozen.current = true;
+              observerRef.current?.disconnect();
+            }
+          },
+          { root, rootMargin, threshold }
+        );
+        observerRef.current.observe(node);
+      } else {
+        elementRef.current = null;
+      }
+    },
+    [root, rootMargin, threshold, freezeOnceVisible, onChange]
+  );
+  useEffect(() => {
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, []);
+  return { ref, isIntersecting, entry };
+}
+var useIntersectionObserver_default = useIntersectionObserver;
+var DEFAULT_DURATION = 4e3;
+function useSnackbar(defaultDuration = DEFAULT_DURATION) {
+  const [state, setState] = useState({
+    open: false,
+    message: "",
+    severity: "info",
+    autoHideDuration: defaultDuration
+  });
+  const show = useCallback(
+    (message, severity = "info", duration) => {
+      setState({
+        open: true,
+        message,
+        severity,
+        autoHideDuration: duration ?? defaultDuration
+      });
+    },
+    [defaultDuration]
+  );
+  const success = useCallback(
+    (message, duration) => show(message, "success", duration),
+    [show]
+  );
+  const error = useCallback(
+    (message, duration) => show(message, "error", duration),
+    [show]
+  );
+  const warning = useCallback(
+    (message, duration) => show(message, "warning", duration),
+    [show]
+  );
+  const info = useCallback(
+    (message, duration) => show(message, "info", duration),
+    [show]
+  );
+  const close = useCallback(() => {
+    setState((prev) => ({ ...prev, open: false }));
+  }, []);
+  return { state, show, success, error, warning, info, close };
+}
+var useSnackbar_default = useSnackbar;
+
+export { useBattery_default as useBattery, useClickAway_default as useClickAway, useContinuousRetry_default as useContinuousRetry, useCopyToClipboard_default as useCopyToClipboard, useCountdown_default as useCountdown, useCounter_default as useCounter, useDebounce_default as useDebounce, useDefault_default as useDefault, useDocumentTitle_default as useDocumentTitle, useEventListener_default as useEventListener, useFavicon_default as useFavicon, useFetch_default as useFetch, useGeolocation_default as useGeolocation, useHistoryState_default as useHistoryState, useHover_default as useHover, useIdle_default as useIdle, useIntersectionObserver_default as useIntersectionObserver, useInterval_default as useInterval, useIntervalWhen_default as useIntervalWhen, useIsClient_default as useIsClient, useIsDesktop, useIsFirstRender_default as useIsFirstRender, useIsMobile, useIsMobileOrTablet, useIsTablet, useKeyPress_default as useKeyPress, useList_default as useList, useLocalStorage_default as useLocalStorage, useLockBodyScroll_default as useLockBodyScroll, useLogger_default as useLogger, useLongPress_default as useLongPress, useMap_default as useMap, useMeasure_default as useMeasure, useMediaQuery_default as useMediaQuery, useMouse_default as useMouse, useNetworkState_default as useNetworkState, useObjectState_default as useObjectState, useOnClickOutside_default as useOnClickOutside, useOrientation_default as useOrientation, usePageLeave_default as usePageLeave, usePageTitle_default as usePageTitle, usePreferredLanguage_default as usePreferredLanguage, usePrevious_default as usePrevious, useQueue_default as useQueue, useRandomInterval_default as useRandomInterval, useRenderCount_default as useRenderCount, useRenderInfo_default as useRenderInfo, useScript_default as useScript, useSessionStorage_default as useSessionStorage, useSet_default as useSet, useSnackbar_default as useSnackbar, useThemeDetector_default as useThemeDetector, useThrottle_default as useThrottle, useTimeout_default as useTimeout, useToggle_default as useToggle, useVisibilityChange_default as useVisibilityChange, useWindowScroll_default as useWindowScroll, useWindowSize_default as useWindowSize };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map