@exyconn/common 1.0.0 → 2.0.0

package/dist/client/index.js

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