hookery 0.0.1 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,22 +17,4300 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  default: () => index_default,
-  useVersion: () => useVersion
+var src_exports = {};
+__export(src_exports, {
+  isBrowser: () => isBrowser,
+  isServer: () => isServer,
+  noop: () => noop,
+  useAnimate: () => useAnimate,
+  useAnthropic: () => useAnthropic,
+  useAsync: () => useAsync,
+  useAudioRef: () => useAudioRef,
+  useBattery: () => useBattery,
+  useBluetooth: () => useBluetooth,
+  useBroadcastChannel: () => useBroadcastChannel,
+  useCalendar: () => useCalendar,
+  useCanvas: () => useCanvas,
+  useClickAnywhere: () => useClickAnywhere,
+  useClickOutside: () => useClickOutside,
+  useCopyToClipboard: () => useCopyToClipboard,
+  useCountdown: () => useCountdown,
+  useCounter: () => useCounter,
+  useDebounce: () => useDebounce,
+  useDebounceCallback: () => useDebounceCallback,
+  useDocumentTitle: () => useDocumentTitle,
+  useDragAndDrop: () => useDragAndDrop,
+  useEmbeddings: () => useEmbeddings,
+  useEvent: () => useEvent,
+  useEyeDropper: () => useEyeDropper,
+  useFetch: () => useFetch,
+  useFileProcessing: () => useFileProcessing,
+  useFileSystem: () => useFileSystem,
+  useForm: () => useForm,
+  useFrameRate: () => useFrameRate,
+  useFullscreen: () => useFullscreen,
+  useGamepad: () => useGamepad,
+  useGemini: () => useGemini,
+  useHistory: () => useHistory,
+  useHover: () => useHover,
+  useIndexedDB: () => useIndexedDB,
+  useInfiniteScroll: () => useInfiniteScroll,
+  useIntersection: () => useIntersection,
+  useInterval: () => useInterval,
+  useIsClient: () => useIsClient,
+  useIsMounted: () => useIsMounted,
+  useIsomorphicLayoutEffect: () => useIsomorphicLayoutEffect,
+  useKeyPress: () => useKeyPress,
+  useLLMStream: () => useLLMStream,
+  useList: () => useList,
+  useLocalStorage: () => useLocalStorage,
+  useLockBodyScroll: () => useLockBodyScroll,
+  useLongPress: () => useLongPress,
+  useLottie: () => useLottie,
+  useMachine: () => useMachine,
+  useMap: () => useMap,
+  useMarkdown: () => useMarkdown,
+  useMediaDevices: () => useMediaDevices,
+  useMediaQuery: () => useMediaQuery,
+  useMediaRecorder: () => useMediaRecorder,
+  useMount: () => useMount,
+  useMutationObserver: () => useMutationObserver,
+  useNetworkState: () => useNetworkState,
+  useOnline: () => useOnline,
+  useOpenAI: () => useOpenAI,
+  usePDF: () => usePDF,
+  usePageLeave: () => usePageLeave,
+  usePagination: () => usePagination,
+  useParallax: () => useParallax,
+  usePermissions: () => usePermissions,
+  usePresence: () => usePresence,
+  usePrevious: () => usePrevious,
+  useQueue: () => useQueue,
+  useRAG: () => useRAG,
+  useRealtimeCollab: () => useRealtimeCollab,
+  useResizeObserver: () => useResizeObserver,
+  useSTT: () => useSTT,
+  useSVGAnimation: () => useSVGAnimation,
+  useScreen: () => useScreen,
+  useScript: () => useScript,
+  useScroll: () => useScroll,
+  useSearchHighlight: () => useSearchHighlight,
+  useSemanticSearch: () => useSemanticSearch,
+  useSessionStorage: () => useSessionStorage,
+  useSet: () => useSet,
+  useShare: () => useShare,
+  useShortcuts: () => useShortcuts,
+  useSortable: () => useSortable,
+  useSpreadsheet: () => useSpreadsheet,
+  useSpringCore: () => useSpringCore,
+  useStableCallback: () => useStableCallback,
+  useStep: () => useStep,
+  useStorageEstimate: () => useStorageEstimate,
+  useTTS: () => useTTS,
+  useTable: () => useTable,
+  useTheme: () => useTheme,
+  useThreeJS: () => useThreeJS,
+  useThrottle: () => useThrottle,
+  useTimeout: () => useTimeout,
+  useToggle: () => useToggle,
+  useUnmount: () => useUnmount,
+  useUpdateEffect: () => useUpdateEffect,
+  useVideoRef: () => useVideoRef,
+  useVirtualList: () => useVirtualList,
+  useWakeLock: () => useWakeLock,
+  useWebRTC: () => useWebRTC,
+  useWebSocket: () => useWebSocket,
+  useWindowFocus: () => useWindowFocus,
+  useWindowSize: () => useWindowSize,
+  useWorker: () => useWorker
 });
