hookery 0.0.1 → 1.0.0

package/dist/index.mjs

@@ -1,11 +1,4176 @@
-// src/index.ts
-function useVersion() {
-  return "0.0.1";
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+import { useEffect, useLayoutEffect } from "react";
+
+// src/utils/index.ts
+var isServer = typeof window === "undefined";
+var isBrowser = !isServer;
+var noop = () => {
+};
+
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+var useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
+
+// src/hooks/useToggle/useToggle.ts
+import { useCallback, useState } from "react";
+function useToggle(options = {}) {
+  const { initialValue = false } = options;
+  const [value, setValue] = useState(initialValue);
+  const toggle = useCallback(() => setValue((prev) => !prev), []);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  return {
+    value,
+    toggle,
+    setTrue,
+    setFalse,
+    setValue
+  };
+}
+
+// src/hooks/useCounter/useCounter.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+function useCounter(options = {}) {
+  const { initialValue = 0, min, max, step = 1 } = options;
+  const clamp = useCallback2(
+    (value) => {
+      let result = value;
+      if (min !== void 0 && result < min) result = min;
+      if (max !== void 0 && result > max) result = max;
+      return result;
+    },
+    [min, max]
+  );
+  const [count, setCount] = useState2(() => clamp(initialValue));
+  const increment = useCallback2(() => {
+    setCount((prev) => clamp(prev + step));
+  }, [clamp, step]);
+  const decrement = useCallback2(() => {
+    setCount((prev) => clamp(prev - step));
+  }, [clamp, step]);
+  const reset = useCallback2(() => {
+    setCount(clamp(initialValue));
+  }, [clamp, initialValue]);
+  const set = useCallback2(
+    (value) => {
+      setCount(clamp(value));
+    },
+    [clamp]
+  );
+  return {
+    count,
+    increment,
+    decrement,
+    reset,
+    set
+  };
+}
+
+// src/hooks/usePrevious/usePrevious.ts
+import { useEffect as useEffect2, useRef } from "react";
+function usePrevious(value) {
+  const ref = useRef(void 0);
+  useEffect2(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+// src/hooks/useMount/useMount.ts
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+function useMount(callback) {
+  const callbackRef = useRef2(callback);
+  callbackRef.current = callback;
+  useEffect3(() => {
+    return callbackRef.current();
+  }, []);
+}
+
+// src/hooks/useUnmount/useUnmount.ts
+import { useEffect as useEffect4, useRef as useRef3 } from "react";
+function useUnmount(callback) {
+  const callbackRef = useRef3(callback);
+  callbackRef.current = callback;
+  useEffect4(() => {
+    return () => {
+      callbackRef.current();
+    };
+  }, []);
+}
+
+// src/hooks/useDebounce/useDebounce.ts
+import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState3 } from "react";
+function useDebounce(value, options = {}) {
+  const { delay = 500, leading = false, trailing = true } = options;
+  const [debouncedValue, setDebouncedValue] = useState3(value);
+  const [isPending, setIsPending] = useState3(false);
+  const timeoutRef = useRef4(null);
+  const leadingRef = useRef4(true);
+  const latestValueRef = useRef4(value);
+  latestValueRef.current = value;
+  const cancel = useCallback3(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    setIsPending(false);
+  }, []);
+  const flush = useCallback3(() => {
+    cancel();
+    setDebouncedValue(latestValueRef.current);
+  }, [cancel]);
+  useEffect5(() => {
+    if (leading && leadingRef.current) {
+      leadingRef.current = false;
+      setDebouncedValue(value);
+      return;
+    }
+    setIsPending(true);
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      if (trailing) {
+        setDebouncedValue(value);
+      }
+      setIsPending(false);
+      timeoutRef.current = null;
+    }, delay);
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [value, delay, leading, trailing]);
+  useEffect5(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  return {
+    debouncedValue,
+    isPending,
+    cancel,
+    flush
+  };
+}
+
+// src/hooks/useThrottle/useThrottle.ts
+import { useEffect as useEffect6, useRef as useRef5, useState as useState4 } from "react";
+function useThrottle(value, options = {}) {
+  const { interval = 500, leading = true, trailing = true } = options;
+  const [throttledValue, setThrottledValue] = useState4(value);
+  const [isPending, setIsPending] = useState4(false);
+  const lastExecuted = useRef5(0);
+  const timeoutRef = useRef5(null);
+  const latestValue = useRef5(value);
+  const isFirstRun = useRef5(true);
+  latestValue.current = value;
+  useEffect6(() => {
+    const now = Date.now();
+    const elapsed = now - lastExecuted.current;
+    if (isFirstRun.current && leading) {
+      isFirstRun.current = false;
+      setThrottledValue(value);
+      lastExecuted.current = now;
+      return;
+    }
+    isFirstRun.current = false;
+    if (elapsed >= interval) {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = null;
+      }
+      setThrottledValue(value);
+      lastExecuted.current = now;
+      setIsPending(false);
+    } else if (trailing) {
+      setIsPending(true);
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        setThrottledValue(latestValue.current);
+        lastExecuted.current = Date.now();
+        setIsPending(false);
+        timeoutRef.current = null;
+      }, interval - elapsed);
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [value, interval, leading, trailing]);
+  useEffect6(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  return {
+    throttledValue,
+    isPending
+  };
+}
+
+// src/hooks/useLocalStorage/useLocalStorage.ts
+import { useCallback as useCallback4, useEffect as useEffect7, useState as useState5 } from "react";
+function useLocalStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    syncAcrossTabs = true
+  } = options;
+  const readValue = useCallback4(() => {
+    if (isServer) {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item !== null ? deserializer(item) : initialValue;
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [key, initialValue, deserializer]);
+  const [storedValue, setStoredValue] = useState5(readValue);
+  const [exists, setExists] = useState5(() => {
+    if (isServer) return false;
+    return window.localStorage.getItem(key) !== null;
+  });
+  const setValue = useCallback4(
+    (value) => {
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        setExists(true);
+        if (!isServer) {
+          window.localStorage.setItem(key, serializer(valueToStore));
+          window.dispatchEvent(
+            new StorageEvent("storage", {
+              key,
+              newValue: serializer(valueToStore)
+            })
+          );
+        }
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key, serializer, storedValue]
+  );
+  const remove = useCallback4(() => {
+    try {
+      setStoredValue(initialValue);
+      setExists(false);
+      if (!isServer) {
+        window.localStorage.removeItem(key);
+      }
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [key, initialValue]);
+  useEffect7(() => {
+    if (isServer || !syncAcrossTabs) return;
+    const handleStorageChange = (event) => {
+      if (event.key === key && event.newValue !== null) {
+        try {
+          setStoredValue(deserializer(event.newValue));
+          setExists(true);
+        } catch {
+        }
+      } else if (event.key === key && event.newValue === null) {
+        setStoredValue(initialValue);
+        setExists(false);
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [key, initialValue, deserializer, syncAcrossTabs]);
+  return {
+    value: storedValue,
+    setValue,
+    remove,
+    exists
+  };
+}
+
+// src/hooks/useSessionStorage/useSessionStorage.ts
+import { useCallback as useCallback5, useEffect as useEffect8, useState as useState6 } from "react";
+function useSessionStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    initializeWithValue = false
+  } = options;
+  const [storedValue, setStoredValue] = useState6(() => {
+    if (isServer) {
+      return typeof initialValue === "function" ? initialValue() : initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      if (item && !initializeWithValue) {
+        return deserializer(item);
+      }
+      const value = typeof initialValue === "function" ? initialValue() : initialValue;
+      if (initializeWithValue) {
+        window.sessionStorage.setItem(key, serializer(value));
+      }
+      return value;
+    } catch (error) {
+      console.error(`Error reading sessionStorage key "${key}":`, error);
+      return typeof initialValue === "function" ? initialValue() : initialValue;
+    }
+  });
+  const setValue = useCallback5(
+    (value) => {
+      try {
+        const valueToStore = value instanceof Function ? value(storedValue) : value;
+        setStoredValue(valueToStore);
+        if (!isServer) {
+          window.sessionStorage.setItem(key, serializer(valueToStore));
+          window.dispatchEvent(new Event("session-storage"));
+        }
+      } catch (error) {
+        console.error(`Error setting sessionStorage key "${key}":`, error);
+      }
+    },
+    [key, storedValue, serializer]
+  );
+  const removeValue = useCallback5(() => {
+    try {
+      setStoredValue(
+        typeof initialValue === "function" ? initialValue() : initialValue
+      );
+      if (!isServer) {
+        window.sessionStorage.removeItem(key);
+        window.dispatchEvent(new Event("session-storage"));
+      }
+    } catch (error) {
+      console.error(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, [key, initialValue]);
+  useEffect8(() => {
+    if (isServer) return;
+    const handleStorageChange = (e) => {
+      if (e.key === key && e.storageArea === window.sessionStorage) {
+        try {
+          if (e.newValue === null) {
+            setStoredValue(
+              typeof initialValue === "function" ? initialValue() : initialValue
+            );
+          } else {
+            setStoredValue(deserializer(e.newValue));
+          }
+        } catch (error) {
+          console.error(`Error syncing sessionStorage key "${key}":`, error);
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key, initialValue, deserializer]);
+  return [storedValue, setValue, removeValue];
+}
+
+// src/hooks/useTimeout/useTimeout.ts
+import { useCallback as useCallback6, useEffect as useEffect9, useRef as useRef6, useState as useState7 } from "react";
+function useTimeout(callback, options) {
+  const { delay, autoStart = true } = options;
+  const [isRunning, setIsRunning] = useState7(autoStart);
+  const [isComplete, setIsComplete] = useState7(false);
+  const callbackRef = useRef6(callback);
+  const timeoutRef = useRef6(null);
+  callbackRef.current = callback;
+  const stop = useCallback6(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    setIsRunning(false);
+  }, []);
+  const start = useCallback6(() => {
+    stop();
+    setIsComplete(false);
+    setIsRunning(true);
+    timeoutRef.current = setTimeout(() => {
+      callbackRef.current();
+      setIsRunning(false);
+      setIsComplete(true);
+      timeoutRef.current = null;
+    }, delay);
+  }, [delay, stop]);
+  const reset = useCallback6(() => {
+    stop();
+    setIsComplete(false);
+  }, [stop]);
+  useEffect9(() => {
+    if (autoStart) {
+      start();
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [delay]);
+  return {
+    isRunning,
+    isComplete,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/hooks/useInterval/useInterval.ts
+import { useCallback as useCallback7, useEffect as useEffect10, useRef as useRef7, useState as useState8 } from "react";
+function useInterval(callback, options) {
+  const { delay, autoStart = true, immediate = false } = options;
+  const [isRunning, setIsRunning] = useState8(autoStart);
+  const [count, setCount] = useState8(0);
+  const callbackRef = useRef7(callback);
+  const intervalRef = useRef7(null);
+  callbackRef.current = callback;
+  const stop = useCallback7(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+    setIsRunning(false);
+  }, []);
+  const start = useCallback7(() => {
+    stop();
+    setIsRunning(true);
+    if (immediate) {
+      callbackRef.current();
+      setCount((c) => c + 1);
+    }
+    intervalRef.current = setInterval(() => {
+      callbackRef.current();
+      setCount((c) => c + 1);
+    }, delay);
+  }, [delay, immediate, stop]);
+  const reset = useCallback7(() => {
+    setCount(0);
+  }, []);
+  useEffect10(() => {
+    if (autoStart) {
+      start();
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [delay]);
+  return {
+    isRunning,
+    count,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/hooks/useUpdateEffect/useUpdateEffect.ts
+import { useEffect as useEffect11, useRef as useRef8 } from "react";
+function useUpdateEffect(effect, deps) {
+  const isFirstMount = useRef8(true);
+  useEffect11(() => {
+    if (isFirstMount.current) {
+      isFirstMount.current = false;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+
+// src/hooks/useIsMounted/useIsMounted.ts
+import { useCallback as useCallback8, useEffect as useEffect12, useRef as useRef9 } from "react";
+function useIsMounted() {
+  const isMountedRef = useRef9(false);
+  useEffect12(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return useCallback8(() => isMountedRef.current, []);
+}
+
+// src/hooks/useStableCallback/useStableCallback.ts
+import { useCallback as useCallback9, useEffect as useEffect13, useRef as useRef10 } from "react";
+function useStableCallback(callback) {
+  const callbackRef = useRef10(callback);
+  useEffect13(() => {
+    callbackRef.current = callback;
+  });
+  return useCallback9((...args) => {
+    return callbackRef.current(...args);
+  }, []);
+}
+var useStableCallback_default = useStableCallback;
+
+// src/hooks/useMediaQuery/useMediaQuery.ts
+import { useCallback as useCallback10, useEffect as useEffect14, useState as useState9 } from "react";
+function useMediaQuery(query, options = {}) {
+  const { defaultValue = false, initializeOnMount = false } = options;
+  const getMatches = useCallback10(() => {
+    if (isServer) {
+      return defaultValue;
+    }
+    return window.matchMedia(query).matches;
+  }, [query, defaultValue]);
+  const [matches, setMatches] = useState9(() => {
+    if (initializeOnMount) {
+      return defaultValue;
+    }
+    return getMatches();
+  });
+  useEffect14(() => {
+    if (isServer) return;
+    const mediaQueryList = window.matchMedia(query);
+    setMatches(mediaQueryList.matches);
+    const handleChange = (event) => {
+      setMatches(event.matches);
+    };
+    if (mediaQueryList.addEventListener) {
+      mediaQueryList.addEventListener("change", handleChange);
+    } else {
+      mediaQueryList.addListener(handleChange);
+    }
+    return () => {
+      if (mediaQueryList.removeEventListener) {
+        mediaQueryList.removeEventListener("change", handleChange);
+      } else {
+        mediaQueryList.removeListener(handleChange);
+      }
+    };
+  }, [query]);
+  return matches;
+}
+
+// src/hooks/useWindowSize/useWindowSize.ts
+import { useCallback as useCallback11, useEffect as useEffect15, useState as useState10 } from "react";
+function useWindowSize(options = {}) {
+  const { debounce = 0, initialWidth = 0, initialHeight = 0 } = options;
+  const getSize = useCallback11(() => {
+    if (isServer) {
+      return { width: initialWidth, height: initialHeight };
+    }
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  }, [initialWidth, initialHeight]);
+  const [windowSize, setWindowSize] = useState10(getSize);
+  useEffect15(() => {
+    if (isServer) return;
+    let timeoutId = null;
+    const handleResize = () => {
+      if (debounce > 0) {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+          setWindowSize(getSize());
+        }, debounce);
+      } else {
+        setWindowSize(getSize());
+      }
+    };
+    setWindowSize(getSize());
+    window.addEventListener("resize", handleResize);
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [debounce, getSize]);
+  return windowSize;
+}
+
+// src/hooks/useClickOutside/useClickOutside.ts
+import { useEffect as useEffect16, useRef as useRef11 } from "react";
+function useClickOutside(ref, callback, options = {}) {
+  const { events = ["mousedown", "touchstart"], enabled = true } = options;
+  const callbackRef = useRef11(callback);
+  callbackRef.current = callback;
+  useEffect16(() => {
+    if (isServer || !enabled) return;
+    const handleClick = (event) => {
+      const el = ref.current;
+      if (!el || el.contains(event.target)) {
+        return;
+      }
+      callbackRef.current(event);
+    };
+    events.forEach((eventName) => {
+      document.addEventListener(eventName, handleClick);
+    });
+    return () => {
+      events.forEach((eventName) => {
+        document.removeEventListener(eventName, handleClick);
+      });
+    };
+  }, [ref, events, enabled]);
+}
+
+// src/hooks/useHover/useHover.ts
+import { useCallback as useCallback12, useRef as useRef12, useState as useState11 } from "react";
+function useHover() {
+  const [isHovered, setIsHovered] = useState11(false);
+  const nodeRef = useRef12(null);
+  const handleMouseEnter = useCallback12(() => {
+    setIsHovered(true);
+  }, []);
+  const handleMouseLeave = useCallback12(() => {
+    setIsHovered(false);
+  }, []);
+  const ref = useCallback12(
+    (node) => {
+      if (nodeRef.current) {
+        nodeRef.current.removeEventListener("mouseenter", handleMouseEnter);
+        nodeRef.current.removeEventListener("mouseleave", handleMouseLeave);
+      }
+      if (node) {
+        node.addEventListener("mouseenter", handleMouseEnter);
+        node.addEventListener("mouseleave", handleMouseLeave);
+      }
+      nodeRef.current = node;
+    },
+    [handleMouseEnter, handleMouseLeave]
+  );
+  return {
+    isHovered,
+    ref,
+    hoverProps: {
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave
+    }
+  };
+}
+
+// src/hooks/useKeyPress/useKeyPress.ts
+import { useCallback as useCallback13, useEffect as useEffect17, useState as useState12 } from "react";
+function useKeyPress(targetKey, callback, options = {}) {
+  const {
+    target = "window",
+    event = "keydown",
+    preventDefault = false,
+    enabled = true
+  } = options;
+  const [isPressed, setIsPressed] = useState12(false);
+  const callbackRef = useCallback13(
+    (e) => {
+      callback?.(e);
+    },
+    [callback]
+  );
+  useEffect17(() => {
+    if (isServer || !enabled) return;
+    const targetElement = target === "document" ? document : window;
+    const handleKeyDown = (e) => {
+      const event2 = e;
+      if (event2.key === targetKey) {
+        if (preventDefault) {
+          event2.preventDefault();
+        }
+        setIsPressed(true);
+        callbackRef(event2);
+      }
+    };
+    const handleKeyUp = (e) => {
+      const event2 = e;
+      if (event2.key === targetKey) {
+        setIsPressed(false);
+      }
+    };
+    targetElement.addEventListener(event, handleKeyDown);
+    if (event === "keydown") {
+      targetElement.addEventListener("keyup", handleKeyUp);
+    }
+    return () => {
+      targetElement.removeEventListener(event, handleKeyDown);
+      if (event === "keydown") {
+        targetElement.removeEventListener("keyup", handleKeyUp);
+      }
+    };
+  }, [targetKey, target, event, preventDefault, enabled, callbackRef]);
+  return isPressed;
+}
+
+// src/hooks/useScroll/useScroll.ts
+import { useEffect as useEffect18, useRef as useRef13, useState as useState13 } from "react";
+function useScroll(ref, options = {}) {
+  const { throttle = 0 } = options;
+  const [position, setPosition] = useState13({ x: 0, y: 0 });
+  const [direction, setDirection] = useState13(null);
+  const [boundaries, setBoundaries] = useState13({
+    isAtTop: true,
+    isAtBottom: false,
+    isAtLeft: true,
+    isAtRight: false
+  });
+  const lastPositionRef = useRef13({ x: 0, y: 0 });
+  const throttleTimerRef = useRef13(null);
+  useEffect18(() => {
+    if (isServer) return;
+    const target = ref?.current ?? window;
+    const isWindow = target === window;
+    const getScrollPosition = () => {
+      if (isWindow) {
+        return {
+          x: window.scrollX ?? window.pageXOffset,
+          y: window.scrollY ?? window.pageYOffset
+        };
+      }
+      const element = target;
+      return {
+        x: element.scrollLeft,
+        y: element.scrollTop
+      };
+    };
+    const getBoundaries = () => {
+      if (isWindow) {
+        const scrollHeight = document.documentElement.scrollHeight;
+        const scrollWidth = document.documentElement.scrollWidth;
+        const clientHeight = window.innerHeight;
+        const clientWidth = window.innerWidth;
+        const { x, y } = getScrollPosition();
+        return {
+          isAtTop: y <= 0,
+          isAtBottom: y + clientHeight >= scrollHeight - 1,
+          isAtLeft: x <= 0,
+          isAtRight: x + clientWidth >= scrollWidth - 1
+        };
+      }
+      const element = target;
+      return {
+        isAtTop: element.scrollTop <= 0,
+        isAtBottom: element.scrollTop + element.clientHeight >= element.scrollHeight - 1,
+        isAtLeft: element.scrollLeft <= 0,
+        isAtRight: element.scrollLeft + element.clientWidth >= element.scrollWidth - 1
+      };
+    };
+    const handleScroll = () => {
+      const execute = () => {
+        const newPosition = getScrollPosition();
+        const lastPosition = lastPositionRef.current;
+        if (newPosition.y !== lastPosition.y) {
+          setDirection(newPosition.y > lastPosition.y ? "down" : "up");
+        } else if (newPosition.x !== lastPosition.x) {
+          setDirection(newPosition.x > lastPosition.x ? "right" : "left");
+        }
+        lastPositionRef.current = newPosition;
+        setPosition(newPosition);
+        setBoundaries(getBoundaries());
+      };
+      if (throttle > 0) {
+        if (!throttleTimerRef.current) {
+          throttleTimerRef.current = setTimeout(() => {
+            execute();
+            throttleTimerRef.current = null;
+          }, throttle);
+        }
+      } else {
+        execute();
+      }
+    };
+    setPosition(getScrollPosition());
+    setBoundaries(getBoundaries());
+    target.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      target.removeEventListener("scroll", handleScroll);
+      if (throttleTimerRef.current) {
+        clearTimeout(throttleTimerRef.current);
+      }
+    };
+  }, [ref, throttle]);
+  return {
+    ...position,
+    ...boundaries,
+    direction
+  };
+}
+
+// src/hooks/useIntersection/useIntersection.ts
+import { useEffect as useEffect19, useRef as useRef14, useState as useState14 } from "react";
+function useIntersection(options = {}) {
+  const {
+    root = null,
+    rootMargin = "0px",
+    threshold = 0,
+    triggerOnce = false,
+    enabled = true
+  } = options;
+  const [entry, setEntry] = useState14(null);
+  const [isIntersecting, setIsIntersecting] = useState14(false);
+  const ref = useRef14(null);
+  const hasTriggeredRef = useRef14(false);
+  useEffect19(() => {
+    if (isServer || !enabled) return;
+    const element = ref.current;
+    if (!element) return;
+    if (triggerOnce && hasTriggeredRef.current) return;
+    const observer = new IntersectionObserver(
+      ([observerEntry]) => {
+        setEntry(observerEntry);
+        setIsIntersecting(observerEntry.isIntersecting);
+        if (observerEntry.isIntersecting && triggerOnce) {
+          hasTriggeredRef.current = true;
+          observer.unobserve(element);
+        }
+      },
+      {
+        root,
+        rootMargin,
+        threshold
+      }
+    );
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, [root, rootMargin, threshold, triggerOnce, enabled]);
+  return {
+    isIntersecting,
+    entry,
+    ref
+  };
+}
+
+// src/hooks/useCopyToClipboard/useCopyToClipboard.ts
+import { useCallback as useCallback14, useState as useState15 } from "react";
+function useCopyToClipboard() {
+  const [copiedValue, setCopiedValue] = useState15(null);
+  const [isSuccess, setIsSuccess] = useState15(false);
+  const [error, setError] = useState15(null);
+  const copy = useCallback14(async (text) => {
+    if (isServer) {
+      console.warn("Clipboard is not available on the server");
+      return false;
+    }
+    if (navigator?.clipboard?.writeText) {
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopiedValue(text);
+        setIsSuccess(true);
+        setError(null);
+        return true;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to copy"));
+        setIsSuccess(false);
+        return false;
+      }
+    }
+    try {
+      const textArea = document.createElement("textarea");
+      textArea.value = text;
+      textArea.style.position = "fixed";
+      textArea.style.left = "-9999px";
+      textArea.style.top = "-9999px";
+      document.body.appendChild(textArea);
+      textArea.focus();
+      textArea.select();
+      const successful = document.execCommand("copy");
+      document.body.removeChild(textArea);
+      if (successful) {
+        setCopiedValue(text);
+        setIsSuccess(true);
+        setError(null);
+        return true;
+      } else {
+        throw new Error('execCommand("copy") failed');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to copy"));
+      setIsSuccess(false);
+      return false;
+    }
+  }, []);
+  const reset = useCallback14(() => {
+    setCopiedValue(null);
+    setIsSuccess(false);
+    setError(null);
+  }, []);
+  return {
+    copiedValue,
+    isSuccess,
+    error,
+    copy,
+    reset
+  };
+}
+
+// src/hooks/useDocumentTitle/useDocumentTitle.ts
+import { useEffect as useEffect20, useRef as useRef15 } from "react";
+function useDocumentTitle(title, options = {}) {
+  const { restoreOnUnmount = true } = options;
+  const previousTitleRef = useRef15(null);
+  useEffect20(() => {
+    if (isServer) return;
+    if (previousTitleRef.current === null) {
+      previousTitleRef.current = document.title;
+    }
+    document.title = title;
+    return () => {
+      if (restoreOnUnmount && previousTitleRef.current !== null) {
+        document.title = previousTitleRef.current;
+      }
+    };
+  }, [title, restoreOnUnmount]);
+}
+
+// src/hooks/useLockBodyScroll/useLockBodyScroll.ts
+import { useEffect as useEffect21 } from "react";
+function useLockBodyScroll(lock = true) {
+  useEffect21(() => {
+    if (isServer || !lock) return;
+    const originalOverflow = document.body.style.overflow;
+    const originalPaddingRight = document.body.style.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 = originalOverflow;
+      document.body.style.paddingRight = originalPaddingRight;
+    };
+  }, [lock]);
+}
+
+// src/hooks/useTheme/useTheme.ts
+import { useCallback as useCallback15, useMemo } from "react";
+function useTheme(options = {}) {
+  const {
+    storageKey = "theme",
+    attribute = "data-theme",
+    defaultTheme = "system",
+    disableTransitionOnChange = true
+  } = options;
+  const { value: theme, setValue: setTheme } = useLocalStorage(
+    storageKey,
+    defaultTheme
+  );
+  const systemPrefersDark = useMediaQuery("(prefers-color-scheme: dark)");
+  const resolvedTheme = useMemo(() => {
+    if (theme === "system") {
+      return systemPrefersDark ? "dark" : "light";
+    }
+    return theme === "dark" ? "dark" : "light";
+  }, [theme, systemPrefersDark]);
+  const applyTheme = useCallback15(() => {
+    if (isServer) return;
+    const root = document.documentElement;
+    if (disableTransitionOnChange) {
+      const css = document.createElement("style");
+      css.appendChild(
+        document.createTextNode(
+          `* {
+             -webkit-transition: none !important;
+             -moz-transition: none !important;
+             -o-transition: none !important;
+             -ms-transition: none !important;
+             transition: none !important;
+           }`
+        )
+      );
+      document.head.appendChild(css);
+      setTimeout(() => {
+        (() => window.getComputedStyle(document.body))();
+        setTimeout(() => {
+          document.head.removeChild(css);
+        }, 1);
+      }, 1);
+    }
+    if (attribute === "class") {
+      root.classList.remove("light", "dark");
+      root.classList.add(resolvedTheme);
+    } else {
+      root.setAttribute(attribute, resolvedTheme);
+    }
+  }, [resolvedTheme, attribute, disableTransitionOnChange]);
+  useIsomorphicLayoutEffect(() => {
+    applyTheme();
+  }, [applyTheme]);
+  const toggleTheme = useCallback15(() => {
+    setTheme((prev) => {
+      if (prev === "system") return resolvedTheme === "dark" ? "light" : "dark";
+      return prev === "dark" ? "light" : "dark";
+    });
+  }, [setTheme, resolvedTheme]);
+  return {
+    theme,
+    resolvedTheme,
+    setTheme,
+    toggleTheme
+  };
+}
+
+// src/hooks/useEvent/useEvent.ts
+import { useEffect as useEffect22, useRef as useRef16 } from "react";
+function useEvent(name, handler, target = isServer ? null : window, options = {}) {
+  const handlerRef = useRef16(handler);
+  handlerRef.current = handler;
+  useEffect22(() => {
+    if (!target) return;
+    const eventListener = (event) => {
+      if (typeof handlerRef.current === "function") {
+        handlerRef.current(event);
+      } else {
+        handlerRef.current.handleEvent(event);
+      }
+    };
+    target.addEventListener(name, eventListener, options);
+    return () => {
+      target.removeEventListener(name, eventListener, options);
+    };
+  }, [name, target, options?.capture, options?.passive, options?.once]);
+}
+
+// src/hooks/useLongPress/useLongPress.ts
+import { useCallback as useCallback16, useRef as useRef17 } from "react";
+function useLongPress(onLongPress, options = {}) {
+  const {
+    threshold = 500,
+    cancelOnMove = true,
+    onStart,
+    onFinish,
+    onCancel
+  } = options;
+  const callbackRef = useRef17(onLongPress);
+  const onStartRef = useRef17(onStart);
+  const onFinishRef = useRef17(onFinish);
+  const onCancelRef = useRef17(onCancel);
+  callbackRef.current = onLongPress;
+  onStartRef.current = onStart;
+  onFinishRef.current = onFinish;
+  onCancelRef.current = onCancel;
+  const timerRef = useRef17(null);
+  const isLongPressActive = useRef17(false);
+  const start = useCallback16(
+    (event) => {
+      onStartRef.current?.(event);
+      isLongPressActive.current = false;
+      timerRef.current = setTimeout(() => {
+        isLongPressActive.current = true;
+        callbackRef.current(event);
+        onFinishRef.current?.(event);
+      }, threshold);
+    },
+    [threshold]
+  );
+  const cancel = useCallback16(
+    (event) => {
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+        if (!isLongPressActive.current) {
+          onCancelRef.current?.(event);
+        }
+      }
+      isLongPressActive.current = false;
+    },
+    []
+  );
+  return {
+    onMouseDown: (e) => start(e),
+    onTouchStart: (e) => start(e),
+    onMouseUp: (e) => cancel(e),
+    onMouseLeave: (e) => cancel(e),
+    onTouchEnd: (e) => cancel(e)
+  };
+}
+
+// src/hooks/useWindowFocus/useWindowFocus.ts
+import { useEffect as useEffect23, useState as useState16 } from "react";
+function useWindowFocus() {
+  const [isFocused, setIsFocused] = useState16(
+    () => !isServer && typeof document !== "undefined" ? document.hasFocus() : true
+  );
+  useEffect23(() => {
+    if (isServer) return;
+    const onFocus = () => setIsFocused(true);
+    const onBlur = () => setIsFocused(false);
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    setIsFocused(document.hasFocus());
+    return () => {
+      window.removeEventListener("focus", onFocus);
+      window.removeEventListener("blur", onBlur);
+    };
+  }, []);
+  return isFocused;
+}
+
+// src/hooks/useResizeObserver/useResizeObserver.ts
+import { useEffect as useEffect24, useRef as useRef18, useState as useState17 } from "react";
+function useResizeObserver(ref, options = {}) {
+  const { throttle = 0 } = options;
+  const [contentRect, setContentRect] = useState17();
+  const throttleTimerRef = useRef18(null);
+  useEffect24(() => {
+    if (isServer) return;
+    const element = ref.current;
+    if (!element) return;
+    if (!window.ResizeObserver) {
+      console.warn("ResizeObserver is not supported in this browser");
+      return;
+    }
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const update = () => {
+        setContentRect(entry.contentRect);
+      };
+      if (throttle > 0) {
+        if (!throttleTimerRef.current) {
+          throttleTimerRef.current = setTimeout(() => {
+            update();
+            throttleTimerRef.current = null;
+          }, throttle);
+        }
+      } else {
+        update();
+      }
+    });
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+      if (throttleTimerRef.current) {
+        clearTimeout(throttleTimerRef.current);
+      }
+    };
+  }, [ref, throttle]);
+  return contentRect;
+}
+
+// src/hooks/useMutationObserver/useMutationObserver.ts
+import { useEffect as useEffect25, useRef as useRef19 } from "react";
+function useMutationObserver(ref, callback, options = {
+  attributes: true,
+  characterData: true,
+  childList: true,
+  subtree: true
+}) {
+  const callbackRef = useRef19(callback);
+  callbackRef.current = callback;
+  const optionsRef = useRef19(options);
+  optionsRef.current = options;
+  useEffect25(() => {
+    if (isServer) return;
+    const element = ref.current;
+    if (!element) return;
+    if (!window.MutationObserver) {
+      console.warn("MutationObserver is not supported");
+      return;
+    }
+    const observer = new MutationObserver((mutations, obs) => {
+      callbackRef.current(mutations, obs);
+    });
+    observer.observe(element, optionsRef.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [ref]);
+}
+
+// src/hooks/usePageLeave/usePageLeave.ts
+import { useEffect as useEffect26 } from "react";
+function usePageLeave(onPageLeave) {
+  useEffect26(() => {
+    if (isServer) return;
+    const handler = (event) => {
+      event = event || window.event;
+      const from = event.relatedTarget || event.toElement;
+      if (!from || from.nodeName === "HTML") {
+        if (event.clientY <= 0) {
+          onPageLeave();
+        }
+      }
+    };
+    const simpleHandler = (event) => {
+      if (event.clientY <= 0) {
+        onPageLeave();
+      }
+    };
+    document.addEventListener("mouseleave", simpleHandler);
+    return () => {
+      document.removeEventListener("mouseleave", simpleHandler);
+    };
+  }, [onPageLeave]);
+}
+
+// src/hooks/useEyeDropper/useEyeDropper.ts
+import { useCallback as useCallback17 } from "react";
+function useEyeDropper() {
+  const isSupported = !isServer && "EyeDropper" in window;
+  const open = useCallback17(async (options) => {
+    if (!isSupported) {
+      throw new Error("EyeDropper is not supported");
+    }
+    const eyeDropper = new window.EyeDropper();
+    return eyeDropper.open(options);
+  }, [isSupported]);
+  return {
+    isSupported,
+    open
+  };
+}
+
+// src/hooks/useOnline/useOnline.ts
+import { useCallback as useCallback18, useEffect as useEffect27, useState as useState18 } from "react";
+function useOnline() {
+  const [isOnline, setIsOnline] = useState18(() => {
+    if (isServer) return true;
+    return navigator.onLine;
+  });
+  const [since, setSince] = useState18(null);
+  const handleOnline = useCallback18(() => {
+    setIsOnline(true);
+    setSince(Date.now());
+  }, []);
+  const handleOffline = useCallback18(() => {
+    setIsOnline(false);
+    setSince(Date.now());
+  }, []);
+  useEffect27(() => {
+    if (isServer) return;
+    setIsOnline(navigator.onLine);
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+    };
+  }, [handleOnline, handleOffline]);
+  return {
+    isOnline,
+    isOffline: !isOnline,
+    since
+  };
+}
+
+// src/hooks/useNetworkState/useNetworkState.ts
+import { useEffect as useEffect28, useState as useState19 } from "react";
+function useNetworkState() {
+  const [state, setState] = useState19({
+    online: true
+  });
+  useEffect28(() => {
+    if (isServer) return;
+    const nav = navigator;
+    const connection = nav.connection || nav.mozConnection || nav.webkitConnection;
+    const updateState = () => {
+      setState({
+        online: navigator.onLine,
+        downlink: connection?.downlink,
+        downlinkMax: connection?.downlinkMax,
+        effectiveType: connection?.effectiveType,
+        rtt: connection?.rtt,
+        saveData: connection?.saveData,
+        type: connection?.type
+      });
+    };
+    updateState();
+    window.addEventListener("online", updateState);
+    window.addEventListener("offline", updateState);
+    if (connection) {
+      connection.addEventListener("change", updateState);
+    }
+    return () => {
+      window.removeEventListener("online", updateState);
+      window.removeEventListener("offline", updateState);
+      if (connection) {
+        connection.removeEventListener("change", updateState);
+      }
+    };
+  }, []);
+  return state;
+}
+
+// src/hooks/useFullscreen/useFullscreen.ts
+import { useCallback as useCallback19, useEffect as useEffect29, useState as useState20 } from "react";
+function useFullscreen(ref) {
+  const [isFullscreen, setIsFullscreen] = useState20(false);
+  const isSupported = !isServer && !!document.fullscreenEnabled;
+  const getElement = useCallback19(() => {
+    return ref?.current ?? document.documentElement;
+  }, [ref]);
+  const enter = useCallback19(async () => {
+    if (isServer || !isSupported) return;
+    const element = getElement();
+    if (!element) return;
+    try {
+      await element.requestFullscreen();
+    } catch (error) {
+      console.error("Failed to enter fullscreen:", error);
+    }
+  }, [isSupported, getElement]);
+  const exit = useCallback19(async () => {
+    if (isServer || !isSupported) return;
+    try {
+      await document.exitFullscreen();
+    } catch (error) {
+      console.error("Failed to exit fullscreen:", error);
+    }
+  }, [isSupported]);
+  const toggle = useCallback19(async () => {
+    if (isFullscreen) {
+      await exit();
+    } else {
+      await enter();
+    }
+  }, [isFullscreen, enter, exit]);
+  useEffect29(() => {
+    if (isServer) return;
+    const handleChange = () => {
+      setIsFullscreen(!!document.fullscreenElement);
+    };
+    document.addEventListener("fullscreenchange", handleChange);
+    return () => {
+      document.removeEventListener("fullscreenchange", handleChange);
+    };
+  }, []);
+  return {
+    isFullscreen,
+    isSupported,
+    enter,
+    exit,
+    toggle
+  };
+}
+
+// src/hooks/useShare/useShare.ts
+import { useCallback as useCallback20, useState as useState21 } from "react";
+function useShare() {
+  const [isSharing, setIsSharing] = useState21(false);
+  const [isSuccess, setIsSuccess] = useState21(false);
+  const [error, setError] = useState21(null);
+  const isSupported = !isServer && !!navigator.share;
+  const canShare = useCallback20(
+    (data) => {
+      if (isServer || !navigator.canShare) return isSupported;
+      if (!data) return isSupported;
+      return navigator.canShare(data);
+    },
+    [isSupported]
+  );
+  const share = useCallback20(
+    async (data) => {
+      if (isServer || !isSupported) {
+        setError(new Error("Web Share API is not supported"));
+        return false;
+      }
+      setIsSharing(true);
+      setIsSuccess(false);
+      setError(null);
+      try {
+        await navigator.share(data);
+        setIsSuccess(true);
+        return true;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          setIsSuccess(false);
+          return false;
+        }
+        const error2 = err instanceof Error ? err : new Error("Share failed");
+        setError(error2);
+        return false;
+      } finally {
+        setIsSharing(false);
+      }
+    },
+    [isSupported]
+  );
+  return {
+    isSupported,
+    isSharing,
+    isSuccess,
+    error,
+    share,
+    canShare
+  };
+}
+
+// src/hooks/usePermissions/usePermissions.ts
+import { useEffect as useEffect30, useState as useState22 } from "react";
+function usePermissions(name) {
+  const [state, setState] = useState22("unknown");
+  useEffect30(() => {
+    if (isServer || !navigator.permissions) return;
+    let mounted = true;
+    let permissionStatus = null;
+    const handleChange = () => {
+      if (mounted && permissionStatus) {
+        setState(permissionStatus.state);
+      }
+    };
+    navigator.permissions.query({ name }).then((status) => {
+      if (!mounted) return;
+      permissionStatus = status;
+      setState(permissionStatus.state);
+      status.addEventListener("change", handleChange);
+    }).catch(() => {
+      if (mounted) setState("unknown");
+    });
+    return () => {
+      mounted = false;
+      if (permissionStatus) {
+        permissionStatus.removeEventListener("change", handleChange);
+      }
+    };
+  }, [name]);
+  return state;
+}
+
+// src/hooks/useWakeLock/useWakeLock.ts
+import { useCallback as useCallback21, useEffect as useEffect31, useRef as useRef20, useState as useState23 } from "react";
+function useWakeLock({
+  onRequest,
+  onRelease,
+  onError
+} = {}) {
+  const [released, setReleased] = useState23();
+  const wakeLockRef = useRef20(null);
+  const isSupported = !isServer && "wakeLock" in navigator;
+  const release = useCallback21(async () => {
+    if (!wakeLockRef.current) return;
+    try {
+      await wakeLockRef.current.release();
+      wakeLockRef.current = null;
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [onError]);
+  const request = useCallback21(async () => {
+    if (!isSupported) return;
+    try {
+      const wakeLock = await navigator.wakeLock.request("screen");
+      wakeLock.addEventListener("release", () => {
+        setReleased(true);
+        onRelease?.();
+        wakeLockRef.current = null;
+      });
+      wakeLockRef.current = wakeLock;
+      setReleased(false);
+      onRequest?.();
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [isSupported, onRequest, onRelease, onError]);
+  useEffect31(() => {
+    return () => {
+      release();
+    };
+  }, [release]);
+  useEffect31(() => {
+    const handleVisibilityChange = async () => {
+      if (wakeLockRef.current !== null && document.visibilityState === "visible") {
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+  }, []);
+  return {
+    isSupported,
+    released: released ?? true,
+    // Default to true (released) initially
+    request,
+    release
+  };
+}
+
+// src/hooks/useMediaDevices/useMediaDevices.ts
+import { useEffect as useEffect32, useState as useState24 } from "react";
+function useMediaDevices() {
+  const [devices, setDevices] = useState24([]);
+  const [isLoading, setIsLoading] = useState24(true);
+  const [error, setError] = useState24(null);
+  const isSupported = !isServer && !!navigator.mediaDevices?.enumerateDevices;
+  const getDevices = useStableCallback_default(async () => {
+    if (!isSupported) {
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const allDevices = await navigator.mediaDevices.enumerateDevices();
+      setDevices(allDevices);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  });
+  useEffect32(() => {
+    getDevices();
+    if (isSupported) {
+      navigator.mediaDevices.addEventListener("devicechange", getDevices);
+      return () => {
+        navigator.mediaDevices.removeEventListener("devicechange", getDevices);
+      };
+    }
+  }, [getDevices, isSupported]);
+  return {
+    devices,
+    isLoading,
+    error,
+    isSupported
+  };
+}
+
+// src/hooks/useMediaRecorder/useMediaRecorder.ts
+import { useCallback as useCallback22, useRef as useRef21, useState as useState25 } from "react";
+function useMediaRecorder(stream, options) {
+  const [status, setStatus] = useState25("idle");
+  const [mediaBlob, setMediaBlob] = useState25();
+  const [mediaUrl, setMediaUrl] = useState25();
+  const [error, setError] = useState25(null);
+  const mediaRecorderRef = useRef21(null);
+  const chunksRef = useRef21([]);
+  const start = useCallback22(
+    (timeSlice) => {
+      if (!stream) return;
+      try {
+        if (!mediaRecorderRef.current) {
+          mediaRecorderRef.current = new MediaRecorder(stream, options);
+          mediaRecorderRef.current.ondataavailable = (event) => {
+            if (event.data && event.data.size > 0) {
+              chunksRef.current.push(event.data);
+            }
+          };
+          mediaRecorderRef.current.onerror = (event) => {
+            setError(event.error);
+            setStatus("idle");
+          };
+          mediaRecorderRef.current.onstop = () => {
+            const blob = new Blob(chunksRef.current, { type: options?.mimeType || "video/webm" });
+            setMediaBlob(blob);
+            const url = URL.createObjectURL(blob);
+            setMediaUrl(url);
+            chunksRef.current = [];
+            setStatus("stopped");
+          };
+        }
+        if (mediaRecorderRef.current.state !== "recording") {
+          mediaRecorderRef.current.start(timeSlice);
+          setStatus("recording");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [stream, options]
+  );
+  const stop = useCallback22(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+      mediaRecorderRef.current.stop();
+    }
+  }, []);
+  const pause = useCallback22(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state === "recording") {
+      mediaRecorderRef.current.pause();
+      setStatus("paused");
+    }
+  }, []);
+  const resume = useCallback22(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state === "paused") {
+      mediaRecorderRef.current.resume();
+      setStatus("recording");
+    }
+  }, []);
+  const clear = useCallback22(() => {
+    if (mediaUrl) {
+      URL.revokeObjectURL(mediaUrl);
+    }
+    setMediaBlob(void 0);
+    setMediaUrl(void 0);
+    setError(null);
+    setStatus("idle");
+  }, [mediaUrl]);
+  return {
+    status,
+    start,
+    stop,
+    pause,
+    resume,
+    isRecording: status === "recording",
+    mediaBlob,
+    mediaUrl,
+    clear,
+    error
+  };
+}
+
+// src/hooks/useBattery/useBattery.ts
+import { useEffect as useEffect33, useState as useState26 } from "react";
+function useBattery() {
+  const [state, setState] = useState26({
+    supported: false,
+    loading: true,
+    level: 1,
+    charging: false,
+    chargingTime: 0,
+    dischargingTime: Infinity
+  });
+  useEffect33(() => {
+    if (isServer || !("getBattery" in navigator)) {
+      setState((s) => ({ ...s, loading: false, supported: false }));
+      return;
+    }
+    let mounted = true;
+    let battery = null;
+    const handleChange = () => {
+      if (!mounted || !battery) return;
+      setState({
+        supported: true,
+        loading: false,
+        level: battery.level,
+        charging: battery.charging,
+        chargingTime: battery.chargingTime,
+        dischargingTime: battery.dischargingTime
+      });
+    };
+    navigator.getBattery().then((bat) => {
+      if (!mounted) return;
+      battery = bat;
+      handleChange();
+      battery.addEventListener("levelchange", handleChange);
+      battery.addEventListener("chargingchange", handleChange);
+      battery.addEventListener("chargingtimechange", handleChange);
+      battery.addEventListener("dischargingtimechange", handleChange);
+    });
+    return () => {
+      mounted = false;
+      if (battery) {
+        battery.removeEventListener("levelchange", handleChange);
+        battery.removeEventListener("chargingchange", handleChange);
+        battery.removeEventListener("chargingtimechange", handleChange);
+        battery.removeEventListener("dischargingtimechange", handleChange);
+      }
+    };
+  }, []);
+  return state;
+}
+
+// src/hooks/useBluetooth/useBluetooth.ts
+import { useCallback as useCallback23, useState as useState27 } from "react";
+function useBluetooth() {
+  const [device, setDevice] = useState27(null);
+  const [server, setServer] = useState27(null);
+  const [error, setError] = useState27(null);
+  const [isConnecting, setIsConnecting] = useState27(false);
+  const isSupported = !isServer && "bluetooth" in navigator;
+  const disconnect = useCallback23(() => {
+    if (device && device.gatt?.connected) {
+      device.gatt.disconnect();
+    }
+    setDevice(null);
+    setServer(null);
+    setIsConnecting(false);
+  }, [device]);
+  const requestDevice = useCallback23(
+    async (options) => {
+      if (!isSupported) {
+        setError(new Error("Bluetooth API not supported"));
+        return;
+      }
+      setIsConnecting(true);
+      setError(null);
+      try {
+        const device2 = await navigator.bluetooth.requestDevice(options || { acceptAllDevices: true });
+        setDevice(device2);
+        device2.addEventListener("gattserverdisconnected", () => {
+          setServer(null);
+        });
+        if (device2.gatt) {
+          const server2 = await device2.gatt.connect();
+          setServer(server2);
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        setIsConnecting(false);
+      }
+    },
+    [isSupported]
+  );
+  return {
+    isSupported,
+    isConnected: !!server?.connected,
+    isConnecting,
+    device,
+    server,
+    error,
+    requestDevice,
+    disconnect
+  };
+}
+
+// src/hooks/useGamepad/useGamepad.ts
+import { useEffect as useEffect34, useRef as useRef22, useState as useState28 } from "react";
+function useGamepad(options = {}) {
+  const { enabled = true } = options;
+  const [gamepads, setGamepads] = useState28([]);
+  const requestRef = useRef22(null);
+  const scanGamepads = () => {
+    if (isServer) return;
+    const detectedGamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    const gamepadArray = Array.from(detectedGamepads);
+    setGamepads(gamepadArray);
+  };
+  useEffect34(() => {
+    if (isServer) return;
+    window.addEventListener("gamepadconnected", scanGamepads);
+    window.addEventListener("gamepaddisconnected", scanGamepads);
+    return () => {
+      window.removeEventListener("gamepadconnected", scanGamepads);
+      window.removeEventListener("gamepaddisconnected", scanGamepads);
+    };
+  }, []);
+  useEffect34(() => {
+    if (isServer || !enabled) return;
+    const tick = () => {
+      scanGamepads();
+      requestRef.current = requestAnimationFrame(tick);
+    };
+    requestRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (requestRef.current) {
+        cancelAnimationFrame(requestRef.current);
+      }
+    };
+  }, [enabled]);
+  return { gamepads };
+}
+
+// src/hooks/useFileSystem/useFileSystem.ts
+import { useCallback as useCallback24, useState as useState29 } from "react";
+function useFileSystem() {
+  const [file, setFile] = useState29(null);
+  const [fileHandle, setFileHandle] = useState29(null);
+  const [error, setError] = useState29(null);
+  const isSupported = !isServer && "showOpenFilePicker" in window;
+  const openFile = useCallback24(async (options) => {
+    if (!isSupported) {
+      setError(new Error("File System Access API not supported"));
+      return;
+    }
+    try {
+      const handles = await window.showOpenFilePicker(options);
+      const handle = handles[0];
+      const file2 = await handle.getFile();
+      setFileHandle(handle);
+      setFile(file2);
+      setError(null);
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }, [isSupported]);
+  const saveFile = useCallback24(async (data, options) => {
+    if (!isSupported) {
+      setError(new Error("File System Access API not supported"));
+      return;
+    }
+    try {
+      const handle = await window.showSaveFilePicker(options);
+      const writable = await handle.createWritable();
+      await writable.write(data);
+      await writable.close();
+      setError(null);
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+  }, [isSupported]);
+  return {
+    isSupported,
+    file,
+    fileHandle,
+    openFile,
+    saveFile,
+    error
+  };
+}
+
+// src/hooks/useStorageEstimate/useStorageEstimate.ts
+import { useEffect as useEffect35, useState as useState30 } from "react";
+function useStorageEstimate() {
+  const [estimate, setEstimate] = useState30({
+    quota: void 0,
+    usage: void 0,
+    supported: false,
+    loading: true
+  });
+  useEffect35(() => {
+    if (isServer || !navigator.storage?.estimate) {
+      setEstimate((s) => ({ ...s, loading: false, supported: false }));
+      return;
+    }
+    navigator.storage.estimate().then(({ quota, usage }) => {
+      setEstimate({
+        quota,
+        usage,
+        supported: true,
+        loading: false
+      });
+    }).catch(() => {
+      setEstimate((s) => ({ ...s, loading: false }));
+    });
+  }, []);
+  return estimate;
+}
+
+// src/hooks/useAsync/useAsync.ts
+import { useCallback as useCallback25, useEffect as useEffect36, useRef as useRef23, useState as useState31 } from "react";
+function useAsync(asyncFunction, options = {}) {
+  const { immediate = false, initialData, onSuccess, onError } = options;
+  const [status, setStatus] = useState31("idle");
+  const [data, setData] = useState31(initialData);
+  const [error, setError] = useState31(null);
+  const isMountedRef = useRef23(true);
+  const asyncFunctionRef = useRef23(asyncFunction);
+  asyncFunctionRef.current = asyncFunction;
+  const execute = useCallback25(
+    async (...args) => {
+      setStatus("pending");
+      setError(null);
+      try {
+        const result = await asyncFunctionRef.current(...args);
+        if (isMountedRef.current) {
+          setData(result);
+          setStatus("success");
+          onSuccess?.(result);
+        }
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        if (isMountedRef.current) {
+          setError(error2);
+          setStatus("error");
+          onError?.(error2);
+        }
+        return void 0;
+      }
+    },
+    [onSuccess, onError]
+  );
+  const reset = useCallback25(() => {
+    setStatus("idle");
+    setData(initialData);
+    setError(null);
+  }, [initialData]);
+  useEffect36(() => {
+    if (immediate) {
+      execute(...[]);
+    }
+  }, []);
+  useEffect36(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return {
+    data,
+    error,
+    status,
+    isLoading: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error",
+    execute,
+    reset
+  };
+}
+
+// src/hooks/useFetch/useFetch.ts
+import { useCallback as useCallback26, useEffect as useEffect37, useRef as useRef24, useState as useState32 } from "react";
+function useFetch(url, options = {}) {
+  const {
+    immediate = true,
+    initialData,
+    transform,
+    retries = 0,
+    retryDelay = 1e3,
+    onSuccess,
+    onError,
+    abortPrevious = true,
+    ...fetchOptions
+  } = options;
+  const [data, setData] = useState32(initialData);
+  const [error, setError] = useState32(null);
+  const [status, setStatus] = useState32("idle");
+  const abortControllerRef = useRef24(null);
+  const isMountedRef = useRef24(true);
+  const retryCountRef = useRef24(0);
+  const abort = useCallback26(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  const optionsRef = useRef24(fetchOptions);
+  optionsRef.current = fetchOptions;
+  const onSuccessRef = useRef24(onSuccess);
+  onSuccessRef.current = onSuccess;
+  const onErrorRef = useRef24(onError);
+  onErrorRef.current = onError;
+  const transformRef = useRef24(transform);
+  transformRef.current = transform;
+  const fetchData = useCallback26(async () => {
+    if (!url) return;
+    if (abortPrevious) {
+      abort();
+    }
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+    setStatus("loading");
+    setError(null);
+    const attemptFetch = async (attempt) => {
+      try {
+        const response = await fetch(url, {
+          ...optionsRef.current,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const result = transformRef.current ? await transformRef.current(response) : await response.json();
+        if (isMountedRef.current && !controller.signal.aborted) {
+          setData(result);
+          setStatus("success");
+          setError(null);
+          retryCountRef.current = 0;
+          onSuccessRef.current?.(result);
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          return;
+        }
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        if (attempt < retries && isMountedRef.current) {
+          retryCountRef.current = attempt + 1;
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+          if (!controller.signal.aborted) {
+            return attemptFetch(attempt + 1);
+          }
+        }
+        if (isMountedRef.current && !controller.signal.aborted) {
+          setError(error2);
+          setStatus("error");
+          retryCountRef.current = 0;
+          onErrorRef.current?.(error2);
+        }
+      }
+    };
+    await attemptFetch(0);
+  }, [url, retries, retryDelay, abort, abortPrevious]);
+  useEffect37(() => {
+    if (immediate && url) {
+      fetchData();
+    }
+    return () => {
+      abort();
+    };
+  }, [url, immediate]);
+  useEffect37(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return {
+    data,
+    error,
+    status,
+    isLoading: status === "loading",
+    isSuccess: status === "success",
+    isError: status === "error",
+    refetch: fetchData,
+    abort
+  };
+}
+
+// src/hooks/useScript/useScript.ts
+import { useEffect as useEffect38, useRef as useRef25, useState as useState33 } from "react";
+var scriptCache = /* @__PURE__ */ new Map();
+function useScript(src, options = {}) {
+  const { immediate = true, removeOnUnmount = false, attributes = {} } = options;
+  const [status, setStatus] = useState33(() => {
+    if (isServer) return "idle";
+    const cached = scriptCache.get(src);
+    if (cached) return cached;
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      return "ready";
+    }
+    return "idle";
+  });
+  const hasLoaded = useRef25(false);
+  const load = () => {
+    if (isServer || hasLoaded.current) return;
+    const cached = scriptCache.get(src);
+    if (cached === "ready") {
+      setStatus("ready");
+      return;
+    }
+    const existingScript = document.querySelector(`script[src="${src}"]`);
+    if (existingScript) {
+      setStatus("ready");
+      scriptCache.set(src, "ready");
+      return;
+    }
+    hasLoaded.current = true;
+    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.remove();
+    };
+    script.addEventListener("load", handleLoad);
+    script.addEventListener("error", handleError);
+    document.body.appendChild(script);
+  };
+  useEffect38(() => {
+    if (immediate && status === "idle") {
+      load();
+    }
+    return () => {
+      if (removeOnUnmount && !isServer) {
+        const script = document.querySelector(`script[src="${src}"]`);
+        if (script) {
+          script.remove();
+          scriptCache.delete(src);
+        }
+      }
+    };
+  }, [src, immediate]);
+  return {
+    status,
+    isLoading: status === "loading",
+    isReady: status === "ready",
+    isError: status === "error",
+    load
+  };
+}
+
+// src/hooks/useWorker/useWorker.ts
+import { useCallback as useCallback27, useEffect as useEffect39, useRef as useRef26, useState as useState34 } from "react";
+function useWorker(workerScript) {
+  const [result, setResult] = useState34();
+  const [error, setError] = useState34(null);
+  const [status, setStatus] = useState34("idle");
+  const workerRef = useRef26(null);
+  const workerUrlRef = useRef26(null);
+  useEffect39(() => {
+    if (isServer) return;
+    const createWorker = () => {
+      try {
+        let worker;
+        if (typeof workerScript === "string") {
+          worker = new Worker(workerScript);
+        } else {
+          const code = `
+                self.onmessage = function(e) {
+                    const result = (${workerScript.toString()})(e.data);
+                    self.postMessage(result);
+                }
+             `;
+          const blob = new Blob([code], { type: "application/javascript" });
+          const url = URL.createObjectURL(blob);
+          workerUrlRef.current = url;
+          worker = new Worker(url);
+        }
+        worker.onmessage = (e) => {
+          setResult(e.data);
+          setStatus("success");
+        };
+        worker.onerror = (e) => {
+          setError(new Error(e.message));
+          setStatus("error");
+        };
+        workerRef.current = worker;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setStatus("error");
+      }
+    };
+    createWorker();
+    return () => {
+      workerRef.current?.terminate();
+      if (workerUrlRef.current) {
+        URL.revokeObjectURL(workerUrlRef.current);
+      }
+    };
+  }, [workerScript]);
+  const run = useCallback27((input) => {
+    if (workerRef.current) {
+      setStatus("running");
+      setError(null);
+      workerRef.current.postMessage(input);
+    }
+  }, []);
+  const terminate = useCallback27(() => {
+    workerRef.current?.terminate();
+    setStatus("idle");
+  }, []);
+  return {
+    result,
+    error,
+    status,
+    run,
+    terminate
+  };
+}
+
+// src/hooks/useIndexedDB/useIndexedDB.ts
+import { useCallback as useCallback28, useEffect as useEffect40, useState as useState35 } from "react";
+function useIndexedDB(dbName, storeName, key) {
+  const [value, setValue] = useState35();
+  const [error, setError] = useState35(null);
+  const [isLoading, setIsLoading] = useState35(true);
+  const openDB = useCallback28(() => {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, 1);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }, [dbName, storeName]);
+  const load = useCallback28(async () => {
+    if (isServer) {
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const db = await openDB();
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const request = store.get(key);
+      request.onsuccess = () => {
+        setValue(request.result);
+        setIsLoading(false);
+      };
+      request.onerror = () => {
+        throw request.error;
+      };
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setIsLoading(false);
+    }
+  }, [key, storeName, openDB]);
+  useEffect40(() => {
+    load();
+  }, [load]);
+  const set = useCallback28(async (newValue) => {
+    try {
+      const db = await openDB();
+      const tx = db.transaction(storeName, "readwrite");
+      const store = tx.objectStore(storeName);
+      return new Promise((resolve, reject) => {
+        const req = store.put(newValue, key);
+        req.onsuccess = () => {
+          setValue(newValue);
+          resolve();
+        };
+        req.onerror = () => reject(req.error);
+      });
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
+  }, [openDB, storeName, key]);
+  const remove = useCallback28(async () => {
+    try {
+      const db = await openDB();
+      const tx = db.transaction(storeName, "readwrite");
+      const store = tx.objectStore(storeName);
+      return new Promise((resolve, reject) => {
+        const req = store.delete(key);
+        req.onsuccess = () => {
+          setValue(void 0);
+          resolve();
+        };
+        req.onerror = () => reject(req.error);
+      });
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
+  }, [openDB, storeName, key]);
+  return {
+    value,
+    set,
+    remove,
+    error,
+    isLoading
+  };
+}
+
+// src/hooks/useHistory/useHistory.ts
+import { useCallback as useCallback29, useState as useState36 } from "react";
+function useHistory(initialValue, options = {}) {
+  const { maxSize = 100 } = options;
+  const [state, setState] = useState36({
+    history: [initialValue],
+    position: 0
+  });
+  const { history, position } = state;
+  const value = history[position];
+  const set = useCallback29(
+    (newValue) => {
+      setState((currentState) => {
+        const { history: currentHistory, position: currentPosition } = currentState;
+        const resolvedValue = typeof newValue === "function" ? newValue(currentHistory[currentPosition]) : newValue;
+        const slicedHistory = currentHistory.slice(0, currentPosition + 1);
+        const newHistory = [...slicedHistory, resolvedValue];
+        if (newHistory.length > maxSize) {
+          const trimmedHistory = newHistory.slice(newHistory.length - maxSize);
+          return {
+            history: trimmedHistory,
+            position: trimmedHistory.length - 1
+          };
+        }
+        return {
+          history: newHistory,
+          position: newHistory.length - 1
+        };
+      });
+    },
+    [maxSize]
+  );
+  const undo = useCallback29(() => {
+    setState((prev) => ({
+      ...prev,
+      position: Math.max(0, prev.position - 1)
+    }));
+  }, []);
+  const redo = useCallback29(() => {
+    setState((prev) => ({
+      ...prev,
+      position: Math.min(prev.history.length - 1, prev.position + 1)
+    }));
+  }, []);
+  const reset = useCallback29((value2) => {
+    setState({
+      history: [value2],
+      position: 0
+    });
+  }, []);
+  const go = useCallback29((newPosition) => {
+    setState((prev) => {
+      const maxPosition = prev.history.length - 1;
+      return {
+        ...prev,
+        position: Math.max(0, Math.min(maxPosition, newPosition))
+      };
+    });
+  }, []);
+  const canUndo = position > 0;
+  const canRedo = position < history.length - 1;
+  return {
+    value,
+    set,
+    undo,
+    redo,
+    reset,
+    canUndo,
+    canRedo,
+    history,
+    position,
+    go
+  };
 }
-var index_default = {
-  version: "0.0.1"
+
+// src/hooks/useStep/useStep.ts
+import { useCallback as useCallback30, useMemo as useMemo2, useState as useState37 } from "react";
+function useStep(options) {
+  const { initialStep = 0, maxStep } = options;
+  const [currentStep, setCurrentStep] = useState37(
+    () => Math.max(0, Math.min(initialStep, maxStep - 1))
+  );
+  const next = useCallback30(() => {
+    setCurrentStep((prev2) => Math.min(prev2 + 1, maxStep - 1));
+  }, [maxStep]);
+  const prev = useCallback30(() => {
+    setCurrentStep((prev2) => Math.max(prev2 - 1, 0));
+  }, []);
+  const goTo = useCallback30(
+    (step) => {
+      setCurrentStep(Math.max(0, Math.min(step, maxStep - 1)));
+    },
+    [maxStep]
+  );
+  const reset = useCallback30(() => {
+    setCurrentStep(Math.max(0, Math.min(initialStep, maxStep - 1)));
+  }, [initialStep, maxStep]);
+  const isStepComplete = useCallback30(
+    (step) => {
+      return step < currentStep;
+    },
+    [currentStep]
+  );
+  const isFirst = currentStep === 0;
+  const isLast = currentStep === maxStep - 1;
+  const progress = useMemo2(
+    () => (currentStep + 1) / maxStep * 100,
+    [currentStep, maxStep]
+  );
+  return {
+    currentStep,
+    step: currentStep + 1,
+    next,
+    prev,
+    goTo,
+    reset,
+    isFirst,
+    isLast,
+    progress,
+    totalSteps: maxStep,
+    isStepComplete
+  };
+}
+
+// src/hooks/usePagination/usePagination.ts
+import { useCallback as useCallback31, useMemo as useMemo3, useState as useState38 } from "react";
+function usePagination(options) {
+  const {
+    totalItems,
+    pageSize: initialPageSize = 10,
+    initialPage = 1,
+    siblings = 1
+  } = options;
+  const [page, setPage] = useState38(() => Math.max(1, initialPage));
+  const [pageSize, setPageSizeState] = useState38(initialPageSize);
+  const totalPages = useMemo3(
+    () => Math.max(1, Math.ceil(totalItems / pageSize)),
+    [totalItems, pageSize]
+  );
+  const boundedPage = useMemo3(
+    () => Math.min(page, totalPages),
+    [page, totalPages]
+  );
+  const next = useCallback31(() => {
+    setPage((prev2) => Math.min(prev2 + 1, totalPages));
+  }, [totalPages]);
+  const prev = useCallback31(() => {
+    setPage((prev2) => Math.max(prev2 - 1, 1));
+  }, []);
+  const goTo = useCallback31(
+    (newPage) => {
+      setPage(Math.max(1, Math.min(newPage, totalPages)));
+    },
+    [totalPages]
+  );
+  const first = useCallback31(() => {
+    setPage(1);
+  }, []);
+  const last = useCallback31(() => {
+    setPage(totalPages);
+  }, [totalPages]);
+  const setPageSize = useCallback31(
+    (size) => {
+      const newTotalPages = Math.max(1, Math.ceil(totalItems / size));
+      setPageSizeState(size);
+      setPage((prev2) => Math.min(prev2, newTotalPages));
+    },
+    [totalItems]
+  );
+  const startIndex = (boundedPage - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, totalItems);
+  const range = useMemo3(() => {
+    const totalPageNumbers = siblings * 2 + 5;
+    if (totalPageNumbers >= totalPages) {
+      return Array.from({ length: totalPages }, (_, i) => i + 1);
+    }
+    const leftSiblingIndex = Math.max(boundedPage - siblings, 1);
+    const rightSiblingIndex = Math.min(boundedPage + siblings, totalPages);
+    const showLeftDots = leftSiblingIndex > 2;
+    const showRightDots = rightSiblingIndex < totalPages - 1;
+    if (!showLeftDots && showRightDots) {
+      const leftItemCount = 3 + 2 * siblings;
+      const leftRange = Array.from({ length: leftItemCount }, (_, i) => i + 1);
+      return [...leftRange, "dots", totalPages];
+    }
+    if (showLeftDots && !showRightDots) {
+      const rightItemCount = 3 + 2 * siblings;
+      const rightRange = Array.from(
+        { length: rightItemCount },
+        (_, i) => totalPages - rightItemCount + i + 1
+      );
+      return [1, "dots", ...rightRange];
+    }
+    const middleRange = Array.from(
+      { length: rightSiblingIndex - leftSiblingIndex + 1 },
+      (_, i) => leftSiblingIndex + i
+    );
+    return [1, "dots", ...middleRange, "dots", totalPages];
+  }, [boundedPage, totalPages, siblings]);
+  return {
+    page: boundedPage,
+    totalPages,
+    pageSize,
+    next,
+    prev,
+    goTo,
+    first,
+    last,
+    isFirst: boundedPage === 1,
+    isLast: boundedPage === totalPages,
+    startIndex,
+    endIndex,
+    range,
+    setPageSize
+  };
+}
+
+// src/hooks/useMachine/useMachine.ts
+import { useReducer } from "react";
+function useMachine(config) {
+  const [state, dispatch] = useReducer(
+    (currentState, event) => {
+      const stateConfig = config.states[currentState];
+      const transition = stateConfig?.on?.[event];
+      if (!transition) {
+        return currentState;
+      }
+      if (typeof transition === "string") {
+        return transition;
+      }
+      if (transition.action) {
+        transition.action();
+      }
+      return transition.target;
+    },
+    config.initial
+  );
+  return [state, dispatch];
+}
+
+// src/hooks/useVirtualList/useVirtualList.ts
+import { useCallback as useCallback32, useMemo as useMemo4, useState as useState39 } from "react";
+function useVirtualList(options) {
+  const { itemHeight, itemCount, containerHeight, overscan = 3 } = options;
+  const [scrollTop, setScrollTop] = useState39(0);
+  const totalHeight = itemCount * itemHeight;
+  const onScroll = useCallback32((event) => {
+    setScrollTop(event.currentTarget.scrollTop);
+  }, []);
+  const items = useMemo4(() => {
+    const startIndex = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
+    const endIndex = Math.min(
+      itemCount - 1,
+      Math.floor((scrollTop + containerHeight) / itemHeight) + overscan
+    );
+    const virtualItems = [];
+    for (let i = startIndex; i <= endIndex; i++) {
+      virtualItems.push({
+        index: i,
+        style: {
+          position: "absolute",
+          top: i * itemHeight,
+          height: itemHeight,
+          width: "100%"
+        }
+      });
+    }
+    return virtualItems;
+  }, [scrollTop, itemHeight, itemCount, containerHeight, overscan]);
+  return {
+    items,
+    totalHeight,
+    onScroll
+  };
+}
+
+// src/hooks/useInfiniteScroll/useInfiniteScroll.ts
+import { useEffect as useEffect41, useRef as useRef27 } from "react";
+function useInfiniteScroll(onLoadMore, options = {}) {
+  const {
+    threshold = 0,
+    rootMargin = "0px",
+    isLoading = false,
+    hasMore = true,
+    disabled = false
+  } = options;
+  const targetRef = useRef27(null);
+  const onLoadMoreStable = useStableCallback_default(onLoadMore);
+  useEffect41(() => {
+    if (disabled || isLoading || !hasMore || !targetRef.current) return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (entry.isIntersecting) {
+          onLoadMoreStable();
+        }
+      },
+      { threshold, rootMargin }
+    );
+    observer.observe(targetRef.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [disabled, isLoading, hasMore, threshold, rootMargin, onLoadMoreStable]);
+  return targetRef;
+}
+
+// src/hooks/useAnthropic/useAnthropic.ts
+import { useCallback as useCallback33, useState as useState40 } from "react";
+function useAnthropic(options = {}) {
+  const {
+    apiKey,
+    model = "claude-3-haiku-20240307",
+    maxTokens = 1024,
+    temperature = 0.7
+  } = options;
+  const [loading, setLoading] = useState40(false);
+  const [response, setResponse] = useState40(null);
+  const [error, setError] = useState40(null);
+  const chat = useCallback33(async (messages) => {
+    setLoading(true);
+    setResponse(null);
+    setError(null);
+    try {
+      const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey || "",
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          max_tokens: maxTokens,
+          temperature
+        })
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error?.message || "Anthropic API Error");
+      }
+      const data = await res.json();
+      const content = data.content?.[0]?.text || "";
+      setResponse(content);
+      return content;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [apiKey, model, maxTokens, temperature]);
+  return { chat, response, loading, error };
+}
+
+// src/hooks/useEmbeddings/useEmbeddings.ts
+import { useCallback as useCallback34, useState as useState41 } from "react";
+function useEmbeddings(fetcher) {
+  const [embeddings, setEmbeddings] = useState41(null);
+  const [loading, setLoading] = useState41(false);
+  const [error, setError] = useState41(null);
+  const generate = useCallback34(async (texts) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await fetcher(texts);
+      setEmbeddings(result);
+      return result;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetcher]);
+  return { embeddings, loading, error, generate };
+}
+
+// src/hooks/useGemini/useGemini.ts
+import { useCallback as useCallback35, useState as useState42 } from "react";
+function useGemini(options = {}) {
+  const {
+    apiKey,
+    model = "gemini-pro"
+  } = options;
+  const [loading, setLoading] = useState42(false);
+  const [response, setResponse] = useState42(null);
+  const [error, setError] = useState42(null);
+  const chat = useCallback35(async (contents) => {
+    setLoading(true);
+    setResponse(null);
+    setError(null);
+    try {
+      const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ contents })
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error?.message || "Gemini API Error");
+      }
+      const data = await res.json();
+      const text = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      setResponse(text);
+      return text;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [apiKey, model]);
+  return { chat, response, loading, error };
+}
+
+// src/hooks/useLLMStream/useLLMStream.ts
+import { useCallback as useCallback36, useRef as useRef28, useState as useState43 } from "react";
+function useLLMStream(options = {}) {
+  const [data, setData] = useState43("");
+  const [loading, setLoading] = useState43(false);
+  const [error, setError] = useState43(null);
+  const abortControllerRef = useRef28(null);
+  const stream = useCallback36(async (url, fetchOptions = {}) => {
+    try {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      setLoading(true);
+      setError(null);
+      setData("");
+      const response = await fetch(url, {
+        ...fetchOptions,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+      }
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      let accumulatedText = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        accumulatedText += chunk;
+        setData((prev) => prev + chunk);
+        options.onToken?.(chunk, accumulatedText);
+      }
+      options.onComplete?.(accumulatedText);
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      setError(err);
+      options.onError?.(err);
+    } finally {
+      setLoading(false);
+      abortControllerRef.current = null;
+    }
+  }, [options]);
+  const cancel = useCallback36(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      setLoading(false);
+    }
+  }, []);
+  return {
+    stream,
+    cancel,
+    data,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useOpenAI/useOpenAI.ts
+import { useCallback as useCallback37, useState as useState44 } from "react";
+function useOpenAI(options = {}) {
+  const {
+    apiKey,
+    apiBase = "https://api.openai.com/v1",
+    model = "gpt-3.5-turbo",
+    temperature = 0.7,
+    stream = false
+  } = options;
+  const [loading, setLoading] = useState44(false);
+  const [response, setResponse] = useState44(null);
+  const [error, setError] = useState44(null);
+  const chat = useCallback37(async (messages) => {
+    setLoading(true);
+    setResponse(null);
+    setError(null);
+    try {
+      const res = await fetch(`${apiBase}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          temperature,
+          stream: false
+          // Streaming strictly not supported in this basic version, useLLMStream for that
+        })
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error?.message || "OpenAI API Error");
+      }
+      const data = await res.json();
+      const content = data.choices?.[0]?.message?.content || "";
+      setResponse(content);
+      return content;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [apiKey, apiBase, model, temperature]);
+  return {
+    chat,
+    response,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useRAG/useRAG.ts
+import { useCallback as useCallback38, useState as useState45 } from "react";
+function useRAG(options) {
+  const [loading, setLoading] = useState45(false);
+  const [answer, setAnswer] = useState45(null);
+  const [retrievedDocs, setRetrievedDocs] = useState45([]);
+  const [error, setError] = useState45(null);
+  const ask = useCallback38(async (query) => {
+    setLoading(true);
+    setError(null);
+    setAnswer(null);
+    setRetrievedDocs([]);
+    try {
+      const docs = await options.retrieve(query);
+      setRetrievedDocs(docs);
+      const contextPrompt = `
+Context documents:
+${docs.map((d) => `- ${d.content}`).join("\n")}
+
+Query: ${query}
+`;
+      const result = await options.generate(contextPrompt, docs);
+      setAnswer(result);
+      return result;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  return { ask, answer, retrievedDocs, loading, error };
+}
+
+// src/hooks/useSearchHighlight/useSearchHighlight.ts
+import { useMemo as useMemo5 } from "react";
+function useSearchHighlight(text, query, options = {}) {
+  const { caseSensitive = false } = options;
+  return useMemo5(() => {
+    if (!query) {
+      return [{ text, isMatch: false }];
+    }
+    const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const flags = caseSensitive ? "g" : "gi";
+    const regex = new RegExp(`(${escapedQuery})`, flags);
+    const parts = text.split(regex);
+    return parts.filter((part) => part).map((part) => {
+      const isMatch = caseSensitive ? part === query : part.toLowerCase() === query.toLowerCase();
+      return {
+        text: part,
+        isMatch
+      };
+    });
+  }, [text, query, caseSensitive]);
+}
+
+// src/hooks/useSemanticSearch/useSemanticSearch.ts
+import { useMemo as useMemo6 } from "react";
+function useSemanticSearch(queryEmbedding, items, getItemEmbedding, topK = 5) {
+  return useMemo6(() => {
+    if (!queryEmbedding || items.length === 0) return [];
+    const results = items.map((item) => {
+      const itemEmbedding = getItemEmbedding(item);
+      const score = cosineSimilarity(queryEmbedding, itemEmbedding);
+      return { item, score };
+    });
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }, [queryEmbedding, items, getItemEmbedding, topK]);
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let magnitudeA = 0;
+  let magnitudeB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    magnitudeA += a[i] * a[i];
+    magnitudeB += b[i] * b[i];
+  }
+  magnitudeA = Math.sqrt(magnitudeA);
+  magnitudeB = Math.sqrt(magnitudeB);
+  if (magnitudeA === 0 || magnitudeB === 0) return 0;
+  return dotProduct / (magnitudeA * magnitudeB);
+}
+
+// src/hooks/useSTT/useSTT.ts
+import { useCallback as useCallback39, useEffect as useEffect42, useRef as useRef29, useState as useState46 } from "react";
+function useSTT(options = {}) {
+  const [listening, setListening] = useState46(false);
+  const [transcript, setTranscript] = useState46("");
+  const [supported, setSupported] = useState46(false);
+  const recognitionRef = useRef29(null);
+  const optionsRef = useRef29(options);
+  optionsRef.current = options;
+  useEffect42(() => {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (SpeechRecognition) {
+      setSupported(true);
+      recognitionRef.current = new SpeechRecognition();
+    }
+  }, []);
+  const listen = useCallback39(() => {
+    if (!recognitionRef.current) return;
+    const recognition = recognitionRef.current;
+    const opts = optionsRef.current;
+    recognition.continuous = opts.continuous ?? false;
+    recognition.interimResults = opts.interimResults ?? false;
+    recognition.lang = opts.lang || "en-US";
+    recognition.onstart = () => setListening(true);
+    recognition.onresult = (event) => {
+      let finalTranscript = "";
+      for (let i = event.resultIndex; i < event.results.length; ++i) {
+        if (event.results[i].isFinal) {
+          finalTranscript += event.results[i][0].transcript;
+        } else if (opts.interimResults) {
+          finalTranscript += event.results[i][0].transcript;
+        }
+      }
+      setTranscript(finalTranscript);
+      opts.onResult?.(finalTranscript);
+    };
+    recognition.onerror = (event) => {
+      setListening(false);
+      opts.onError?.(event.error);
+    };
+    recognition.onend = () => {
+      setListening(false);
+      opts.onEnd?.();
+    };
+    try {
+      recognition.start();
+    } catch (e) {
+    }
+  }, []);
+  const stop = useCallback39(() => {
+    recognitionRef.current?.stop();
+    setListening(false);
+  }, []);
+  const abort = useCallback39(() => {
+    recognitionRef.current?.abort();
+    setListening(false);
+  }, []);
+  return {
+    listen,
+    stop,
+    abort,
+    listening,
+    transcript,
+    supported
+  };
+}
+
+// src/hooks/useTTS/useTTS.ts
+import { useCallback as useCallback40, useEffect as useEffect43, useRef as useRef30, useState as useState47 } from "react";
+function useTTS(options = {}) {
+  const [speaking, setSpeaking] = useState47(false);
+  const [supported, setSupported] = useState47(false);
+  const [voices, setVoices] = useState47([]);
+  const optionsRef = useRef30(options);
+  optionsRef.current = options;
+  useEffect43(() => {
+    if (typeof window !== "undefined" && "speechSynthesis" in window) {
+      setSupported(true);
+      const updateVoices = () => {
+        setVoices(window.speechSynthesis.getVoices());
+      };
+      updateVoices();
+      window.speechSynthesis.onvoiceschanged = updateVoices;
+    }
+  }, []);
+  const cancel = useCallback40(() => {
+    if (!supported) return;
+    window.speechSynthesis.cancel();
+    setSpeaking(false);
+  }, [supported]);
+  const speak = useCallback40((text, overrideOptions = {}) => {
+    if (!supported) return;
+    cancel();
+    const opts = { ...optionsRef.current, ...overrideOptions };
+    const utterance = new SpeechSynthesisUtterance(text);
+    if (opts.volume !== void 0) utterance.volume = opts.volume;
+    if (opts.rate !== void 0) utterance.rate = opts.rate;
+    if (opts.pitch !== void 0) utterance.pitch = opts.pitch;
+    if (opts.voiceURI) {
+      const voice = voices.find((v) => v.voiceURI === opts.voiceURI);
+      if (voice) utterance.voice = voice;
+    }
+    utterance.onstart = () => {
+      setSpeaking(true);
+      opts.onStart?.();
+    };
+    utterance.onend = () => {
+      setSpeaking(false);
+      opts.onEnd?.();
+    };
+    utterance.onerror = (event) => {
+      setSpeaking(false);
+      opts.onError?.(event);
+    };
+    window.speechSynthesis.speak(utterance);
+  }, [supported, voices, cancel]);
+  useEffect43(() => {
+    return () => {
+      if (supported) {
+        window.speechSynthesis.cancel();
+      }
+    };
+  }, [supported]);
+  return {
+    speak,
+    cancel,
+    speaking,
+    supported,
+    voices
+  };
+}
+
+// src/hooks/useAnimate/useAnimate.ts
+import { useCallback as useCallback41, useEffect as useEffect44, useRef as useRef31 } from "react";
+function useAnimate(callback, running = true) {
+  const requestRef = useRef31();
+  const previousTimeRef = useRef31();
+  const savedCallback = useStableCallback(callback);
+  const animate = useCallback41((time) => {
+    if (previousTimeRef.current !== void 0) {
+      const deltaTime = time - previousTimeRef.current;
+      savedCallback(time, deltaTime);
+    }
+    previousTimeRef.current = time;
+    requestRef.current = requestAnimationFrame(animate);
+  }, [savedCallback]);
+  useEffect44(() => {
+    if (running) {
+      requestRef.current = requestAnimationFrame(animate);
+    } else {
+      previousTimeRef.current = void 0;
+      if (requestRef.current) {
+        cancelAnimationFrame(requestRef.current);
+      }
+    }
+    return () => {
+      if (requestRef.current) {
+        cancelAnimationFrame(requestRef.current);
+      }
+    };
+  }, [running, animate]);
+}
+
+// src/hooks/useVideoRef/useVideoRef.ts
+import { useCallback as useCallback42, useEffect as useEffect45, useRef as useRef32, useState as useState48 } from "react";
+function useMediaRef() {
+  const ref = useRef32(null);
+  const [state, setState] = useState48({
+    playing: false,
+    paused: true,
+    muted: false,
+    volume: 1,
+    time: 0,
+    duration: 0,
+    buffered: 0,
+    waiting: false,
+    ended: false
+  });
+  const updateState = useCallback42(() => {
+    const el = ref.current;
+    if (!el) return;
+    setState({
+      playing: !el.paused && !el.ended && el.readyState > 2,
+      paused: el.paused,
+      muted: el.muted,
+      volume: el.volume,
+      time: el.currentTime,
+      duration: el.duration || 0,
+      buffered: el.buffered.length > 0 ? el.buffered.end(el.buffered.length - 1) : 0,
+      waiting: el.readyState < 3,
+      // HAVE_FUTURE_DATA
+      ended: el.ended
+    });
+  }, []);
+  useEffect45(() => {
+    const el = ref.current;
+    if (!el) return;
+    const events = [
+      "loadstart",
+      "loadedmetadata",
+      "canplay",
+      "play",
+      "playing",
+      "pause",
+      "waiting",
+      "seeking",
+      "seeked",
+      "ended",
+      "durationchange",
+      "timeupdate",
+      "progress",
+      "volumechange"
+    ];
+    events.forEach((ev) => el.addEventListener(ev, updateState));
+    updateState();
+    return () => {
+      events.forEach((ev) => el.removeEventListener(ev, updateState));
+    };
+  }, [updateState]);
+  const controls = {
+    play: async () => {
+      await ref.current?.play();
+    },
+    pause: () => {
+      ref.current?.pause();
+    },
+    toggle: () => {
+      const el = ref.current;
+      if (el) el.paused ? el.play() : el.pause();
+    },
+    seek: (time) => {
+      if (ref.current) ref.current.currentTime = time;
+    },
+    mute: () => {
+      if (ref.current) ref.current.muted = true;
+    },
+    unmute: () => {
+      if (ref.current) ref.current.muted = false;
+    },
+    setVolume: (val) => {
+      if (ref.current) ref.current.volume = Math.max(0, Math.min(1, val));
+    }
+  };
+  return { ref, controls, state };
+}
+function useVideoRef() {
+  return useMediaRef();
+}
+
+// src/hooks/useAudioRef/useAudioRef.ts
+function useAudioRef() {
+  return useMediaRef();
+}
+
+// src/hooks/useCanvas/useCanvas.ts
+import { useEffect as useEffect46, useRef as useRef33 } from "react";
+function useCanvas(options = {}) {
+  const canvasRef = useRef33(null);
+  const requestRef = useRef33();
+  const frameCountRef = useRef33(0);
+  useEffect46(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const context = canvas.getContext("2d");
+    if (!context) return;
+    const dpr = window.devicePixelRatio || 1;
+    const rect = canvas.getBoundingClientRect();
+    const width = options.width ?? rect.width;
+    const height = options.height ?? rect.height;
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    context.scale(dpr, dpr);
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+    const render = () => {
+      frameCountRef.current++;
+      if (options.animate) {
+        options.animate(context, frameCountRef.current);
+      }
+      requestRef.current = requestAnimationFrame(render);
+    };
+    if (options.animate) {
+      render();
+    }
+    return () => {
+      if (requestRef.current) cancelAnimationFrame(requestRef.current);
+    };
+  }, [options.width, options.height, options.animate]);
+  return canvasRef;
+}
+
+// src/hooks/useFrameRate/useFrameRate.ts
+import { useEffect as useEffect47, useRef as useRef34, useState as useState49 } from "react";
+function useFrameRate(running = true) {
+  const [fps, setFps] = useState49(0);
+  const frameCountRef = useRef34(0);
+  const lastTimeRef = useRef34(performance.now());
+  const requestRef = useRef34();
+  useEffect47(() => {
+    if (!running) return;
+    const loop = (time) => {
+      frameCountRef.current++;
+      if (time - lastTimeRef.current >= 1e3) {
+        setFps(frameCountRef.current);
+        frameCountRef.current = 0;
+        lastTimeRef.current = time;
+      }
+      requestRef.current = requestAnimationFrame(loop);
+    };
+    requestRef.current = requestAnimationFrame(loop);
+    return () => {
+      if (requestRef.current) cancelAnimationFrame(requestRef.current);
+    };
+  }, [running]);
+  return fps;
+}
+
+// src/hooks/useLottie/useLottie.ts
+import lottie from "lottie-web";
+import { useEffect as useEffect48, useRef as useRef35 } from "react";
+function useLottie(containerRef, options) {
+  const animationRef = useRef35();
+  useEffect48(() => {
+    if (!containerRef.current) return;
+    const anim = lottie.loadAnimation({
+      container: containerRef.current,
+      renderer: "svg",
+      loop: options.loop ?? true,
+      autoplay: options.autoplay ?? true,
+      animationData: options.animationData,
+      path: options.path
+    });
+    animationRef.current = anim;
+    if (options.speed) anim.setSpeed(options.speed);
+    if (options.direction) anim.setDirection(options.direction);
+    return () => {
+      anim.destroy();
+    };
+  }, [options.path, options.animationData]);
+  useEffect48(() => {
+    if (!animationRef.current) return;
+    if (options.speed !== void 0) animationRef.current.setSpeed(options.speed);
+    if (options.direction !== void 0) animationRef.current.setDirection(options.direction);
+    if (options.isPlaying !== void 0) {
+      options.isPlaying ? animationRef.current.play() : animationRef.current.pause();
+    }
+  }, [options.speed, options.direction, options.isPlaying]);
+  return animationRef.current;
+}
+
+// src/hooks/useParallax/useParallax.ts
+import { useEffect as useEffect49, useRef as useRef36, useState as useState50 } from "react";
+function useParallax(options = {}) {
+  const { speed = 0.5, axis = "y" } = options;
+  const [offset, setOffset] = useState50(0);
+  const ref = useRef36(null);
+  useEffect49(() => {
+    const handleScroll = () => {
+      if (!ref.current) return;
+      const rect = ref.current.getBoundingClientRect();
+      const scrollY = window.scrollY || window.pageYOffset;
+      const scrollX = window.scrollX || window.pageXOffset;
+      const val = axis === "y" ? scrollY : scrollX;
+      setOffset(val * speed);
+    };
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    handleScroll();
+    return () => window.removeEventListener("scroll", handleScroll);
+  }, [speed, axis]);
+  return {
+    ref,
+    style: {
+      transform: axis === "y" ? `translateY(${offset}px)` : `translateX(${offset}px)`,
+      willChange: "transform"
+    }
+  };
+}
+
+// src/hooks/useSpringCore/useSpringCore.ts
+import { useEffect as useEffect50, useRef as useRef37, useState as useState51 } from "react";
+var DEFAULT_CONFIG = {
+  stiffness: 170,
+  damping: 26,
+  mass: 1
 };
+function useSpringCore(targetValue, options = {}) {
+  const [value, setValue] = useState51(options.initialValue ?? targetValue);
+  const velocityRef = useRef37(0);
+  const valueRef = useRef37(options.initialValue ?? targetValue);
+  const lastTimeRef = useRef37();
+  const rafRef = useRef37();
+  const config = { ...DEFAULT_CONFIG, ...options };
+  useEffect50(() => {
+    const animate = (time) => {
+      if (lastTimeRef.current === void 0) {
+        lastTimeRef.current = time;
+        rafRef.current = requestAnimationFrame(animate);
+        return;
+      }
+      const deltaTime = (time - lastTimeRef.current) / 1e3;
+      lastTimeRef.current = time;
+      const dt = Math.min(deltaTime, 0.1);
+      const force = -config.stiffness * (valueRef.current - targetValue);
+      const dampingForce = -config.damping * velocityRef.current;
+      const acceleration = (force + dampingForce) / config.mass;
+      velocityRef.current += acceleration * dt;
+      valueRef.current += velocityRef.current * dt;
+      setValue(valueRef.current);
+      if (Math.abs(velocityRef.current) < 0.01 && Math.abs(valueRef.current - targetValue) < 0.01) {
+        setValue(targetValue);
+        valueRef.current = targetValue;
+        velocityRef.current = 0;
+        return;
+      }
+      rafRef.current = requestAnimationFrame(animate);
+    };
+    if (valueRef.current !== targetValue) {
+      lastTimeRef.current = void 0;
+      rafRef.current = requestAnimationFrame(animate);
+    }
+    return () => {
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
+    };
+  }, [targetValue, config.stiffness, config.damping, config.mass]);
+  return value;
+}
+
+// src/hooks/useSVGAnimation/useSVGAnimation.ts
+import { useEffect as useEffect51, useState as useState52 } from "react";
+function useSVGAnimation(length, options = {}) {
+  const [offset, setOffset] = useState52(length);
+  const { duration = 1e3, delay = 0, easing = (t) => t } = options;
+  useEffect51(() => {
+    let start = null;
+    let rafId;
+    const animate = (time) => {
+      if (!start) start = time;
+      const elapsed = time - start;
+      const progress = Math.min(Math.max((elapsed - delay) / duration, 0), 1);
+      const easedProgress = easing(progress);
+      setOffset(length * (1 - easedProgress));
+      if (progress < 1) {
+        rafId = requestAnimationFrame(animate);
+      }
+    };
+    rafId = requestAnimationFrame(animate);
+    return () => {
+      cancelAnimationFrame(rafId);
+    };
+  }, [length, duration, delay]);
+  return {
+    strokeDasharray: length,
+    strokeDashoffset: offset
+  };
+}
+
+// src/hooks/useThreeJS/useThreeJS.ts
+import { useEffect as useEffect52, useRef as useRef38 } from "react";
+import * as THREE from "three";
+function useThreeJS(containerRef, options = {}) {
+  const { init, animate, resize = true } = options;
+  const rendererRef = useRef38();
+  const sceneRef = useRef38();
+  const cameraRef = useRef38();
+  const requestRef = useRef38();
+  useEffect52(() => {
+    if (!containerRef.current) return;
+    const width = containerRef.current.clientWidth;
+    const height = containerRef.current.clientHeight;
+    const scene = new THREE.Scene();
+    const camera = new THREE.PerspectiveCamera(75, width / height, 0.1, 1e3);
+    const renderer = new THREE.WebGLRenderer({ alpha: true, antialias: true });
+    renderer.setSize(width, height);
+    containerRef.current.appendChild(renderer.domElement);
+    sceneRef.current = scene;
+    cameraRef.current = camera;
+    rendererRef.current = renderer;
+    if (init) {
+      init(scene, camera, renderer);
+    }
+    const loop = (time) => {
+      if (animate) {
+        animate(time, scene, camera);
+      }
+      renderer.render(scene, camera);
+      requestRef.current = requestAnimationFrame(loop);
+    };
+    loop(0);
+    const handleResize = () => {
+      if (!containerRef.current) return;
+      const w = containerRef.current.clientWidth;
+      const h = containerRef.current.clientHeight;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h);
+    };
+    if (resize) {
+      window.addEventListener("resize", handleResize);
+    }
+    return () => {
+      if (requestRef.current) cancelAnimationFrame(requestRef.current);
+      if (resize) window.removeEventListener("resize", handleResize);
+      renderer.dispose();
+      if (containerRef.current) {
+        containerRef.current.removeChild(renderer.domElement);
+      }
+    };
+  }, [init, animate, resize]);
+  return { scene: sceneRef.current, camera: cameraRef.current, renderer: rendererRef.current };
+}
+
+// src/hooks/useBroadcastChannel/useBroadcastChannel.ts
+import { useCallback as useCallback43, useEffect as useEffect53, useRef as useRef39, useState as useState53 } from "react";
+function useBroadcastChannel(channelName) {
+  const [lastMessage, setLastMessage] = useState53(null);
+  const channelRef = useRef39(null);
+  useEffect53(() => {
+    const channel = new BroadcastChannel(channelName);
+    channelRef.current = channel;
+    channel.onmessage = (event) => {
+      setLastMessage(event.data);
+    };
+    return () => {
+      channel.close();
+    };
+  }, [channelName]);
+  const postMessage = useCallback43((message) => {
+    channelRef.current?.postMessage(message);
+  }, []);
+  return { postMessage, lastMessage };
+}
+
+// src/hooks/useCalendar/useCalendar.ts
+import { useMemo as useMemo7, useState as useState54 } from "react";
+function useCalendar(options = {}) {
+  const [date, setDate] = useState54(options.initialDate || /* @__PURE__ */ new Date());
+  const daysInMonth = useMemo7(() => {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    return new Date(year, month + 1, 0).getDate();
+  }, [date]);
+  const firstDayOfMonth = useMemo7(() => {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    return new Date(year, month, 1).getDay();
+  }, [date]);
+  const nextMonth = () => {
+    setDate((prev) => new Date(prev.getFullYear(), prev.getMonth() + 1, 1));
+  };
+  const prevMonth = () => {
+    setDate((prev) => new Date(prev.getFullYear(), prev.getMonth() - 1, 1));
+  };
+  return {
+    date,
+    daysInMonth,
+    firstDayOfMonth,
+    nextMonth,
+    prevMonth,
+    setHeader: setDate
+  };
+}
+
+// src/hooks/useDragAndDrop/useDragAndDrop.ts
+import { useCallback as useCallback44, useEffect as useEffect54, useRef as useRef40, useState as useState55 } from "react";
+function useDragAndDrop(options = {}) {
+  const [isDragging, setIsDragging] = useState55(false);
+  const ref = useRef40(null);
+  const handleDragEnter = useCallback44((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(true);
+  }, []);
+  const handleDragLeave = useCallback44((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+  }, []);
+  const handleDragOver = useCallback44((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = useCallback44((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+    if (e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+      const files = Array.from(e.dataTransfer.files);
+      options.onDrop?.(files);
+      e.dataTransfer.clearData();
+    }
+  }, [options]);
+  useEffect54(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.addEventListener("dragenter", handleDragEnter);
+    el.addEventListener("dragleave", handleDragLeave);
+    el.addEventListener("dragover", handleDragOver);
+    el.addEventListener("drop", handleDrop);
+    return () => {
+      el.removeEventListener("dragenter", handleDragEnter);
+      el.removeEventListener("dragleave", handleDragLeave);
+      el.removeEventListener("dragover", handleDragOver);
+      el.removeEventListener("drop", handleDrop);
+    };
+  }, [handleDragEnter, handleDragLeave, handleDragOver, handleDrop]);
+  return { ref, isDragging };
+}
+
+// src/hooks/useFileProcessing/useFileProcessing.ts
+import { useCallback as useCallback45, useState as useState56 } from "react";
+function useFileProcessing(options = {}) {
+  const [processing, setProcessing] = useState56(false);
+  const [error, setError] = useState56(null);
+  const process = useCallback45(async (file) => {
+    setProcessing(true);
+    setError(null);
+    try {
+      if (options.limit && file.size > options.limit) {
+        throw new Error("File too large");
+      }
+      const text = await file.text();
+      return text;
+    } catch (err) {
+      setError(err.message);
+      throw err;
+    } finally {
+      setProcessing(false);
+    }
+  }, [options.limit]);
+  return { process, processing, error };
+}
+
+// src/hooks/useForm/useForm.ts
+import { useCallback as useCallback46, useState as useState57 } from "react";
+function useForm(options) {
+  const [values, setValues] = useState57(options.initialValues);
+  const [errors, setErrors] = useState57({});
+  const [isSubmitting, setIsSubmitting] = useState57(false);
+  const [touched, setTouched] = useState57({});
+  const handleChange = useCallback46((e) => {
+    const { name, value, type } = e.target;
+    const val = type === "checkbox" ? e.target.checked : value;
+    setValues((prev) => ({ ...prev, [name]: val }));
+  }, []);
+  const setFieldValue = useCallback46((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+  }, []);
+  const handleBlur = useCallback46((e) => {
+    const { name } = e.target;
+    setTouched((prev) => ({ ...prev, [name]: true }));
+  }, []);
+  const handleSubmit = useCallback46(async (e) => {
+    e?.preventDefault();
+    setIsSubmitting(true);
+    setErrors({});
+    if (options.validate) {
+      const validationErrors = await options.validate(values);
+      if (Object.keys(validationErrors).length > 0) {
+        setErrors(validationErrors);
+        setIsSubmitting(false);
+        return;
+      }
+    }
+    try {
+      await options.onSubmit(values);
+    } catch (err) {
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [values, options]);
+  return {
+    values,
+    errors,
+    touched,
+    isSubmitting,
+    handleChange,
+    handleBlur,
+    handleSubmit,
+    setFieldValue,
+    setValues
+    // expose for resets
+  };
+}
+
+// src/hooks/useMarkdown/useMarkdown.ts
+function useMarkdown() {
+  const compile = (markdown) => {
+    let html = markdown.replace(/^# (.*)/gm, "<h1>$1</h1>").replace(/^## (.*)/gm, "<h2>$1</h2>").replace(/\*\*(.*)\*\*/g, "<b>$1</b>");
+    return html;
+  };
+  return { compile };
+}
+
+// src/hooks/usePDF/usePDF.ts
+import { useCallback as useCallback47, useState as useState58 } from "react";
+function usePDF() {
+  const [generating, setGenerating] = useState58(false);
+  const generate = useCallback47(async (content, filename = "document.pdf") => {
+    setGenerating(true);
+    await new Promise((r) => setTimeout(r, 100));
+    console.log("Generating PDF for:", filename);
+    setGenerating(false);
+    return true;
+  }, []);
+  return { generate, generating };
+}
+
+// src/hooks/usePresence/usePresence.ts
+import { useEffect as useEffect55, useState as useState59 } from "react";
+function usePresence(heartbeatInterval = 5e3) {
+  const [lastActive, setLastActive] = useState59(Date.now());
+  const [isIdle, setIsIdle] = useState59(false);
+  useEffect55(() => {
+    const handleActivity = () => {
+      setLastActive(Date.now());
+      if (isIdle) setIsIdle(false);
+    };
+    window.addEventListener("mousemove", handleActivity);
+    window.addEventListener("keydown", handleActivity);
+    const interval = setInterval(() => {
+      if (Date.now() - lastActive > heartbeatInterval * 2) {
+        setIsIdle(true);
+      }
+    }, heartbeatInterval);
+    return () => {
+      window.removeEventListener("mousemove", handleActivity);
+      window.removeEventListener("keydown", handleActivity);
+      clearInterval(interval);
+    };
+  }, [heartbeatInterval, lastActive, isIdle]);
+  return { isIdle, lastActive };
+}
+
+// src/hooks/useRealtimeCollab/useRealtimeCollab.ts
+import { useCallback as useCallback48, useState as useState60 } from "react";
+function useRealtimeCollab(userId) {
+  const [events, setEvents] = useState60([]);
+  const emit = useCallback48((type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+      userId
+    };
+    setEvents((prev) => [...prev, event]);
+  }, [userId]);
+  const applyRemote = useCallback48((event) => {
+    setEvents((prev) => [...prev, event]);
+  }, []);
+  return { events, emit, applyRemote };
+}
+
+// src/hooks/useShortcuts/useShortcuts.ts
+import { useEffect as useEffect56 } from "react";
+function useShortcuts(shortcuts) {
+  useEffect56(() => {
+    const handleKeyDown = (event) => {
+      const parts = [];
+      if (event.ctrlKey) parts.push("Control");
+      if (event.metaKey) parts.push("Meta");
+      if (event.altKey) parts.push("Alt");
+      if (event.shiftKey) parts.push("Shift");
+      if (["Control", "Meta", "Alt", "Shift"].includes(event.key)) {
+      } else {
+        parts.push(event.key);
+      }
+      const combo = parts.join("+");
+      if (shortcuts[combo]) {
+        shortcuts[combo](event);
+      } else if (shortcuts[event.key]) {
+        shortcuts[event.key](event);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [shortcuts]);
+}
+
+// src/hooks/useSortable/useSortable.ts
+import { useCallback as useCallback49, useState as useState61 } from "react";
+function useSortable(options) {
+  const [draggedIndex, setDraggedIndex] = useState61(null);
+  const move = useCallback49((fromIndex, toIndex) => {
+    if (fromIndex === toIndex) return;
+    const newItems = [...options.items];
+    const [removed] = newItems.splice(fromIndex, 1);
+    newItems.splice(toIndex, 0, removed);
+    options.onReorder(newItems);
+  }, [options]);
+  return {
+    draggedIndex,
+    setDraggedIndex,
+    move
+  };
+}
+
+// src/hooks/useSpreadsheet/useSpreadsheet.ts
+import { useState as useState62 } from "react";
+function useSpreadsheet(options) {
+  const { rows, cols, initialData } = options;
+  const createGrid = () => {
+    if (initialData) return initialData;
+    return Array.from({ length: rows }, () => Array(cols).fill(null));
+  };
+  const [data, setData] = useState62(createGrid);
+  const [selectedCell, setSelectedCell] = useState62(null);
+  const setCell = (r, c, value) => {
+    setData((prev) => {
+      const next = [...prev];
+      next[r] = [...next[r]];
+      next[r][c] = value;
+      return next;
+    });
+  };
+  return {
+    data,
+    setCell,
+    selectedCell,
+    setSelectedCell
+  };
+}
+
+// src/hooks/useTable/useTable.ts
+import { useMemo as useMemo8, useState as useState63 } from "react";
+function useTable(options) {
+  const [sortConfig, setSortConfig] = useState63(
+    options.initialSort || null
+  );
+  const requestSort = (key) => {
+    let direction = "asc";
+    if (sortConfig && sortConfig.key === key && sortConfig.direction === "asc") {
+      direction = "desc";
+    }
+    setSortConfig({ key, direction });
+  };
+  const sortedData = useMemo8(() => {
+    const sortableItems = [...options.data];
+    if (sortConfig !== null) {
+      sortableItems.sort((a, b) => {
+        const valA = a[sortConfig.key];
+        const valB = b[sortConfig.key];
+        if (valA < valB) return sortConfig.direction === "asc" ? -1 : 1;
+        if (valA > valB) return sortConfig.direction === "asc" ? 1 : -1;
+        return 0;
+      });
+    }
+    return sortableItems;
+  }, [options.data, sortConfig]);
+  return {
+    items: sortedData,
+    requestSort,
+    sortConfig,
+    columns: options.columns
+  };
+}
+
+// src/hooks/useWebRTC/useWebRTC.ts
+import { useEffect as useEffect57, useRef as useRef41, useState as useState64 } from "react";
+function useWebRTC(options = {}) {
+  const [connectionState, setConnectionState] = useState64("new");
+  const [signalingState, setSignalingState] = useState64("stable");
+  const pcRef = useRef41(null);
+  useEffect57(() => {
+    const pc = new RTCPeerConnection({
+      iceServers: options.iceServers || [{ urls: "stun:stun.l.google.com:19302" }]
+    });
+    pcRef.current = pc;
+    pc.onconnectionstatechange = () => setConnectionState(pc.connectionState);
+    pc.onsignalingstatechange = () => setSignalingState(pc.signalingState);
+    return () => {
+      pc.close();
+    };
+  }, [options.iceServers]);
+  return {
+    pc: pcRef.current,
+    connectionState,
+    signalingState
+  };
+}
+
+// src/hooks/useWebSocket/useWebSocket.ts
+import { useCallback as useCallback50, useEffect as useEffect58, useRef as useRef42, useState as useState65 } from "react";
+function useWebSocket(url, options = {}) {
+  const {
+    reconnect = true,
+    reconnectAttempts = 5,
+    reconnectInterval = 3e3
+  } = options;
+  const [isConnected, setIsConnected] = useState65(false);
+  const [lastMessage, setLastMessage] = useState65(null);
+  const wsRef = useRef42(null);
+  const reconnectCountRef = useRef42(0);
+  const reconnectTimerRef = useRef42();
+  const connect = useCallback50(() => {
+    if (reconnectTimerRef.current) clearTimeout(reconnectTimerRef.current);
+    const ws = new WebSocket(url);
+    wsRef.current = ws;
+    ws.onopen = (e) => {
+      setIsConnected(true);
+      reconnectCountRef.current = 0;
+      options.onOpen?.(e);
+    };
+    ws.onclose = (e) => {
+      setIsConnected(false);
+      options.onClose?.(e);
+      if (reconnect && reconnectCountRef.current < reconnectAttempts) {
+        reconnectTimerRef.current = setTimeout(() => {
+          reconnectCountRef.current++;
+          connect();
+        }, reconnectInterval);
+      }
+    };
+    ws.onmessage = (e) => {
+      setLastMessage(e);
+      options.onMessage?.(e);
+    };
+    ws.onerror = (e) => {
+      options.onError?.(e);
+    };
+  }, [url, reconnect, reconnectAttempts, reconnectInterval, options]);
+  useEffect58(() => {
+    connect();
+    return () => {
+      if (reconnectTimerRef.current) clearTimeout(reconnectTimerRef.current);
+      wsRef.current?.close();
+    };
+  }, [connect]);
+  const send = useCallback50((data) => {
+    if (wsRef.current?.readyState === WebSocket.OPEN) {
+      wsRef.current.send(data);
+    }
+  }, []);
+  return {
+    send,
+    lastMessage,
+    isConnected,
+    ws: wsRef.current
+  };
+}
+
+// src/hooks/useClickAnywhere/useClickAnywhere.ts
+function useClickAnywhere(handler) {
+  useEvent("click", (event) => {
+    handler(event);
+  });
+}
+
+// src/hooks/useCountdown/useCountdown.ts
+import { useCallback as useCallback51, useEffect as useEffect59, useRef as useRef43, useState as useState66 } from "react";
+function useCountdown({
+  countStart,
+  intervalMs = 1e3,
+  isIncrement = false,
+  countStop = 0
+}) {
+  const [count, setCount] = useState66(countStart);
+  const [isRunning, setIsRunning] = useState66(false);
+  const intervalRef = useRef43(null);
+  const startCountdown = useCallback51(() => setIsRunning(true), []);
+  const stopCountdown = useCallback51(() => setIsRunning(false), []);
+  const resetCountdown = useCallback51(() => {
+    setIsRunning(false);
+    setCount(countStart);
+  }, [countStart]);
+  useEffect59(() => {
+    if (!isRunning) {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+      return;
+    }
+    intervalRef.current = setInterval(() => {
+      setCount((prev) => {
+        if (isIncrement) {
+          if (prev < countStop) {
+            return prev + 1;
+          } else {
+            setIsRunning(false);
+            return prev;
+          }
+        } else {
+          if (prev > countStop) {
+            return prev - 1;
+          } else {
+            setIsRunning(false);
+            return prev;
+          }
+        }
+      });
+    }, intervalMs);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [isRunning, intervalMs, isIncrement, countStop]);
+  return { count, startCountdown, stopCountdown, resetCountdown };
+}
+
+// src/hooks/useDebounceCallback/useDebounceCallback.ts
+import { useEffect as useEffect60, useMemo as useMemo9, useRef as useRef44 } from "react";
+function useDebounceCallback(func, wait = 0, options = {}) {
+  const funcRef = useRef44(func);
+  const timeoutRef = useRef44();
+  useEffect60(() => {
+    funcRef.current = func;
+  }, [func]);
+  const debounced = useMemo9(() => {
+    const debouncedFunc = (...args) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        funcRef.current(...args);
+      }, wait);
+    };
+    const cancel = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+    const flush = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+    debouncedFunc.cancel = cancel;
+    debouncedFunc.flush = flush;
+    return debouncedFunc;
+  }, [wait]);
+  return debounced;
+}
+
+// src/hooks/useIsClient/useIsClient.ts
+import { useEffect as useEffect61, useState as useState67 } from "react";
+function useIsClient() {
+  const [isClient, setIsClient] = useState67(false);
+  useEffect61(() => {
+    setIsClient(true);
+  }, []);
+  return isClient;
+}
+
+// src/hooks/useList/useList.ts
+import { useCallback as useCallback52, useState as useState68 } from "react";
+function useList(initialList = []) {
+  const [list, setList] = useState68(initialList);
+  const actions = {
+    set: useCallback52((l) => setList(l), []),
+    push: useCallback52((element) => setList((l) => [...l, element]), []),
+    updateAt: useCallback52(
+      (index, element) => setList((l) => {
+        const m = [...l];
+        m[index] = element;
+        return m;
+      }),
+      []
+    ),
+    insertAt: useCallback52(
+      (index, element) => setList((l) => {
+        const m = [...l];
+        m.splice(index, 0, element);
+        return m;
+      }),
+      []
+    ),
+    update: useCallback52(
+      (predicate, newElement) => setList((l) => l.map((item) => predicate(item, newElement) ? newElement : item)),
+      []
+    ),
+    removeAt: useCallback52(
+      (index) => setList((l) => {
+        const m = [...l];
+        m.splice(index, 1);
+        return m;
+      }),
+      []
+    ),
+    clear: useCallback52(() => setList([]), []),
+    reset: useCallback52(() => setList(initialList), [initialList])
+  };
+  return [list, actions];
+}
+
+// src/hooks/useMap/useMap.ts
+import { useCallback as useCallback53, useState as useState69 } from "react";
+function useMap(initialState = /* @__PURE__ */ new Map()) {
+  const [map, setMap] = useState69(new Map(initialState));
+  const actions = {
+    set: useCallback53((key, value) => {
+      setMap((prev) => {
+        const copy = new Map(prev);
+        copy.set(key, value);
+        return copy;
+      });
+    }, []),
+    setAll: useCallback53((entries) => {
+      setMap(new Map(entries));
+    }, []),
+    remove: useCallback53((key) => {
+      setMap((prev) => {
+        const copy = new Map(prev);
+        copy.delete(key);
+        return copy;
+      });
+    }, []),
+    reset: useCallback53(() => {
+      setMap(new Map(initialState));
+    }, [initialState])
+  };
+  return [map, actions];
+}
+
+// src/hooks/useQueue/useQueue.ts
+import { useCallback as useCallback54, useState as useState70 } from "react";
+function useQueue(initialValue = []) {
+  const [queue, setQueue] = useState70(initialValue);
+  const add = useCallback54((element) => {
+    setQueue((q) => [...q, element]);
+  }, []);
+  const remove = useCallback54(() => {
+    let removedElement;
+    setQueue((q) => {
+      const [first, ...rest] = q;
+      removedElement = first;
+      return rest;
+    });
+    return removedElement;
+  }, []);
+  const clear = useCallback54(() => {
+    setQueue([]);
+  }, []);
+  return {
+    queue,
+    add,
+    remove,
+    clear,
+    first: queue[0],
+    last: queue[queue.length - 1],
+    size: queue.length
+  };
+}
+
+// src/hooks/useScreen/useScreen.ts
+import { useEffect as useEffect62, useState as useState71 } from "react";
+function useScreen() {
+  const getScreen = () => {
+    if (typeof window !== "undefined" && window.screen) {
+      return window.screen;
+    }
+    return void 0;
+  };
+  const [screen, setScreen] = useState71(getScreen());
+  const handleResize = () => {
+    setScreen(getScreen());
+  };
+  useEvent("resize", handleResize);
+  useEffect62(() => {
+    setScreen(getScreen());
+  }, []);
+  return screen;
+}
+
+// src/hooks/useSet/useSet.ts
+import { useCallback as useCallback55, useState as useState72 } from "react";
+function useSet(initialSet = /* @__PURE__ */ new Set()) {
+  const [set, setSet] = useState72(initialSet);
+  const actions = {
+    add: useCallback55((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        copy.add(key);
+        return copy;
+      });
+    }, []),
+    remove: useCallback55((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        copy.delete(key);
+        return copy;
+      });
+    }, []),
+    toggle: useCallback55((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        if (copy.has(key)) {
+          copy.delete(key);
+        } else {
+          copy.add(key);
+        }
+        return copy;
+      });
+    }, []),
+    reset: useCallback55(() => {
+      setSet(initialSet);
+    }, [initialSet]),
+    clear: useCallback55(() => {
+      setSet(/* @__PURE__ */ new Set());
+    }, [])
+  };
+  return [set, actions];
+}
 export {
-  index_default as default,
-  useVersion
+  isBrowser,
+  isServer,
+  noop,
+  useAnimate,
+  useAnthropic,
+  useAsync,
+  useAudioRef,
+  useBattery,
+  useBluetooth,
+  useBroadcastChannel,
+  useCalendar,
+  useCanvas,
+  useClickAnywhere,
+  useClickOutside,
+  useCopyToClipboard,
+  useCountdown,
+  useCounter,
+  useDebounce,
+  useDebounceCallback,
+  useDocumentTitle,
+  useDragAndDrop,
+  useEmbeddings,
+  useEvent,
+  useEyeDropper,
+  useFetch,
+  useFileProcessing,
+  useFileSystem,
+  useForm,
+  useFrameRate,
+  useFullscreen,
+  useGamepad,
+  useGemini,
+  useHistory,
+  useHover,
+  useIndexedDB,
+  useInfiniteScroll,
+  useIntersection,
+  useInterval,
+  useIsClient,
+  useIsMounted,
+  useIsomorphicLayoutEffect,
+  useKeyPress,
+  useLLMStream,
+  useList,
+  useLocalStorage,
+  useLockBodyScroll,
+  useLongPress,
+  useLottie,
+  useMachine,
+  useMap,
+  useMarkdown,
+  useMediaDevices,
+  useMediaQuery,
+  useMediaRecorder,
+  useMount,
+  useMutationObserver,
+  useNetworkState,
+  useOnline,
+  useOpenAI,
+  usePDF,
+  usePageLeave,
+  usePagination,
+  useParallax,
+  usePermissions,
+  usePresence,
+  usePrevious,
+  useQueue,
+  useRAG,
+  useRealtimeCollab,
+  useResizeObserver,
+  useSTT,
+  useSVGAnimation,
+  useScreen,
+  useScript,
+  useScroll,
+  useSearchHighlight,
+  useSemanticSearch,
+  useSessionStorage,
+  useSet,
+  useShare,
+  useShortcuts,
+  useSortable,
+  useSpreadsheet,
+  useSpringCore,
+  useStableCallback,
+  useStep,
+  useStorageEstimate,
+  useTTS,
+  useTable,
+  useTheme,
+  useThreeJS,
+  useThrottle,
+  useTimeout,
+  useToggle,
+  useUnmount,
+  useUpdateEffect,
+  useVideoRef,
+  useVirtualList,
+  useWakeLock,
+  useWebRTC,
+  useWebSocket,
+  useWindowFocus,
+  useWindowSize,
+  useWorker
 };
+/**
+ * Hookery - A collection of high-quality React hooks
+ * @version 0.0.1
+ * @license MIT
+ */
+//# sourceMappingURL=index.mjs.map