-module.exports = __toCommonJS(index_exports);
-function useVersion() {
-  return "0.0.1";
+module.exports = __toCommonJS(src_exports);
+
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+var import_react = require("react");
+
+// src/utils/index.ts
+var isServer = typeof window === "undefined";
+var isBrowser = !isServer;
+var noop = () => {
+};
+
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+var useIsomorphicLayoutEffect = isServer ? import_react.useEffect : import_react.useLayoutEffect;
+
+// src/hooks/useToggle/useToggle.ts
+var import_react2 = require("react");
+function useToggle(options = {}) {
+  const { initialValue = false } = options;
+  const [value, setValue] = (0, import_react2.useState)(initialValue);
+  const toggle = (0, import_react2.useCallback)(() => setValue((prev) => !prev), []);
+  const setTrue = (0, import_react2.useCallback)(() => setValue(true), []);
+  const setFalse = (0, import_react2.useCallback)(() => setValue(false), []);
+  return {
+    value,
+    toggle,
+    setTrue,
+    setFalse,
+    setValue
+  };
+}
+
+// src/hooks/useCounter/useCounter.ts
+var import_react3 = require("react");
+function useCounter(options = {}) {
+  const { initialValue = 0, min, max, step = 1 } = options;
+  const clamp = (0, import_react3.useCallback)(
+    (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] = (0, import_react3.useState)(() => clamp(initialValue));
+  const increment = (0, import_react3.useCallback)(() => {
+    setCount((prev) => clamp(prev + step));
+  }, [clamp, step]);
+  const decrement = (0, import_react3.useCallback)(() => {
+    setCount((prev) => clamp(prev - step));
+  }, [clamp, step]);
+  const reset = (0, import_react3.useCallback)(() => {
+    setCount(clamp(initialValue));
+  }, [clamp, initialValue]);
+  const set = (0, import_react3.useCallback)(
+    (value) => {
+      setCount(clamp(value));
+    },
+    [clamp]
+  );
+  return {
+    count,
+    increment,
+    decrement,
+    reset,
+    set
+  };
+}
+
+// src/hooks/usePrevious/usePrevious.ts
+var import_react4 = require("react");
+function usePrevious(value) {
+  const ref = (0, import_react4.useRef)(void 0);
+  (0, import_react4.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+// src/hooks/useMount/useMount.ts
+var import_react5 = require("react");
+function useMount(callback) {
+  const callbackRef = (0, import_react5.useRef)(callback);
+  callbackRef.current = callback;
+  (0, import_react5.useEffect)(() => {
+    return callbackRef.current();
+  }, []);
+}
+
+// src/hooks/useUnmount/useUnmount.ts
+var import_react6 = require("react");
+function useUnmount(callback) {
+  const callbackRef = (0, import_react6.useRef)(callback);
+  callbackRef.current = callback;
+  (0, import_react6.useEffect)(() => {
+    return () => {
+      callbackRef.current();
+    };
+  }, []);
+}
+
+// src/hooks/useDebounce/useDebounce.ts
+var import_react7 = require("react");
+function useDebounce(value, options = {}) {
+  const { delay = 500, leading = false, trailing = true } = options;
+  const [debouncedValue, setDebouncedValue] = (0, import_react7.useState)(value);
+  const [isPending, setIsPending] = (0, import_react7.useState)(false);
+  const timeoutRef = (0, import_react7.useRef)(null);
+  const leadingRef = (0, import_react7.useRef)(true);
+  const latestValueRef = (0, import_react7.useRef)(value);
+  latestValueRef.current = value;
+  const cancel = (0, import_react7.useCallback)(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    setIsPending(false);
+  }, []);
+  const flush = (0, import_react7.useCallback)(() => {
+    cancel();
+    setDebouncedValue(latestValueRef.current);
+  }, [cancel]);
+  (0, import_react7.useEffect)(() => {
+    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]);
+  (0, import_react7.useEffect)(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  return {
+    debouncedValue,
+    isPending,
+    cancel,
+    flush
+  };
+}
+
+// src/hooks/useThrottle/useThrottle.ts
+var import_react8 = require("react");
+function useThrottle(value, options = {}) {
+  const { interval = 500, leading = true, trailing = true } = options;
+  const [throttledValue, setThrottledValue] = (0, import_react8.useState)(value);
+  const [isPending, setIsPending] = (0, import_react8.useState)(false);
+  const lastExecuted = (0, import_react8.useRef)(0);
+  const timeoutRef = (0, import_react8.useRef)(null);
+  const latestValue = (0, import_react8.useRef)(value);
+  const isFirstRun = (0, import_react8.useRef)(true);
+  latestValue.current = value;
+  (0, import_react8.useEffect)(() => {
+    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]);
+  (0, import_react8.useEffect)(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  return {
+    throttledValue,
+    isPending
+  };
+}
+
+// src/hooks/useLocalStorage/useLocalStorage.ts
+var import_react9 = require("react");
+function useLocalStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    syncAcrossTabs = true
+  } = options;
+  const readValue = (0, import_react9.useCallback)(() => {
+    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] = (0, import_react9.useState)(readValue);
+  const [exists, setExists] = (0, import_react9.useState)(() => {
+    if (isServer) return false;
+    return window.localStorage.getItem(key) !== null;
+  });
+  const setValue = (0, import_react9.useCallback)(
+    (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 = (0, import_react9.useCallback)(() => {
+    try {
+      setStoredValue(initialValue);
+      setExists(false);
+      if (!isServer) {
+        window.localStorage.removeItem(key);
+      }
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [key, initialValue]);
+  (0, import_react9.useEffect)(() => {
+    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
+var import_react10 = require("react");
+function useSessionStorage(key, initialValue, options = {}) {
+  const {
+    serializer = JSON.stringify,
+    deserializer = JSON.parse,
+    initializeWithValue = false
+  } = options;
+  const [storedValue, setStoredValue] = (0, import_react10.useState)(() => {
+    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 = (0, import_react10.useCallback)(
+    (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 = (0, import_react10.useCallback)(() => {
+    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]);
+  (0, import_react10.useEffect)(() => {
+    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
+var import_react11 = require("react");
+function useTimeout(callback, options) {
+  const { delay, autoStart = true } = options;
+  const [isRunning, setIsRunning] = (0, import_react11.useState)(autoStart);
+  const [isComplete, setIsComplete] = (0, import_react11.useState)(false);
+  const callbackRef = (0, import_react11.useRef)(callback);
+  const timeoutRef = (0, import_react11.useRef)(null);
+  callbackRef.current = callback;
+  const stop = (0, import_react11.useCallback)(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    setIsRunning(false);
+  }, []);
+  const start = (0, import_react11.useCallback)(() => {
+    stop();
+    setIsComplete(false);
+    setIsRunning(true);
+    timeoutRef.current = setTimeout(() => {
+      callbackRef.current();
+      setIsRunning(false);
+      setIsComplete(true);
+      timeoutRef.current = null;
+    }, delay);
+  }, [delay, stop]);
+  const reset = (0, import_react11.useCallback)(() => {
+    stop();
+    setIsComplete(false);
+  }, [stop]);
+  (0, import_react11.useEffect)(() => {
+    if (autoStart) {
+      start();
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [delay]);
+  return {
+    isRunning,
+    isComplete,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/hooks/useInterval/useInterval.ts
+var import_react12 = require("react");
+function useInterval(callback, options) {
+  const { delay, autoStart = true, immediate = false } = options;
+  const [isRunning, setIsRunning] = (0, import_react12.useState)(autoStart);
+  const [count, setCount] = (0, import_react12.useState)(0);
+  const callbackRef = (0, import_react12.useRef)(callback);
+  const intervalRef = (0, import_react12.useRef)(null);
+  callbackRef.current = callback;
+  const stop = (0, import_react12.useCallback)(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+    setIsRunning(false);
+  }, []);
+  const start = (0, import_react12.useCallback)(() => {
+    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 = (0, import_react12.useCallback)(() => {
+    setCount(0);
+  }, []);
+  (0, import_react12.useEffect)(() => {
+    if (autoStart) {
+      start();
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [delay]);
+  return {
+    isRunning,
+    count,
+    start,
+    stop,
+    reset
+  };
+}
+
+// src/hooks/useUpdateEffect/useUpdateEffect.ts
+var import_react13 = require("react");
+function useUpdateEffect(effect, deps) {
+  const isFirstMount = (0, import_react13.useRef)(true);
+  (0, import_react13.useEffect)(() => {
+    if (isFirstMount.current) {
+      isFirstMount.current = false;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+
+// src/hooks/useIsMounted/useIsMounted.ts
+var import_react14 = require("react");
+function useIsMounted() {
+  const isMountedRef = (0, import_react14.useRef)(false);
+  (0, import_react14.useEffect)(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return (0, import_react14.useCallback)(() => isMountedRef.current, []);
+}
+
+// src/hooks/useStableCallback/useStableCallback.ts
+var import_react15 = require("react");
+function useStableCallback(callback) {
+  const callbackRef = (0, import_react15.useRef)(callback);
+  (0, import_react15.useEffect)(() => {
+    callbackRef.current = callback;
+  });
+  return (0, import_react15.useCallback)((...args) => {
+    return callbackRef.current(...args);
+  }, []);
+}
+var useStableCallback_default = useStableCallback;
+
+// src/hooks/useMediaQuery/useMediaQuery.ts
+var import_react16 = require("react");
+function useMediaQuery(query, options = {}) {
+  const { defaultValue = false, initializeOnMount = false } = options;
+  const getMatches = (0, import_react16.useCallback)(() => {
+    if (isServer) {
+      return defaultValue;
+    }
+    return window.matchMedia(query).matches;
+  }, [query, defaultValue]);
+  const [matches, setMatches] = (0, import_react16.useState)(() => {
+    if (initializeOnMount) {
+      return defaultValue;
+    }
+    return getMatches();
+  });
+  (0, import_react16.useEffect)(() => {
+    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
+var import_react17 = require("react");
+function useWindowSize(options = {}) {
+  const { debounce = 0, initialWidth = 0, initialHeight = 0 } = options;
+  const getSize = (0, import_react17.useCallback)(() => {
+    if (isServer) {
+      return { width: initialWidth, height: initialHeight };
+    }
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  }, [initialWidth, initialHeight]);
+  const [windowSize, setWindowSize] = (0, import_react17.useState)(getSize);
+  (0, import_react17.useEffect)(() => {
+    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
+var import_react18 = require("react");
+function useClickOutside(ref, callback, options = {}) {
+  const { events = ["mousedown", "touchstart"], enabled = true } = options;
+  const callbackRef = (0, import_react18.useRef)(callback);
+  callbackRef.current = callback;
+  (0, import_react18.useEffect)(() => {
+    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
+var import_react19 = require("react");
+function useHover() {
+  const [isHovered, setIsHovered] = (0, import_react19.useState)(false);
+  const nodeRef = (0, import_react19.useRef)(null);
+  const handleMouseEnter = (0, import_react19.useCallback)(() => {
+    setIsHovered(true);
+  }, []);
+  const handleMouseLeave = (0, import_react19.useCallback)(() => {
+    setIsHovered(false);
+  }, []);
+  const ref = (0, import_react19.useCallback)(
+    (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
+var import_react20 = require("react");
+function useKeyPress(targetKey, callback, options = {}) {
+  const {
+    target = "window",
+    event = "keydown",
+    preventDefault = false,
+    enabled = true
+  } = options;
+  const [isPressed, setIsPressed] = (0, import_react20.useState)(false);
+  const callbackRef = (0, import_react20.useCallback)(
+    (e) => {
+      callback?.(e);
+    },
+    [callback]
+  );
+  (0, import_react20.useEffect)(() => {
+    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
+var import_react21 = require("react");
+function useScroll(ref, options = {}) {
+  const { throttle = 0 } = options;
+  const [position, setPosition] = (0, import_react21.useState)({ x: 0, y: 0 });
+  const [direction, setDirection] = (0, import_react21.useState)(null);
+  const [boundaries, setBoundaries] = (0, import_react21.useState)({
+    isAtTop: true,
+    isAtBottom: false,
+    isAtLeft: true,
+    isAtRight: false
+  });
+  const lastPositionRef = (0, import_react21.useRef)({ x: 0, y: 0 });
+  const throttleTimerRef = (0, import_react21.useRef)(null);
+  (0, import_react21.useEffect)(() => {
+    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
+var import_react22 = require("react");
+function useIntersection(options = {}) {
+  const {
+    root = null,
+    rootMargin = "0px",
+    threshold = 0,
+    triggerOnce = false,
+    enabled = true
+  } = options;
+  const [entry, setEntry] = (0, import_react22.useState)(null);
+  const [isIntersecting, setIsIntersecting] = (0, import_react22.useState)(false);
+  const ref = (0, import_react22.useRef)(null);
+  const hasTriggeredRef = (0, import_react22.useRef)(false);
+  (0, import_react22.useEffect)(() => {
+    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
+var import_react23 = require("react");
+function useCopyToClipboard() {
+  const [copiedValue, setCopiedValue] = (0, import_react23.useState)(null);
+  const [isSuccess, setIsSuccess] = (0, import_react23.useState)(false);
+  const [error, setError] = (0, import_react23.useState)(null);
+  const copy = (0, import_react23.useCallback)(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 = (0, import_react23.useCallback)(() => {
+    setCopiedValue(null);
+    setIsSuccess(false);
+    setError(null);
+  }, []);
+  return {
+    copiedValue,
+    isSuccess,
+    error,
+    copy,
+    reset
+  };
+}
+
+// src/hooks/useDocumentTitle/useDocumentTitle.ts
+var import_react24 = require("react");
+function useDocumentTitle(title, options = {}) {
+  const { restoreOnUnmount = true } = options;
+  const previousTitleRef = (0, import_react24.useRef)(null);
+  (0, import_react24.useEffect)(() => {
+    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
+var import_react25 = require("react");
+function useLockBodyScroll(lock = true) {
+  (0, import_react25.useEffect)(() => {
+    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
+var import_react26 = require("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 = (0, import_react26.useMemo)(() => {
+    if (theme === "system") {
+      return systemPrefersDark ? "dark" : "light";
+    }
+    return theme === "dark" ? "dark" : "light";
+  }, [theme, systemPrefersDark]);
+  const applyTheme = (0, import_react26.useCallback)(() => {
+    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 = (0, import_react26.useCallback)(() => {
+    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
+var import_react27 = require("react");
+function useEvent(name, handler, target = isServer ? null : window, options = {}) {
+  const handlerRef = (0, import_react27.useRef)(handler);
+  handlerRef.current = handler;
+  (0, import_react27.useEffect)(() => {
+    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
+var import_react28 = require("react");
+function useLongPress(onLongPress, options = {}) {
+  const {
+    threshold = 500,
+    cancelOnMove = true,
+    onStart,
+    onFinish,
+    onCancel
+  } = options;
+  const callbackRef = (0, import_react28.useRef)(onLongPress);
+  const onStartRef = (0, import_react28.useRef)(onStart);
+  const onFinishRef = (0, import_react28.useRef)(onFinish);
+  const onCancelRef = (0, import_react28.useRef)(onCancel);
+  callbackRef.current = onLongPress;
+  onStartRef.current = onStart;
+  onFinishRef.current = onFinish;
+  onCancelRef.current = onCancel;
+  const timerRef = (0, import_react28.useRef)(null);
+  const isLongPressActive = (0, import_react28.useRef)(false);
+  const start = (0, import_react28.useCallback)(
+    (event) => {
+      onStartRef.current?.(event);
+      isLongPressActive.current = false;
+      timerRef.current = setTimeout(() => {
+        isLongPressActive.current = true;
+        callbackRef.current(event);
+        onFinishRef.current?.(event);
+      }, threshold);
+    },
+    [threshold]
+  );
+  const cancel = (0, import_react28.useCallback)(
+    (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
+var import_react29 = require("react");
+function useWindowFocus() {
+  const [isFocused, setIsFocused] = (0, import_react29.useState)(
+    () => !isServer && typeof document !== "undefined" ? document.hasFocus() : true
+  );
+  (0, import_react29.useEffect)(() => {
+    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
+var import_react30 = require("react");
+function useResizeObserver(ref, options = {}) {
+  const { throttle = 0 } = options;
+  const [contentRect, setContentRect] = (0, import_react30.useState)();
+  const throttleTimerRef = (0, import_react30.useRef)(null);
+  (0, import_react30.useEffect)(() => {
+    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
+var import_react31 = require("react");
+function useMutationObserver(ref, callback, options = {
+  attributes: true,
+  characterData: true,
+  childList: true,
+  subtree: true
+}) {
+  const callbackRef = (0, import_react31.useRef)(callback);
+  callbackRef.current = callback;
+  const optionsRef = (0, import_react31.useRef)(options);
+  optionsRef.current = options;
+  (0, import_react31.useEffect)(() => {
+    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
+var import_react32 = require("react");
+function usePageLeave(onPageLeave) {
+  (0, import_react32.useEffect)(() => {
+    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
+var import_react33 = require("react");
+function useEyeDropper() {
+  const isSupported = !isServer && "EyeDropper" in window;
+  const open = (0, import_react33.useCallback)(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
+var import_react34 = require("react");
+function useOnline() {
+  const [isOnline, setIsOnline] = (0, import_react34.useState)(() => {
+    if (isServer) return true;
+    return navigator.onLine;
+  });
+  const [since, setSince] = (0, import_react34.useState)(null);
+  const handleOnline = (0, import_react34.useCallback)(() => {
+    setIsOnline(true);
+    setSince(Date.now());
+  }, []);
+  const handleOffline = (0, import_react34.useCallback)(() => {
+    setIsOnline(false);
+    setSince(Date.now());
+  }, []);
+  (0, import_react34.useEffect)(() => {
+    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
+var import_react35 = require("react");
+function useNetworkState() {
+  const [state, setState] = (0, import_react35.useState)({
+    online: true
+  });
+  (0, import_react35.useEffect)(() => {
+    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
+var import_react36 = require("react");
+function useFullscreen(ref) {
+  const [isFullscreen, setIsFullscreen] = (0, import_react36.useState)(false);
+  const isSupported = !isServer && !!document.fullscreenEnabled;
+  const getElement = (0, import_react36.useCallback)(() => {
+    return ref?.current ?? document.documentElement;
+  }, [ref]);
+  const enter = (0, import_react36.useCallback)(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 = (0, import_react36.useCallback)(async () => {
+    if (isServer || !isSupported) return;
+    try {
+      await document.exitFullscreen();
+    } catch (error) {
+      console.error("Failed to exit fullscreen:", error);
+    }
+  }, [isSupported]);
+  const toggle = (0, import_react36.useCallback)(async () => {
+    if (isFullscreen) {
+      await exit();
+    } else {
+      await enter();
+    }
+  }, [isFullscreen, enter, exit]);
+  (0, import_react36.useEffect)(() => {
+    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
+var import_react37 = require("react");
+function useShare() {
+  const [isSharing, setIsSharing] = (0, import_react37.useState)(false);
+  const [isSuccess, setIsSuccess] = (0, import_react37.useState)(false);
+  const [error, setError] = (0, import_react37.useState)(null);
+  const isSupported = !isServer && !!navigator.share;
+  const canShare = (0, import_react37.useCallback)(
+    (data) => {
+      if (isServer || !navigator.canShare) return isSupported;
+      if (!data) return isSupported;
+      return navigator.canShare(data);
+    },
+    [isSupported]
+  );
+  const share = (0, import_react37.useCallback)(
+    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
+var import_react38 = require("react");
+function usePermissions(name) {
+  const [state, setState] = (0, import_react38.useState)("unknown");
+  (0, import_react38.useEffect)(() => {
+    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
+var import_react39 = require("react");
+function useWakeLock({
+  onRequest,
+  onRelease,
+  onError
+} = {}) {
+  const [released, setReleased] = (0, import_react39.useState)();
+  const wakeLockRef = (0, import_react39.useRef)(null);
+  const isSupported = !isServer && "wakeLock" in navigator;
+  const release = (0, import_react39.useCallback)(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 = (0, import_react39.useCallback)(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]);
+  (0, import_react39.useEffect)(() => {
+    return () => {
+      release();
+    };
+  }, [release]);
+  (0, import_react39.useEffect)(() => {
+    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
+var import_react40 = require("react");
+function useMediaDevices() {
+  const [devices, setDevices] = (0, import_react40.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react40.useState)(true);
+  const [error, setError] = (0, import_react40.useState)(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);
+    }
+  });
+  (0, import_react40.useEffect)(() => {
+    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
+var import_react41 = require("react");
+function useMediaRecorder(stream, options) {
+  const [status, setStatus] = (0, import_react41.useState)("idle");
+  const [mediaBlob, setMediaBlob] = (0, import_react41.useState)();
+  const [mediaUrl, setMediaUrl] = (0, import_react41.useState)();
+  const [error, setError] = (0, import_react41.useState)(null);
+  const mediaRecorderRef = (0, import_react41.useRef)(null);
+  const chunksRef = (0, import_react41.useRef)([]);
+  const start = (0, import_react41.useCallback)(
+    (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 = (0, import_react41.useCallback)(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+      mediaRecorderRef.current.stop();
+    }
+  }, []);
+  const pause = (0, import_react41.useCallback)(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state === "recording") {
+      mediaRecorderRef.current.pause();
+      setStatus("paused");
+    }
+  }, []);
+  const resume = (0, import_react41.useCallback)(() => {
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state === "paused") {
+      mediaRecorderRef.current.resume();
+      setStatus("recording");
+    }
+  }, []);
+  const clear = (0, import_react41.useCallback)(() => {
+    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
+var import_react42 = require("react");
+function useBattery() {
+  const [state, setState] = (0, import_react42.useState)({
+    supported: false,
+    loading: true,
+    level: 1,
+    charging: false,
+    chargingTime: 0,
+    dischargingTime: Infinity
+  });
+  (0, import_react42.useEffect)(() => {
+    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
+var import_react43 = require("react");
+function useBluetooth() {
+  const [device, setDevice] = (0, import_react43.useState)(null);
+  const [server, setServer] = (0, import_react43.useState)(null);
+  const [error, setError] = (0, import_react43.useState)(null);
+  const [isConnecting, setIsConnecting] = (0, import_react43.useState)(false);
+  const isSupported = !isServer && "bluetooth" in navigator;
+  const disconnect = (0, import_react43.useCallback)(() => {
+    if (device && device.gatt?.connected) {
+      device.gatt.disconnect();
+    }
+    setDevice(null);
+    setServer(null);
+    setIsConnecting(false);
+  }, [device]);
+  const requestDevice = (0, import_react43.useCallback)(
+    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
+var import_react44 = require("react");
+function useGamepad(options = {}) {
+  const { enabled = true } = options;
+  const [gamepads, setGamepads] = (0, import_react44.useState)([]);
+  const requestRef = (0, import_react44.useRef)(null);
+  const scanGamepads = () => {
+    if (isServer) return;
+    const detectedGamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    const gamepadArray = Array.from(detectedGamepads);
+    setGamepads(gamepadArray);
+  };
+  (0, import_react44.useEffect)(() => {
+    if (isServer) return;
+    window.addEventListener("gamepadconnected", scanGamepads);
+    window.addEventListener("gamepaddisconnected", scanGamepads);
+    return () => {
+      window.removeEventListener("gamepadconnected", scanGamepads);
+      window.removeEventListener("gamepaddisconnected", scanGamepads);
+    };
+  }, []);
+  (0, import_react44.useEffect)(() => {
+    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
+var import_react45 = require("react");
+function useFileSystem() {
+  const [file, setFile] = (0, import_react45.useState)(null);
+  const [fileHandle, setFileHandle] = (0, import_react45.useState)(null);
+  const [error, setError] = (0, import_react45.useState)(null);
+  const isSupported = !isServer && "showOpenFilePicker" in window;
+  const openFile = (0, import_react45.useCallback)(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 = (0, import_react45.useCallback)(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
+  };
 }
-var index_default = {
-  version: "0.0.1"
+
+// src/hooks/useStorageEstimate/useStorageEstimate.ts
+var import_react46 = require("react");
+function useStorageEstimate() {
+  const [estimate, setEstimate] = (0, import_react46.useState)({
+    quota: void 0,
+    usage: void 0,
+    supported: false,
+    loading: true
+  });
+  (0, import_react46.useEffect)(() => {
+    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
+var import_react47 = require("react");
+function useAsync(asyncFunction, options = {}) {
+  const { immediate = false, initialData, onSuccess, onError } = options;
+  const [status, setStatus] = (0, import_react47.useState)("idle");
+  const [data, setData] = (0, import_react47.useState)(initialData);
+  const [error, setError] = (0, import_react47.useState)(null);
+  const isMountedRef = (0, import_react47.useRef)(true);
+  const asyncFunctionRef = (0, import_react47.useRef)(asyncFunction);
+  asyncFunctionRef.current = asyncFunction;
+  const execute = (0, import_react47.useCallback)(
+    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 = (0, import_react47.useCallback)(() => {
+    setStatus("idle");
+    setData(initialData);
+    setError(null);
+  }, [initialData]);
+  (0, import_react47.useEffect)(() => {
+    if (immediate) {
+      execute(...[]);
+    }
+  }, []);
+  (0, import_react47.useEffect)(() => {
+    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
+var import_react48 = require("react");
+function useFetch(url, options = {}) {
+  const {
+    immediate = true,
+    initialData,
+    transform,
+    retries = 0,
+    retryDelay = 1e3,
+    onSuccess,
+    onError,
+    abortPrevious = true,
+    ...fetchOptions
+  } = options;
+  const [data, setData] = (0, import_react48.useState)(initialData);
+  const [error, setError] = (0, import_react48.useState)(null);
+  const [status, setStatus] = (0, import_react48.useState)("idle");
+  const abortControllerRef = (0, import_react48.useRef)(null);
+  const isMountedRef = (0, import_react48.useRef)(true);
+  const retryCountRef = (0, import_react48.useRef)(0);
+  const abort = (0, import_react48.useCallback)(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  const optionsRef = (0, import_react48.useRef)(fetchOptions);
+  optionsRef.current = fetchOptions;
+  const onSuccessRef = (0, import_react48.useRef)(onSuccess);
+  onSuccessRef.current = onSuccess;
+  const onErrorRef = (0, import_react48.useRef)(onError);
+  onErrorRef.current = onError;
+  const transformRef = (0, import_react48.useRef)(transform);
+  transformRef.current = transform;
+  const fetchData = (0, import_react48.useCallback)(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]);
+  (0, import_react48.useEffect)(() => {
+    if (immediate && url) {
+      fetchData();
+    }
+    return () => {
+      abort();
+    };
+  }, [url, immediate]);
+  (0, import_react48.useEffect)(() => {
+    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
+var import_react49 = require("react");
+var scriptCache = /* @__PURE__ */ new Map();
+function useScript(src, options = {}) {
+  const { immediate = true, removeOnUnmount = false, attributes = {} } = options;
+  const [status, setStatus] = (0, import_react49.useState)(() => {
+    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 = (0, import_react49.useRef)(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);
+  };
+  (0, import_react49.useEffect)(() => {
+    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
+var import_react50 = require("react");
+function useWorker(workerScript) {
+  const [result, setResult] = (0, import_react50.useState)();
+  const [error, setError] = (0, import_react50.useState)(null);
+  const [status, setStatus] = (0, import_react50.useState)("idle");
+  const workerRef = (0, import_react50.useRef)(null);
+  const workerUrlRef = (0, import_react50.useRef)(null);
+  (0, import_react50.useEffect)(() => {
+    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 = (0, import_react50.useCallback)((input) => {
+    if (workerRef.current) {
+      setStatus("running");
+      setError(null);
+      workerRef.current.postMessage(input);
+    }
+  }, []);
+  const terminate = (0, import_react50.useCallback)(() => {
+    workerRef.current?.terminate();
+    setStatus("idle");
+  }, []);
+  return {
+    result,
+    error,
+    status,
+    run,
+    terminate
+  };
+}
+
+// src/hooks/useIndexedDB/useIndexedDB.ts
+var import_react51 = require("react");
+function useIndexedDB(dbName, storeName, key) {
+  const [value, setValue] = (0, import_react51.useState)();
+  const [error, setError] = (0, import_react51.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react51.useState)(true);
+  const openDB = (0, import_react51.useCallback)(() => {
+    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 = (0, import_react51.useCallback)(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]);
+  (0, import_react51.useEffect)(() => {
+    load();
+  }, [load]);
+  const set = (0, import_react51.useCallback)(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 = (0, import_react51.useCallback)(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
+var import_react52 = require("react");
+function useHistory(initialValue, options = {}) {
+  const { maxSize = 100 } = options;
+  const [state, setState] = (0, import_react52.useState)({
+    history: [initialValue],
+    position: 0
+  });
+  const { history, position } = state;
+  const value = history[position];
+  const set = (0, import_react52.useCallback)(
+    (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 = (0, import_react52.useCallback)(() => {
+    setState((prev) => ({
+      ...prev,
+      position: Math.max(0, prev.position - 1)
+    }));
+  }, []);
+  const redo = (0, import_react52.useCallback)(() => {
+    setState((prev) => ({
+      ...prev,
+      position: Math.min(prev.history.length - 1, prev.position + 1)
+    }));
+  }, []);
+  const reset = (0, import_react52.useCallback)((value2) => {
+    setState({
+      history: [value2],
+      position: 0
+    });
+  }, []);
+  const go = (0, import_react52.useCallback)((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
+  };
+}
+
+// src/hooks/useStep/useStep.ts
+var import_react53 = require("react");
+function useStep(options) {
+  const { initialStep = 0, maxStep } = options;
+  const [currentStep, setCurrentStep] = (0, import_react53.useState)(
+    () => Math.max(0, Math.min(initialStep, maxStep - 1))
+  );
+  const next = (0, import_react53.useCallback)(() => {
+    setCurrentStep((prev2) => Math.min(prev2 + 1, maxStep - 1));
+  }, [maxStep]);
+  const prev = (0, import_react53.useCallback)(() => {
+    setCurrentStep((prev2) => Math.max(prev2 - 1, 0));
+  }, []);
+  const goTo = (0, import_react53.useCallback)(
+    (step) => {
+      setCurrentStep(Math.max(0, Math.min(step, maxStep - 1)));
+    },
+    [maxStep]
+  );
+  const reset = (0, import_react53.useCallback)(() => {
+    setCurrentStep(Math.max(0, Math.min(initialStep, maxStep - 1)));
+  }, [initialStep, maxStep]);
+  const isStepComplete = (0, import_react53.useCallback)(
+    (step) => {
+      return step < currentStep;
+    },
+    [currentStep]
+  );
+  const isFirst = currentStep === 0;
+  const isLast = currentStep === maxStep - 1;
+  const progress = (0, import_react53.useMemo)(
+    () => (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
+var import_react54 = require("react");
+function usePagination(options) {
+  const {
+    totalItems,
+    pageSize: initialPageSize = 10,
+    initialPage = 1,
+    siblings = 1
+  } = options;
+  const [page, setPage] = (0, import_react54.useState)(() => Math.max(1, initialPage));
+  const [pageSize, setPageSizeState] = (0, import_react54.useState)(initialPageSize);
+  const totalPages = (0, import_react54.useMemo)(
+    () => Math.max(1, Math.ceil(totalItems / pageSize)),
+    [totalItems, pageSize]
+  );
+  const boundedPage = (0, import_react54.useMemo)(
+    () => Math.min(page, totalPages),
+    [page, totalPages]
+  );
+  const next = (0, import_react54.useCallback)(() => {
+    setPage((prev2) => Math.min(prev2 + 1, totalPages));
+  }, [totalPages]);
+  const prev = (0, import_react54.useCallback)(() => {
+    setPage((prev2) => Math.max(prev2 - 1, 1));
+  }, []);
+  const goTo = (0, import_react54.useCallback)(
+    (newPage) => {
+      setPage(Math.max(1, Math.min(newPage, totalPages)));
+    },
+    [totalPages]
+  );
+  const first = (0, import_react54.useCallback)(() => {
+    setPage(1);
+  }, []);
+  const last = (0, import_react54.useCallback)(() => {
+    setPage(totalPages);
+  }, [totalPages]);
+  const setPageSize = (0, import_react54.useCallback)(
+    (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 = (0, import_react54.useMemo)(() => {
+    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
+var import_react55 = require("react");
+function useMachine(config) {
+  const [state, dispatch] = (0, import_react55.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
+var import_react56 = require("react");
+function useVirtualList(options) {
+  const { itemHeight, itemCount, containerHeight, overscan = 3 } = options;
+  const [scrollTop, setScrollTop] = (0, import_react56.useState)(0);
+  const totalHeight = itemCount * itemHeight;
+  const onScroll = (0, import_react56.useCallback)((event) => {
+    setScrollTop(event.currentTarget.scrollTop);
+  }, []);
+  const items = (0, import_react56.useMemo)(() => {
+    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
+var import_react57 = require("react");
+function useInfiniteScroll(onLoadMore, options = {}) {
+  const {
+    threshold = 0,
+    rootMargin = "0px",
+    isLoading = false,
+    hasMore = true,
+    disabled = false
+  } = options;
+  const targetRef = (0, import_react57.useRef)(null);
+  const onLoadMoreStable = useStableCallback_default(onLoadMore);
+  (0, import_react57.useEffect)(() => {
+    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
+var import_react58 = require("react");
+function useAnthropic(options = {}) {
+  const {
+    apiKey,
+    model = "claude-3-haiku-20240307",
+    maxTokens = 1024,
+    temperature = 0.7
+  } = options;
+  const [loading, setLoading] = (0, import_react58.useState)(false);
+  const [response, setResponse] = (0, import_react58.useState)(null);
+  const [error, setError] = (0, import_react58.useState)(null);
+  const chat = (0, import_react58.useCallback)(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
+var import_react59 = require("react");
+function useEmbeddings(fetcher) {
+  const [embeddings, setEmbeddings] = (0, import_react59.useState)(null);
+  const [loading, setLoading] = (0, import_react59.useState)(false);
+  const [error, setError] = (0, import_react59.useState)(null);
+  const generate = (0, import_react59.useCallback)(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
+var import_react60 = require("react");
+function useGemini(options = {}) {
+  const {
+    apiKey,
+    model = "gemini-pro"
+  } = options;
+  const [loading, setLoading] = (0, import_react60.useState)(false);
+  const [response, setResponse] = (0, import_react60.useState)(null);
+  const [error, setError] = (0, import_react60.useState)(null);
+  const chat = (0, import_react60.useCallback)(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
+var import_react61 = require("react");
+function useLLMStream(options = {}) {
+  const [data, setData] = (0, import_react61.useState)("");
+  const [loading, setLoading] = (0, import_react61.useState)(false);
+  const [error, setError] = (0, import_react61.useState)(null);
+  const abortControllerRef = (0, import_react61.useRef)(null);
+  const stream = (0, import_react61.useCallback)(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 = (0, import_react61.useCallback)(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+      setLoading(false);
+    }
+  }, []);
+  return {
+    stream,
+    cancel,
+    data,
+    loading,
+    error
+  };
+}
+
+// src/hooks/useOpenAI/useOpenAI.ts
+var import_react62 = require("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] = (0, import_react62.useState)(false);
+  const [response, setResponse] = (0, import_react62.useState)(null);
+  const [error, setError] = (0, import_react62.useState)(null);
+  const chat = (0, import_react62.useCallback)(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
+var import_react63 = require("react");
+function useRAG(options) {
+  const [loading, setLoading] = (0, import_react63.useState)(false);
+  const [answer, setAnswer] = (0, import_react63.useState)(null);
+  const [retrievedDocs, setRetrievedDocs] = (0, import_react63.useState)([]);
+  const [error, setError] = (0, import_react63.useState)(null);
+  const ask = (0, import_react63.useCallback)(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
+var import_react64 = require("react");
+function useSearchHighlight(text, query, options = {}) {
+  const { caseSensitive = false } = options;
+  return (0, import_react64.useMemo)(() => {
+    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
+var import_react65 = require("react");
+function useSemanticSearch(queryEmbedding, items, getItemEmbedding, topK = 5) {
+  return (0, import_react65.useMemo)(() => {
+    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
+var import_react66 = require("react");
+function useSTT(options = {}) {
+  const [listening, setListening] = (0, import_react66.useState)(false);
+  const [transcript, setTranscript] = (0, import_react66.useState)("");
+  const [supported, setSupported] = (0, import_react66.useState)(false);
+  const recognitionRef = (0, import_react66.useRef)(null);
+  const optionsRef = (0, import_react66.useRef)(options);
+  optionsRef.current = options;
+  (0, import_react66.useEffect)(() => {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (SpeechRecognition) {
+      setSupported(true);
+      recognitionRef.current = new SpeechRecognition();
+    }
+  }, []);
+  const listen = (0, import_react66.useCallback)(() => {
+    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 = (0, import_react66.useCallback)(() => {
+    recognitionRef.current?.stop();
+    setListening(false);
+  }, []);
+  const abort = (0, import_react66.useCallback)(() => {
+    recognitionRef.current?.abort();
+    setListening(false);
+  }, []);
+  return {
+    listen,
+    stop,
+    abort,
+    listening,
+    transcript,
+    supported
+  };
+}
+
+// src/hooks/useTTS/useTTS.ts
+var import_react67 = require("react");
+function useTTS(options = {}) {
+  const [speaking, setSpeaking] = (0, import_react67.useState)(false);
+  const [supported, setSupported] = (0, import_react67.useState)(false);
+  const [voices, setVoices] = (0, import_react67.useState)([]);
+  const optionsRef = (0, import_react67.useRef)(options);
+  optionsRef.current = options;
+  (0, import_react67.useEffect)(() => {
+    if (typeof window !== "undefined" && "speechSynthesis" in window) {
+      setSupported(true);
+      const updateVoices = () => {
+        setVoices(window.speechSynthesis.getVoices());
+      };
+      updateVoices();
+      window.speechSynthesis.onvoiceschanged = updateVoices;
+    }
+  }, []);
+  const cancel = (0, import_react67.useCallback)(() => {
+    if (!supported) return;
+    window.speechSynthesis.cancel();
+    setSpeaking(false);
+  }, [supported]);
+  const speak = (0, import_react67.useCallback)((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]);
+  (0, import_react67.useEffect)(() => {
+    return () => {
+      if (supported) {
+        window.speechSynthesis.cancel();
+      }
+    };
+  }, [supported]);
+  return {
+    speak,
+    cancel,
+    speaking,
+    supported,
+    voices
+  };
+}
+
+// src/hooks/useAnimate/useAnimate.ts
+var import_react68 = require("react");
+function useAnimate(callback, running = true) {
+  const requestRef = (0, import_react68.useRef)();
+  const previousTimeRef = (0, import_react68.useRef)();
+  const savedCallback = useStableCallback(callback);
+  const animate = (0, import_react68.useCallback)((time) => {
+    if (previousTimeRef.current !== void 0) {
+      const deltaTime = time - previousTimeRef.current;
+      savedCallback(time, deltaTime);
+    }
+    previousTimeRef.current = time;
+    requestRef.current = requestAnimationFrame(animate);
+  }, [savedCallback]);
+  (0, import_react68.useEffect)(() => {
+    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
+var import_react69 = require("react");
+function useMediaRef() {
+  const ref = (0, import_react69.useRef)(null);
+  const [state, setState] = (0, import_react69.useState)({
+    playing: false,
+    paused: true,
+    muted: false,
+    volume: 1,
+    time: 0,
+    duration: 0,
+    buffered: 0,
+    waiting: false,
+    ended: false
+  });
+  const updateState = (0, import_react69.useCallback)(() => {
+    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
+    });
+  }, []);
+  (0, import_react69.useEffect)(() => {
+    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
+var import_react70 = require("react");
+function useCanvas(options = {}) {
+  const canvasRef = (0, import_react70.useRef)(null);
+  const requestRef = (0, import_react70.useRef)();
+  const frameCountRef = (0, import_react70.useRef)(0);
+  (0, import_react70.useEffect)(() => {
+    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
+var import_react71 = require("react");
+function useFrameRate(running = true) {
+  const [fps, setFps] = (0, import_react71.useState)(0);
+  const frameCountRef = (0, import_react71.useRef)(0);
+  const lastTimeRef = (0, import_react71.useRef)(performance.now());
+  const requestRef = (0, import_react71.useRef)();
+  (0, import_react71.useEffect)(() => {
+    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
+var import_lottie_web = __toESM(require("lottie-web"));
+var import_react72 = require("react");
+function useLottie(containerRef, options) {
+  const animationRef = (0, import_react72.useRef)();
+  (0, import_react72.useEffect)(() => {
+    if (!containerRef.current) return;
+    const anim = import_lottie_web.default.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]);
+  (0, import_react72.useEffect)(() => {
+    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
+var import_react73 = require("react");
+function useParallax(options = {}) {
+  const { speed = 0.5, axis = "y" } = options;
+  const [offset, setOffset] = (0, import_react73.useState)(0);
+  const ref = (0, import_react73.useRef)(null);
+  (0, import_react73.useEffect)(() => {
+    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
+var import_react74 = require("react");
+var DEFAULT_CONFIG = {
+  stiffness: 170,
+  damping: 26,
+  mass: 1
 };
+function useSpringCore(targetValue, options = {}) {
+  const [value, setValue] = (0, import_react74.useState)(options.initialValue ?? targetValue);
+  const velocityRef = (0, import_react74.useRef)(0);
+  const valueRef = (0, import_react74.useRef)(options.initialValue ?? targetValue);
+  const lastTimeRef = (0, import_react74.useRef)();
+  const rafRef = (0, import_react74.useRef)();
+  const config = { ...DEFAULT_CONFIG, ...options };
+  (0, import_react74.useEffect)(() => {
+    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
+var import_react75 = require("react");
+function useSVGAnimation(length, options = {}) {
+  const [offset, setOffset] = (0, import_react75.useState)(length);
+  const { duration = 1e3, delay = 0, easing = (t) => t } = options;
+  (0, import_react75.useEffect)(() => {
+    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
+var import_react76 = require("react");
+var THREE = __toESM(require("three"));
+function useThreeJS(containerRef, options = {}) {
+  const { init, animate, resize = true } = options;
+  const rendererRef = (0, import_react76.useRef)();
+  const sceneRef = (0, import_react76.useRef)();
+  const cameraRef = (0, import_react76.useRef)();
+  const requestRef = (0, import_react76.useRef)();
+  (0, import_react76.useEffect)(() => {
+    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
+var import_react77 = require("react");
+function useBroadcastChannel(channelName) {
+  const [lastMessage, setLastMessage] = (0, import_react77.useState)(null);
+  const channelRef = (0, import_react77.useRef)(null);
+  (0, import_react77.useEffect)(() => {
+    const channel = new BroadcastChannel(channelName);
+    channelRef.current = channel;
+    channel.onmessage = (event) => {
+      setLastMessage(event.data);
+    };
+    return () => {
+      channel.close();
+    };
+  }, [channelName]);
+  const postMessage = (0, import_react77.useCallback)((message) => {
+    channelRef.current?.postMessage(message);
+  }, []);
+  return { postMessage, lastMessage };
+}
+
+// src/hooks/useCalendar/useCalendar.ts
+var import_react78 = require("react");
+function useCalendar(options = {}) {
+  const [date, setDate] = (0, import_react78.useState)(options.initialDate || /* @__PURE__ */ new Date());
+  const daysInMonth = (0, import_react78.useMemo)(() => {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    return new Date(year, month + 1, 0).getDate();
+  }, [date]);
+  const firstDayOfMonth = (0, import_react78.useMemo)(() => {
+    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
+var import_react79 = require("react");
+function useDragAndDrop(options = {}) {
+  const [isDragging, setIsDragging] = (0, import_react79.useState)(false);
+  const ref = (0, import_react79.useRef)(null);
+  const handleDragEnter = (0, import_react79.useCallback)((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(true);
+  }, []);
+  const handleDragLeave = (0, import_react79.useCallback)((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+  }, []);
+  const handleDragOver = (0, import_react79.useCallback)((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = (0, import_react79.useCallback)((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]);
+  (0, import_react79.useEffect)(() => {
+    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
+var import_react80 = require("react");
+function useFileProcessing(options = {}) {
+  const [processing, setProcessing] = (0, import_react80.useState)(false);
+  const [error, setError] = (0, import_react80.useState)(null);
+  const process = (0, import_react80.useCallback)(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
+var import_react81 = require("react");
+function useForm(options) {
+  const [values, setValues] = (0, import_react81.useState)(options.initialValues);
+  const [errors, setErrors] = (0, import_react81.useState)({});
+  const [isSubmitting, setIsSubmitting] = (0, import_react81.useState)(false);
+  const [touched, setTouched] = (0, import_react81.useState)({});
+  const handleChange = (0, import_react81.useCallback)((e) => {
+    const { name, value, type } = e.target;
+    const val = type === "checkbox" ? e.target.checked : value;
+    setValues((prev) => ({ ...prev, [name]: val }));
+  }, []);
+  const setFieldValue = (0, import_react81.useCallback)((name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+  }, []);
+  const handleBlur = (0, import_react81.useCallback)((e) => {
+    const { name } = e.target;
+    setTouched((prev) => ({ ...prev, [name]: true }));
+  }, []);
+  const handleSubmit = (0, import_react81.useCallback)(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
+var import_react82 = require("react");
+function usePDF() {
+  const [generating, setGenerating] = (0, import_react82.useState)(false);
+  const generate = (0, import_react82.useCallback)(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
+var import_react83 = require("react");
+function usePresence(heartbeatInterval = 5e3) {
+  const [lastActive, setLastActive] = (0, import_react83.useState)(Date.now());
+  const [isIdle, setIsIdle] = (0, import_react83.useState)(false);
+  (0, import_react83.useEffect)(() => {
+    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
+var import_react84 = require("react");
+function useRealtimeCollab(userId) {
+  const [events, setEvents] = (0, import_react84.useState)([]);
+  const emit = (0, import_react84.useCallback)((type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+      userId
+    };
+    setEvents((prev) => [...prev, event]);
+  }, [userId]);
+  const applyRemote = (0, import_react84.useCallback)((event) => {
+    setEvents((prev) => [...prev, event]);
+  }, []);
+  return { events, emit, applyRemote };
+}
+
+// src/hooks/useShortcuts/useShortcuts.ts
+var import_react85 = require("react");
+function useShortcuts(shortcuts) {
+  (0, import_react85.useEffect)(() => {
+    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
+var import_react86 = require("react");
+function useSortable(options) {
+  const [draggedIndex, setDraggedIndex] = (0, import_react86.useState)(null);
+  const move = (0, import_react86.useCallback)((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
+var import_react87 = require("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] = (0, import_react87.useState)(createGrid);
+  const [selectedCell, setSelectedCell] = (0, import_react87.useState)(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
+var import_react88 = require("react");
+function useTable(options) {
+  const [sortConfig, setSortConfig] = (0, import_react88.useState)(
+    options.initialSort || null
+  );
+  const requestSort = (key) => {
+    let direction = "asc";
+    if (sortConfig && sortConfig.key === key && sortConfig.direction === "asc") {
+      direction = "desc";
+    }
+    setSortConfig({ key, direction });
+  };
+  const sortedData = (0, import_react88.useMemo)(() => {
+    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
+var import_react89 = require("react");
+function useWebRTC(options = {}) {
+  const [connectionState, setConnectionState] = (0, import_react89.useState)("new");
+  const [signalingState, setSignalingState] = (0, import_react89.useState)("stable");
+  const pcRef = (0, import_react89.useRef)(null);
+  (0, import_react89.useEffect)(() => {
+    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
+var import_react90 = require("react");
+function useWebSocket(url, options = {}) {
+  const {
+    reconnect = true,
+    reconnectAttempts = 5,
+    reconnectInterval = 3e3
+  } = options;
+  const [isConnected, setIsConnected] = (0, import_react90.useState)(false);
+  const [lastMessage, setLastMessage] = (0, import_react90.useState)(null);
+  const wsRef = (0, import_react90.useRef)(null);
+  const reconnectCountRef = (0, import_react90.useRef)(0);
+  const reconnectTimerRef = (0, import_react90.useRef)();
+  const connect = (0, import_react90.useCallback)(() => {
+    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]);
+  (0, import_react90.useEffect)(() => {
+    connect();
+    return () => {
+      if (reconnectTimerRef.current) clearTimeout(reconnectTimerRef.current);
+      wsRef.current?.close();
+    };
+  }, [connect]);
+  const send = (0, import_react90.useCallback)((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
+var import_react91 = require("react");
+function useCountdown({
+  countStart,
+  intervalMs = 1e3,
+  isIncrement = false,
+  countStop = 0
+}) {
+  const [count, setCount] = (0, import_react91.useState)(countStart);
+  const [isRunning, setIsRunning] = (0, import_react91.useState)(false);
+  const intervalRef = (0, import_react91.useRef)(null);
+  const startCountdown = (0, import_react91.useCallback)(() => setIsRunning(true), []);
+  const stopCountdown = (0, import_react91.useCallback)(() => setIsRunning(false), []);
+  const resetCountdown = (0, import_react91.useCallback)(() => {
+    setIsRunning(false);
+    setCount(countStart);
+  }, [countStart]);
+  (0, import_react91.useEffect)(() => {
+    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
+var import_react92 = require("react");
+function useDebounceCallback(func, wait = 0, options = {}) {
+  const funcRef = (0, import_react92.useRef)(func);
+  const timeoutRef = (0, import_react92.useRef)();
+  (0, import_react92.useEffect)(() => {
+    funcRef.current = func;
+  }, [func]);
+  const debounced = (0, import_react92.useMemo)(() => {
+    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
+var import_react93 = require("react");
+function useIsClient() {
+  const [isClient, setIsClient] = (0, import_react93.useState)(false);
+  (0, import_react93.useEffect)(() => {
+    setIsClient(true);
+  }, []);
+  return isClient;
+}
+
+// src/hooks/useList/useList.ts
+var import_react94 = require("react");
+function useList(initialList = []) {
+  const [list, setList] = (0, import_react94.useState)(initialList);
+  const actions = {
+    set: (0, import_react94.useCallback)((l) => setList(l), []),
+    push: (0, import_react94.useCallback)((element) => setList((l) => [...l, element]), []),
+    updateAt: (0, import_react94.useCallback)(
+      (index, element) => setList((l) => {
+        const m = [...l];
+        m[index] = element;
+        return m;
+      }),
+      []
+    ),
+    insertAt: (0, import_react94.useCallback)(
+      (index, element) => setList((l) => {
+        const m = [...l];
+        m.splice(index, 0, element);
+        return m;
+      }),
+      []
+    ),
+    update: (0, import_react94.useCallback)(
+      (predicate, newElement) => setList((l) => l.map((item) => predicate(item, newElement) ? newElement : item)),
+      []
+    ),
+    removeAt: (0, import_react94.useCallback)(
+      (index) => setList((l) => {
+        const m = [...l];
+        m.splice(index, 1);
+        return m;
+      }),
+      []
+    ),
+    clear: (0, import_react94.useCallback)(() => setList([]), []),
+    reset: (0, import_react94.useCallback)(() => setList(initialList), [initialList])
+  };
+  return [list, actions];
+}
+
+// src/hooks/useMap/useMap.ts
+var import_react95 = require("react");
+function useMap(initialState = /* @__PURE__ */ new Map()) {
+  const [map, setMap] = (0, import_react95.useState)(new Map(initialState));
+  const actions = {
+    set: (0, import_react95.useCallback)((key, value) => {
+      setMap((prev) => {
+        const copy = new Map(prev);
+        copy.set(key, value);
+        return copy;
+      });
+    }, []),
+    setAll: (0, import_react95.useCallback)((entries) => {
+      setMap(new Map(entries));
+    }, []),
+    remove: (0, import_react95.useCallback)((key) => {
+      setMap((prev) => {
+        const copy = new Map(prev);
+        copy.delete(key);
+        return copy;
+      });
+    }, []),
+    reset: (0, import_react95.useCallback)(() => {
+      setMap(new Map(initialState));
+    }, [initialState])
+  };
+  return [map, actions];
+}
+
+// src/hooks/useQueue/useQueue.ts
+var import_react96 = require("react");
+function useQueue(initialValue = []) {
+  const [queue, setQueue] = (0, import_react96.useState)(initialValue);
+  const add = (0, import_react96.useCallback)((element) => {
+    setQueue((q) => [...q, element]);
+  }, []);
+  const remove = (0, import_react96.useCallback)(() => {
+    let removedElement;
+    setQueue((q) => {
+      const [first, ...rest] = q;
+      removedElement = first;
+      return rest;
+    });
+    return removedElement;
+  }, []);
+  const clear = (0, import_react96.useCallback)(() => {
+    setQueue([]);
+  }, []);
+  return {
+    queue,
+    add,
+    remove,
+    clear,
+    first: queue[0],
+    last: queue[queue.length - 1],
+    size: queue.length
+  };
+}
+
+// src/hooks/useScreen/useScreen.ts
+var import_react97 = require("react");
+function useScreen() {
+  const getScreen = () => {
+    if (typeof window !== "undefined" && window.screen) {
+      return window.screen;
+    }
+    return void 0;
+  };
+  const [screen, setScreen] = (0, import_react97.useState)(getScreen());
+  const handleResize = () => {
+    setScreen(getScreen());
+  };
+  useEvent("resize", handleResize);
+  (0, import_react97.useEffect)(() => {
+    setScreen(getScreen());
+  }, []);
+  return screen;
+}
+
+// src/hooks/useSet/useSet.ts
+var import_react98 = require("react");
+function useSet(initialSet = /* @__PURE__ */ new Set()) {
+  const [set, setSet] = (0, import_react98.useState)(initialSet);
+  const actions = {
+    add: (0, import_react98.useCallback)((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        copy.add(key);
+        return copy;
+      });
+    }, []),
+    remove: (0, import_react98.useCallback)((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        copy.delete(key);
+        return copy;
+      });
+    }, []),
+    toggle: (0, import_react98.useCallback)((key) => {
+      setSet((prev) => {
+        const copy = new Set(prev);
+        if (copy.has(key)) {
+          copy.delete(key);
+        } else {
+          copy.add(key);
+        }
+        return copy;
+      });
+    }, []),
+    reset: (0, import_react98.useCallback)(() => {
+      setSet(initialSet);
+    }, [initialSet]),
+    clear: (0, import_react98.useCallback)(() => {
+      setSet(/* @__PURE__ */ new Set());
+    }, [])
+  };
+  return [set, actions];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  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.js.map