sse-hooks 1.2.0 → 2.0.0

package/dist/index.mjs

@@ -1,2410 +0,0 @@
-import React, { useState, useRef, useEffect, useMemo, useCallback, useLayoutEffect } from 'react';
-import debounce from 'lodash.debounce';
-
-const extend = Object.assign;
-const isArray = Array.isArray;
-const isMap = (val) => val instanceof Map;
-const isFunction = (val) => typeof val === "function";
-const isSymbol = (val) => typeof val === "symbol";
-const isObject = (val) => val !== null && typeof val === "object";
-const isIntegerKey = (key) => typeof key === "string" && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
-const __DEV__ = process.env.NODE_ENV !== "production";
-
-let activeSub;
-let shouldTrack = true;
-function getActiveSub() {
-  return activeSub;
-}
-function setActiveSub(sub) {
-  activeSub = sub;
-}
-function startBatch() {
-}
-function endBatch() {
-}
-function batch(sub, isComputed = false) {
-}
-
-var EffectFlags = /* @__PURE__ */ ((EffectFlags2) => {
-  EffectFlags2[EffectFlags2["ACTIVE"] = 1] = "ACTIVE";
-  EffectFlags2[EffectFlags2["RUNNING"] = 2] = "RUNNING";
-  EffectFlags2[EffectFlags2["TRACKING"] = 4] = "TRACKING";
-  EffectFlags2[EffectFlags2["NOTIFIED"] = 8] = "NOTIFIED";
-  EffectFlags2[EffectFlags2["DIRTY"] = 16] = "DIRTY";
-  EffectFlags2[EffectFlags2["ALLOW_RECURSE"] = 32] = "ALLOW_RECURSE";
-  EffectFlags2[EffectFlags2["PAUSED"] = 64] = "PAUSED";
-  return EffectFlags2;
-})(EffectFlags || {});
-var TrackOpTypes = /* @__PURE__ */ ((TrackOpTypes2) => {
-  TrackOpTypes2["GET"] = "get";
-  TrackOpTypes2["HAS"] = "has";
-  TrackOpTypes2["ITERATE"] = "iterate";
-  return TrackOpTypes2;
-})(TrackOpTypes || {});
-var TriggerOpTypes = /* @__PURE__ */ ((TriggerOpTypes2) => {
-  TriggerOpTypes2["SET"] = "set";
-  TriggerOpTypes2["ADD"] = "add";
-  TriggerOpTypes2["DELETE"] = "delete";
-  TriggerOpTypes2["CLEAR"] = "clear";
-  return TriggerOpTypes2;
-})(TriggerOpTypes || {});
-const ReactiveFlags = {
-  IS_REF: "__v_isRef",
-  IS_READONLY: "__v_isReadonly",
-  SKIP: "__v_skip"
-};
-
-let globalVersion = 0;
-class Link {
-  constructor(sub, dep) {
-    this.sub = sub;
-    this.dep = dep;
-    this.version = dep.version;
-  }
-  version;
-  nextDep;
-  prevDep;
-  nextSub;
-  prevSub;
-  prevActiveLink;
-}
-class Dep {
-  constructor(computed) {
-    this.computed = computed;
-    if (__DEV__) {
-      this.subsHead = void 0;
-    }
-  }
-  version = 0;
-  activeLink = void 0;
-  subs = void 0;
-  subsHead;
-  map = void 0;
-  key = void 0;
-  sc = 0;
-  track(debugInfo) {
-    const activeSub = getActiveSub();
-    if (!activeSub || !shouldTrack || activeSub === this.computed) {
-      return;
-    }
-    let link = this.activeLink;
-    if (link === void 0 || link.sub !== activeSub) {
-      link = this.activeLink = new Link(activeSub, this);
-      if (!activeSub.deps) {
-        activeSub.deps = activeSub.depsTail = link;
-      } else {
-        link.prevDep = activeSub.depsTail;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-      }
-      addSub(link);
-    } else if (link.version === -1) {
-      link.version = this.version;
-      if (link.nextDep) {
-        const next = link.nextDep;
-        next.prevDep = link.prevDep;
-        if (link.prevDep) link.prevDep.nextDep = next;
-        link.prevDep = activeSub.depsTail;
-        link.nextDep = void 0;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-        if (activeSub.deps === link) activeSub.deps = next;
-      }
-    }
-    if (__DEV__ && activeSub.onTrack) {
-      activeSub.onTrack(extend({ effect: activeSub }, debugInfo));
-    }
-    return link;
-  }
-  trigger(debugInfo) {
-    this.version++;
-    globalVersion++;
-    this.notify(debugInfo);
-  }
-  notify(debugInfo) {
-    try {
-      for (let link = this.subs; link; link = link.prevSub) {
-        if (link.sub.notify()) {
-          link.sub.dep.notify();
-        }
-      }
-    } finally {
-    }
-  }
-}
-function addSub(link) {
-  link.dep.sc++;
-  if (link.sub.flags & EffectFlags.TRACKING) {
-    const computed = link.dep.computed;
-    if (computed && !link.dep.subs) {
-      computed.flags |= EffectFlags.TRACKING | EffectFlags.DIRTY;
-      for (let l = computed.deps; l; l = l.nextDep) {
-        addSub(l);
-      }
-    }
-    const currentTail = link.dep.subs;
-    if (currentTail !== link) {
-      link.prevSub = currentTail;
-      if (currentTail) currentTail.nextSub = link;
-    }
-    link.dep.subs = link;
-  }
-}
-const targetMap = /* @__PURE__ */ new WeakMap();
-function track(target, type, key) {
-  const activeSub = getActiveSub();
-  if (activeSub) {
-    let depsMap = targetMap.get(target);
-    if (!depsMap) {
-      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
-    }
-    let dep = depsMap.get(key);
-    if (!dep) {
-      depsMap.set(key, dep = new Dep());
-      dep.map = depsMap;
-      dep.key = key;
-    }
-    dep.track({ target, type, key });
-  }
-}
-
-function refreshComputed(computed2) {
-  if (computed2.flags & EffectFlags.DIRTY) {
-    const prevSub = getActiveSub();
-    setActiveSub(computed2);
-    try {
-      for (let link = computed2.deps; link; link = link.nextDep) {
-        link.version = -1;
-        link.prevActiveLink = link.prevDep;
-      }
-      const value = computed2.fn(computed2._value);
-      computed2._value = value;
-      computed2.flags &= ~EffectFlags.DIRTY;
-    } finally {
-      setActiveSub(prevSub);
-    }
-  }
-}
-class ComputedRefImpl {
-  constructor(fn, setter, isSSR) {
-    this.fn = fn;
-    this.setter = setter;
-    this.isSSR = isSSR;
-  }
-  _value = void 0;
-  dep = new Dep(this);
-  __v_isRef = true;
-  deps = void 0;
-  depsTail = void 0;
-  flags = EffectFlags.DIRTY;
-  globalVersion = globalVersion - 1;
-  isSSR;
-  effect = this;
-  onTrack;
-  onTrigger;
-  notify() {
-    this.flags |= EffectFlags.DIRTY;
-    return true;
-  }
-  get value() {
-    const link = __DEV__ ? this.dep.track({ target: this, type: TrackOpTypes.GET, key: "value" }) : this.dep.track();
-    refreshComputed(this);
-    if (link) link.version = this.dep.version;
-    return this._value;
-  }
-  set value(newValue) {
-    if (this.setter) {
-      this.setter(newValue);
-    } else {
-      console.warn("Write operation failed: computed value is readonly");
-    }
-  }
-}
-function computed(getterOrOptions, debugOptions, isSSR = false) {
-  let getter;
-  let setter;
-  if (isFunction(getterOrOptions)) {
-    getter = getterOrOptions;
-  } else {
-    getter = getterOrOptions.get;
-    setter = getterOrOptions.set;
-  }
-  const cRef = new ComputedRefImpl(getter, setter, isSSR);
-  return cRef;
-}
-
-class ReactSubscriber {
-  constructor(triggerUpdate) {
-    this.triggerUpdate = triggerUpdate;
-  }
-  deps;
-  depsTail;
-  flags = EffectFlags.TRACKING;
-  notify() {
-    this.triggerUpdate();
-  }
-}
-function useReactive(refObj) {
-  const [, setTick] = useState(0);
-  const forceUpdate = () => setTick((t) => t + 1);
-  const subscriberRef = useRef(null);
-  if (!subscriberRef.current) {
-    subscriberRef.current = new ReactSubscriber(forceUpdate);
-  }
-  const sub = subscriberRef.current;
-  const prevSub = getActiveSub();
-  setActiveSub(sub);
-  const value = refObj.value;
-  setActiveSub(prevSub);
-  useEffect(() => {
-    return () => {
-    };
-  }, []);
-  return value;
-}
-function useComputed(getter, deps = []) {
-  const cRef = useMemo(() => computed(getter), deps);
-  return useReactive(cRef);
-}
-
-class RefImpl {
-  _value;
-  dep;
-  __v_isRef = true;
-  constructor(value) {
-    this._value = value;
-    this.dep = new Dep();
-  }
-  get value() {
-    this.dep.track({ target: this, type: TrackOpTypes.GET, key: "value" });
-    return this._value;
-  }
-  set value(newVal) {
-    if (newVal !== this._value) {
-      this._value = newVal;
-      this.dep.trigger({
-        target: this,
-        type: TriggerOpTypes.SET,
-        key: "value",
-        newValue: newVal
-      });
-    }
-  }
-}
-function ref(value) {
-  return new RefImpl(value);
-}
-
-function withDefaults(props, defaults) {
-  const merged = useMemo(() => {
-    const result = { ...props };
-    for (const key in defaults) {
-      if (!(key in result) || result[key] === void 0) {
-        const def = defaults[key];
-        if (typeof def === "function") {
-          result[key] = def(result);
-        } else {
-          result[key] = def;
-        }
-      }
-    }
-    return result;
-  }, [props, defaults]);
-  return merged;
-}
-
-const useAudioRecorder = (options = {}) => {
-  const { audioBitsPerSecond, mimeType, timeslice, enableAnalysis, fftSize } = withDefaults(options, {
-    audioBitsPerSecond: 128e3,
-    mimeType: "audio/webm",
-    enableAnalysis: false,
-    fftSize: 2048
-  });
-  const [isRecording, setIsRecording] = useState(false);
-  const [isPaused, setIsPaused] = useState(false);
-  const [stream, setStream] = useState(null);
-  const [mediaRecorder, setMediaRecorder] = useState(
-    null
-  );
-  const [audioBlob, setAudioBlob] = useState(null);
-  const [audioUrl, setAudioUrl] = useState(null);
-  const [duration, setDuration] = useState(0);
-  const [error, setError] = useState(null);
-  const [analysisData, setAnalysisData] = useState(
-    null
-  );
-  const chunksRef = useRef([]);
-  const startTimeRef = useRef(0);
-  const pausedTimeRef = useRef(0);
-  const intervalRef = useRef(null);
-  const audioContextRef = useRef(null);
-  const analyserRef = useRef(null);
-  const sourceRef = useRef(null);
-  const animationFrameRef = useRef(null);
-  const isSupported = typeof navigator !== "undefined" && !!navigator.mediaDevices && !!navigator.mediaDevices.getUserMedia && !!window.MediaRecorder;
-  const updateDuration = useCallback(() => {
-    if (startTimeRef.current) {
-      const elapsed = Date.now() - startTimeRef.current - pausedTimeRef.current;
-      setDuration(Math.floor(elapsed / 1e3));
-    }
-  }, []);
-  const analyzeAudio = useCallback(() => {
-    if (!analyserRef.current || !enableAnalysis) return;
-    const frequencyData = new Uint8Array(analyserRef.current.frequencyBinCount);
-    const timeData = new Uint8Array(analyserRef.current.fftSize);
-    analyserRef.current.getByteFrequencyData(frequencyData);
-    analyserRef.current.getByteTimeDomainData(timeData);
-    let sum = 0;
-    for (let i = 0; i < timeData.length; i++) {
-      const sample = ((timeData[i] ?? 0) - 128) / 128;
-      sum += sample * sample;
-    }
-    const volume = Math.sqrt(sum / timeData.length);
-    setAnalysisData({
-      frequencyData: frequencyData.slice(),
-      timeData: timeData.slice(),
-      volume
-    });
-    if (isRecording && !isPaused) {
-      animationFrameRef.current = requestAnimationFrame(analyzeAudio);
-    }
-  }, [isRecording, isPaused, enableAnalysis]);
-  const setupAudioAnalysis = useCallback(
-    (mediaStream) => {
-      if (!enableAnalysis) return;
-      try {
-        audioContextRef.current = new (window.AudioContext || window.webkitAudioContext)();
-        analyserRef.current = audioContextRef.current.createAnalyser();
-        sourceRef.current = audioContextRef.current.createMediaStreamSource(mediaStream);
-        analyserRef.current.fftSize = fftSize;
-        analyserRef.current.smoothingTimeConstant = 0.8;
-        sourceRef.current.connect(analyserRef.current);
-        analyzeAudio();
-      } catch (err) {
-        console.warn("Failed to setup audio analysis:", err);
-      }
-    },
-    [enableAnalysis, fftSize, analyzeAudio]
-  );
-  const startRecording = useCallback(async () => {
-    if (!isSupported) {
-      setError("Audio recording is not supported in this browser");
-      return;
-    }
-    try {
-      setError(null);
-      const mediaStream = await navigator.mediaDevices.getUserMedia({
-        audio: {
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true
-        }
-      });
-      setStream(mediaStream);
-      setupAudioAnalysis(mediaStream);
-      const recorder = new MediaRecorder(mediaStream, {
-        audioBitsPerSecond,
-        mimeType: MediaRecorder.isTypeSupported(mimeType) ? mimeType : "audio/webm"
-      });
-      chunksRef.current = [];
-      recorder.ondataavailable = (event) => {
-        if (event.data.size > 0) {
-          chunksRef.current.push(event.data);
-        }
-      };
-      recorder.onstop = () => {
-        const blob = new Blob(chunksRef.current, { type: recorder.mimeType });
-        setAudioBlob(blob);
-        setAudioUrl(URL.createObjectURL(blob));
-        setIsRecording(false);
-        setIsPaused(false);
-        if (intervalRef.current) {
-          clearInterval(intervalRef.current);
-          intervalRef.current = null;
-        }
-        if (animationFrameRef.current) {
-          cancelAnimationFrame(animationFrameRef.current);
-          animationFrameRef.current = null;
-        }
-      };
-      recorder.onpause = () => {
-        setIsPaused(true);
-        pausedTimeRef.current += Date.now() - startTimeRef.current;
-        if (animationFrameRef.current) {
-          cancelAnimationFrame(animationFrameRef.current);
-          animationFrameRef.current = null;
-        }
-      };
-      recorder.onresume = () => {
-        setIsPaused(false);
-        startTimeRef.current = Date.now();
-        if (enableAnalysis) {
-          analyzeAudio();
-        }
-      };
-      recorder.onerror = (event) => {
-        setError(`Recording error: ${event.error?.message || "Unknown error"}`);
-        setIsRecording(false);
-        setIsPaused(false);
-      };
-      setMediaRecorder(recorder);
-      recorder.start(timeslice);
-      setIsRecording(true);
-      startTimeRef.current = Date.now();
-      pausedTimeRef.current = 0;
-      setDuration(0);
-      intervalRef.current = setInterval(updateDuration, 1e3);
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Failed to start recording";
-      setError(errorMessage);
-    }
-  }, [
-    isSupported,
-    audioBitsPerSecond,
-    mimeType,
-    timeslice,
-    setupAudioAnalysis,
-    updateDuration,
-    enableAnalysis,
-    analyzeAudio
-  ]);
-  const stopRecording = useCallback(() => {
-    if (mediaRecorder && mediaRecorder.state !== "inactive") {
-      mediaRecorder.stop();
-    }
-    if (stream) {
-      stream.getTracks().forEach((track) => track.stop());
-      setStream(null);
-    }
-    if (audioContextRef.current) {
-      audioContextRef.current.close();
-      audioContextRef.current = null;
-    }
-  }, [mediaRecorder, stream]);
-  const pauseRecording = useCallback(() => {
-    if (mediaRecorder && mediaRecorder.state === "recording") {
-      mediaRecorder.pause();
-    }
-  }, [mediaRecorder]);
-  const resumeRecording = useCallback(() => {
-    if (mediaRecorder && mediaRecorder.state === "paused") {
-      mediaRecorder.resume();
-    }
-  }, [mediaRecorder]);
-  const clearRecording = useCallback(() => {
-    if (audioUrl) {
-      URL.revokeObjectURL(audioUrl);
-    }
-    setAudioBlob(null);
-    setAudioUrl(null);
-    setDuration(0);
-    setAnalysisData(null);
-    setError(null);
-  }, [audioUrl]);
-  const downloadRecording = useCallback(
-    (filename = "recording.webm") => {
-      if (!audioUrl) return;
-      const link = document.createElement("a");
-      link.href = audioUrl;
-      link.download = filename;
-      document.body.appendChild(link);
-      link.click();
-      document.body.removeChild(link);
-    },
-    [audioUrl]
-  );
-  useEffect(() => {
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-      }
-      if (animationFrameRef.current) {
-        cancelAnimationFrame(animationFrameRef.current);
-      }
-      if (stream) {
-        stream.getTracks().forEach((track) => track.stop());
-      }
-      if (audioContextRef.current) {
-        audioContextRef.current.close();
-      }
-      if (audioUrl) {
-        URL.revokeObjectURL(audioUrl);
-      }
-    };
-  }, [stream, audioUrl]);
-  return {
-    isSupported,
-    isRecording,
-    isPaused,
-    stream,
-    mediaRecorder,
-    audioBlob,
-    audioUrl,
-    duration,
-    error,
-    analysisData,
-    startRecording,
-    stopRecording,
-    pauseRecording,
-    resumeRecording,
-    clearRecording,
-    downloadRecording
-  };
-};
-
-function on(obj, ...args) {
-  if (obj && obj.addEventListener) {
-    obj.addEventListener(
-      ...args
-    );
-  }
-}
-function off(obj, ...args) {
-  if (obj && obj.removeEventListener) {
-    obj.removeEventListener(
-      ...args
-    );
-  }
-}
-const isNavigator = typeof navigator !== "undefined";
-
-const { valueOf, toString } = Object.prototype;
-const isEqual = (a, b) => {
-  const visited = /* @__PURE__ */ new WeakMap();
-  const inner = (a2, b2) => {
-    if (a2 === b2) {
-      return true;
-    }
-    if (typeof a2 !== "object" || typeof b2 !== "object" || !a2 || !b2) {
-      return a2 !== a2 && b2 !== b2;
-    }
-    if (Object.getPrototypeOf(a2) !== Object.getPrototypeOf(b2)) {
-      return false;
-    }
-    const { constructor } = a2;
-    if (constructor === Date) {
-      return a2.getTime() === b2.getTime();
-    }
-    if (constructor === RegExp) {
-      return a2.source === b2.source && a2.flags === b2.flags;
-    }
-    if (constructor === Set) {
-      if (a2.size !== b2.size) {
-        return false;
-      }
-      for (const value of a2) {
-        if (!b2.has(value)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (constructor === ArrayBuffer) {
-      a2 = new DataView(a2);
-      b2 = new DataView(b2);
-    }
-    if (constructor === DataView || ArrayBuffer.isView(a2)) {
-      if (constructor !== DataView) {
-        a2 = new DataView(a2.buffer);
-        b2 = new DataView(b2.buffer);
-      }
-      if (a2.byteLength !== b2.byteLength) return false;
-      for (let i = a2.byteLength; i-- !== 0; ) {
-        if (a2.getUint8(i) !== b2.getUint8(i)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (visited.has(a2) && visited.get(a2) === b2) {
-      return true;
-    }
-    visited.set(a2, b2);
-    if (constructor === Array) {
-      if (a2.length !== b2.length) {
-        return false;
-      }
-      for (let i = a2.length; i-- !== 0; ) {
-        if (!inner(a2[i], b2[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (constructor === Map) {
-      if (a2.size !== b2.size) {
-        return false;
-      }
-      for (const entry of a2) {
-        if (!b2.has(entry[0]) || !inner(entry[1], b2.get(entry[0]))) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (a2.valueOf !== valueOf && typeof a2.valueOf === "function" && typeof b2.valueOf === "function") {
-      return a2.valueOf() === b2.valueOf();
-    }
-    if (a2.toString !== toString && typeof a2.toString === "function" && typeof b2.toString === "function") {
-      return a2.toString() === b2.toString();
-    }
-    const aKeys = Object.keys(a2);
-    let key;
-    for (let l = aKeys.length; l-- !== 0; ) {
-      key = aKeys[l];
-      if (!Object.hasOwn(b2, key) || !inner(a2[key], b2[key])) {
-        return false;
-      }
-    }
-    return Object.keys(b2).length === aKeys.length;
-  };
-  return inner(a, b);
-};
-
-const nav = isNavigator ? navigator : void 0;
-const isBatteryApiSupported = nav && typeof nav.getBattery === "function";
-function useBatteryMock() {
-  return { isSupported: false };
-}
-function useBattery() {
-  const [state, setState] = useState({
-    isSupported: true,
-    fetched: false
-  });
-  useEffect(() => {
-    let isMounted = true;
-    let battery = null;
-    const handleChange = () => {
-      if (!isMounted || !battery) {
-        return;
-      }
-      const newState = {
-        isSupported: true,
-        fetched: true,
-        level: battery.level,
-        charging: battery.charging,
-        dischargingTime: battery.dischargingTime,
-        chargingTime: battery.chargingTime
-      };
-      !isEqual(state, newState) && setState(newState);
-    };
-    nav.getBattery().then((bat) => {
-      if (!isMounted) {
-        return;
-      }
-      battery = bat;
-      on(battery, "chargingchange", handleChange);
-      on(battery, "chargingtimechange", handleChange);
-      on(battery, "dischargingtimechange", handleChange);
-      on(battery, "levelchange", handleChange);
-      handleChange();
-    });
-    return () => {
-      isMounted = false;
-      if (battery) {
-        off(battery, "chargingchange", handleChange);
-        off(battery, "chargingtimechange", handleChange);
-        off(battery, "dischargingtimechange", handleChange);
-        off(battery, "levelchange", handleChange);
-      }
-    };
-  }, []);
-  return state;
-}
-const useBatteryHook = isBatteryApiSupported ? useBattery : useBatteryMock;
-
-function useBoolean(defaultValue = false) {
-  if (typeof defaultValue !== "boolean") {
-    throw new Error("defaultValue must be `true` or `false`");
-  }
-  const [value, setValue] = useState(defaultValue);
-  const setTrue = useCallback(() => {
-    setValue(true);
-  }, []);
-  const setFalse = useCallback(() => {
-    setValue(false);
-  }, []);
-  const toggle = useCallback(() => {
-    setValue((x) => !x);
-  }, []);
-  return { value, setValue, setTrue, setFalse, toggle };
-}
-
-const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
-
-function useEventListener(eventName, handler, element, options) {
-  const savedHandler = useRef(handler);
-  useIsomorphicLayoutEffect(() => {
-    savedHandler.current = handler;
-  }, [handler]);
-  useEffect(() => {
-    const targetElement = element?.current ?? window;
-    if (!(targetElement && targetElement.addEventListener)) return;
-    const listener = (event) => {
-      savedHandler.current(event);
-    };
-    targetElement.addEventListener(eventName, listener, options);
-    return () => {
-      targetElement.removeEventListener(eventName, listener, options);
-    };
-  }, [eventName, element, options]);
-}
-
-function useClickAnyWhere(handler) {
-  useEventListener("click", (event) => {
-    handler(event);
-  });
-}
-
-function useForkRef(...refs) {
-  const cleanupRef = React.useRef(void 0);
-  const refEffect = React.useCallback((instance) => {
-    const cleanups = refs.map((ref) => {
-      if (ref == null) {
-        return null;
-      }
-      if (typeof ref === "function") {
-        const refCallback = ref;
-        const refCleanup = refCallback(instance);
-        return typeof refCleanup === "function" ? refCleanup : () => {
-          refCallback(null);
-        };
-      }
-      ref.current = instance;
-      return () => {
-        ref.current = null;
-      };
-    });
-    return () => {
-      cleanups.forEach((refCleanup) => refCleanup?.());
-    };
-  }, refs);
-  return React.useMemo(() => {
-    if (refs.every((ref) => ref == null)) {
-      return null;
-    }
-    return (value) => {
-      if (cleanupRef.current) {
-        cleanupRef.current();
-        cleanupRef.current = void 0;
-      }
-      if (value != null) {
-        cleanupRef.current = refEffect(value);
-      }
-    };
-  }, refs);
-}
-
-function ownerDocument(node) {
-  return node && node.ownerDocument || document;
-}
-
-function useEventCallback(fn) {
-  const ref = useRef(() => {
-    throw new Error("Cannot call an event handler while rendering.");
-  });
-  useIsomorphicLayoutEffect(() => {
-    ref.current = fn;
-  }, [fn]);
-  return useCallback((...args) => ref.current?.(...args), [ref]);
-}
-
-function mapEventPropToEvent(eventProp) {
-  return eventProp.substring(2).toLowerCase();
-}
-function clickedRootScrollbar(event, doc) {
-  return doc.documentElement.clientWidth < event.clientX || doc.documentElement.clientHeight < event.clientY;
-}
-function useClickAway(onClickAway, options = {}) {
-  const {
-    disableReactTree = false,
-    mouseEvent = "onClick",
-    touchEvent = "onTouchEnd",
-    ref: externalRef
-  } = options;
-  const internalRef = React.useRef(null);
-  const handleRef = useForkRef(externalRef, internalRef);
-  const movedRef = React.useRef(false);
-  const activatedRef = React.useRef(false);
-  const syntheticEventRef = React.useRef(false);
-  React.useEffect(() => {
-    const timer = setTimeout(() => {
-      activatedRef.current = true;
-    }, 0);
-    return () => {
-      activatedRef.current = false;
-      clearTimeout(timer);
-    };
-  }, []);
-  const handleClickAway = useEventCallback((event) => {
-    const insideReactTree = syntheticEventRef.current;
-    syntheticEventRef.current = false;
-    const doc = ownerDocument(internalRef.current);
-    if (!activatedRef.current || !internalRef.current || "clientX" in event && clickedRootScrollbar(event, doc)) {
-      return;
-    }
-    if (movedRef.current) {
-      movedRef.current = false;
-      return;
-    }
-    let insideDOM;
-    if (event.composedPath) {
-      insideDOM = event.composedPath().includes(internalRef.current);
-    } else {
-      insideDOM = !doc.documentElement.contains(
-        // @ts-expect-error returns `false` as intended when not dispatched from a Node
-        event.target
-      ) || internalRef.current.contains(
-        // @ts-expect-error returns `false` as intended when not dispatched from a Node
-        event.target
-      );
-    }
-    if (!insideDOM && (disableReactTree || !insideReactTree)) {
-      onClickAway(event);
-    }
-  });
-  const createHandleSynthetic = (event) => {
-    syntheticEventRef.current = true;
-  };
-  React.useEffect(() => {
-    if (touchEvent !== false) {
-      const mappedTouchEvent = mapEventPropToEvent(touchEvent);
-      const doc = ownerDocument(internalRef.current);
-      const handleTouchMove = () => {
-        movedRef.current = true;
-      };
-      doc.addEventListener(mappedTouchEvent, handleClickAway);
-      doc.addEventListener("touchmove", handleTouchMove);
-      return () => {
-        doc.removeEventListener(mappedTouchEvent, handleClickAway);
-        doc.removeEventListener("touchmove", handleTouchMove);
-      };
-    }
-    return void 0;
-  }, [handleClickAway, touchEvent]);
-  React.useEffect(() => {
-    if (mouseEvent !== false) {
-      const mappedMouseEvent = mapEventPropToEvent(mouseEvent);
-      const doc = ownerDocument(internalRef.current);
-      doc.addEventListener(mappedMouseEvent, handleClickAway);
-      return () => {
-        doc.removeEventListener(mappedMouseEvent, handleClickAway);
-      };
-    }
-    return void 0;
-  }, [handleClickAway, mouseEvent]);
-  const listenerProps = {};
-  if (mouseEvent !== false) {
-    listenerProps[mouseEvent] = createHandleSynthetic;
-  }
-  if (touchEvent !== false) {
-    listenerProps[touchEvent] = createHandleSynthetic;
-  }
-  return {
-    ref: handleRef,
-    listenerProps
-  };
-}
-
-const IS_SERVER$7 = typeof document === "undefined";
-function parseCookies() {
-  if (IS_SERVER$7) return {};
-  return document.cookie.split("; ").reduce(
-    (acc, part) => {
-      const [k, ...v] = part.split("=");
-      if (k && v) {
-        acc[decodeURIComponent(k.trim())] = decodeURIComponent(v.join("="));
-      }
-      return acc;
-    },
-    {}
-  );
-}
-function buildCookie(key, value, options) {
-  let cookie = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-  if (options.path) cookie += `; path=${options.path}`;
-  if (options.domain) cookie += `; domain=${options.domain}`;
-  if (options.expires) cookie += `; expires=${options.expires.toUTCString()}`;
-  if (options.maxAge) cookie += `; max-age=${options.maxAge}`;
-  if (options.secure) cookie += `; secure`;
-  if (options.sameSite) cookie += `; samesite=${options.sameSite}`;
-  return cookie;
-}
-function useCookie(key, initialValue, options = {}) {
-  const { initializeWithValue = true, prefix = "" } = options;
-  const cookieKey = prefix + key;
-  const serializer = useCallback(
-    (value) => {
-      if (options.serializer) return options.serializer(value);
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = useCallback(
-    (value) => {
-      if (options.deserializer) return options.deserializer(value);
-      if (value === "undefined") return void 0;
-      const fallback = initialValue instanceof Function ? initialValue() : initialValue;
-      try {
-        return JSON.parse(value);
-      } catch {
-        return fallback;
-      }
-    },
-    [options, initialValue]
-  );
-  const readValue = useCallback(() => {
-    const fallback = initialValue instanceof Function ? initialValue() : initialValue;
-    if (IS_SERVER$7) return fallback;
-    const cookies = parseCookies();
-    if (!(cookieKey in cookies)) return fallback;
-    return deserializer(cookies[cookieKey]);
-  }, [cookieKey, deserializer, initialValue]);
-  const [storedValue, setStoredValue] = useState(() => {
-    if (initializeWithValue) return readValue();
-    return initialValue instanceof Function ? initialValue() : initialValue;
-  });
-  const setValue = useEventCallback((value) => {
-    if (IS_SERVER$7) return;
-    try {
-      const newValue = value instanceof Function ? value(readValue()) : value;
-      const serialized = serializer(newValue);
-      document.cookie = buildCookie(cookieKey, serialized, {
-        path: "/",
-        ...options
-      });
-      setStoredValue(newValue);
-      window.dispatchEvent(
-        new CustomEvent("cookie-change", { detail: { key: cookieKey } })
-      );
-    } catch (error) {
-      console.warn(`Error setting cookie "${cookieKey}":`, error);
-    }
-  });
-  const removeValue = useEventCallback(() => {
-    if (IS_SERVER$7) return;
-    const fallback = initialValue instanceof Function ? initialValue() : initialValue;
-    document.cookie = buildCookie(cookieKey, "", {
-      path: "/",
-      ...options,
-      expires: /* @__PURE__ */ new Date(0)
-    });
-    setStoredValue(fallback);
-    window.dispatchEvent(
-      new CustomEvent("cookie-change", { detail: { key: cookieKey } })
-    );
-  });
-  useEffect(() => {
-    setStoredValue(readValue());
-  }, [cookieKey]);
-  const handleChange = useCallback(
-    (event) => {
-      if ("detail" in event && event.detail?.key !== cookieKey) return;
-      if ("key" in event && event.key !== cookieKey) return;
-      setStoredValue(readValue());
-    },
-    [cookieKey, readValue]
-  );
-  useEventListener("cookie-change", handleChange);
-  useEventListener("visibilitychange", () => {
-    if (document.visibilityState === "visible") {
-      setStoredValue(readValue());
-    }
-  });
-  return [storedValue, setValue, removeValue];
-}
-
-function useCopyToClipboard() {
-  const [copiedText, setCopiedText] = useState(null);
-  const copy = useCallback(async (text) => {
-    if (!navigator?.clipboard) {
-      console.warn("Clipboard not supported");
-      return false;
-    }
-    try {
-      await navigator.clipboard.writeText(text);
-      setCopiedText(text);
-      return true;
-    } catch (error) {
-      console.warn("Copy failed", error);
-      setCopiedText(null);
-      return false;
-    }
-  }, []);
-  return [copiedText, copy];
-}
-
-function useCounter(initialValue) {
-  const [count, setCount] = useState(initialValue ?? 0);
-  const increment = useCallback(() => {
-    setCount((x) => x + 1);
-  }, []);
-  const decrement = useCallback(() => {
-    setCount((x) => x - 1);
-  }, []);
-  const reset = useCallback(() => {
-    setCount(initialValue ?? 0);
-  }, [initialValue]);
-  return {
-    count,
-    increment,
-    decrement,
-    reset,
-    setCount
-  };
-}
-
-function useInterval(callback, delay) {
-  const savedCallback = useRef(callback);
-  useIsomorphicLayoutEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    if (delay === null) {
-      return;
-    }
-    const id = setInterval(() => {
-      savedCallback.current();
-    }, delay);
-    return () => {
-      clearInterval(id);
-    };
-  }, [delay]);
-}
-
-function useCountdown({
-  countStart,
-  countStop = 0,
-  intervalMs = 1e3,
-  isIncrement = false
-}) {
-  const {
-    count,
-    increment,
-    decrement,
-    reset: resetCounter
-  } = useCounter(countStart);
-  const {
-    value: isCountdownRunning,
-    setTrue: startCountdown,
-    setFalse: stopCountdown
-  } = useBoolean(false);
-  const resetCountdown = useCallback(() => {
-    stopCountdown();
-    resetCounter();
-  }, [stopCountdown, resetCounter]);
-  const countdownCallback = useCallback(() => {
-    if (count === countStop) {
-      stopCountdown();
-      return;
-    }
-    if (isIncrement) {
-      increment();
-    } else {
-      decrement();
-    }
-  }, [count, countStop, decrement, increment, isIncrement, stopCountdown]);
-  useInterval(countdownCallback, isCountdownRunning ? intervalMs : null);
-  return [count, { startCountdown, stopCountdown, resetCountdown }];
-}
-
-const IS_SERVER$6 = typeof window === "undefined";
-function useLocalStorage(key, initialValue, options = {}) {
-  const { initializeWithValue = true } = options;
-  const serializer = useCallback(
-    (value) => {
-      if (options.serializer) {
-        return options.serializer(value);
-      }
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = useCallback(
-    (value) => {
-      if (options.deserializer) {
-        return options.deserializer(value);
-      }
-      if (value === "undefined") {
-        return void 0;
-      }
-      const defaultValue = initialValue instanceof Function ? initialValue() : initialValue;
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch (error) {
-        console.error("Error parsing JSON:", error);
-        return defaultValue;
-      }
-      return parsed;
-    },
-    [options, initialValue]
-  );
-  const readValue = useCallback(() => {
-    const initialValueToUse = initialValue instanceof Function ? initialValue() : initialValue;
-    if (IS_SERVER$6) {
-      return initialValueToUse;
-    }
-    try {
-      const raw = window.localStorage.getItem(key);
-      return raw ? deserializer(raw) : initialValueToUse;
-    } catch (error) {
-      console.warn(`Error reading localStorage key \u201C${key}\u201D:`, error);
-      return initialValueToUse;
-    }
-  }, [initialValue, key, deserializer]);
-  const [storedValue, setStoredValue] = useState(() => {
-    if (initializeWithValue) {
-      return readValue();
-    }
-    return initialValue instanceof Function ? initialValue() : initialValue;
-  });
-  const setValue = useEventCallback((value) => {
-    if (IS_SERVER$6) {
-      console.warn(
-        `Tried setting localStorage key \u201C${key}\u201D even though environment is not a client`
-      );
-    }
-    try {
-      const newValue = value instanceof Function ? value(readValue()) : value;
-      window.localStorage.setItem(key, serializer(newValue));
-      setStoredValue(newValue);
-      window.dispatchEvent(new StorageEvent("local-storage", { key }));
-    } catch (error) {
-      console.warn(`Error setting localStorage key \u201C${key}\u201D:`, error);
-    }
-  });
-  const removeValue = useEventCallback(() => {
-    if (IS_SERVER$6) {
-      console.warn(
-        `Tried removing localStorage key \u201C${key}\u201D even though environment is not a client`
-      );
-    }
-    const defaultValue = initialValue instanceof Function ? initialValue() : initialValue;
-    window.localStorage.removeItem(key);
-    setStoredValue(defaultValue);
-    window.dispatchEvent(new StorageEvent("local-storage", { key }));
-  });
-  useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = useCallback(
-    (event) => {
-      if (event.key && event.key !== key) {
-        return;
-      }
-      setStoredValue(readValue());
-    },
-    [key, readValue]
-  );
-  useEventListener("storage", handleStorageChange);
-  useEventListener("local-storage", handleStorageChange);
-  return [storedValue, setValue, removeValue];
-}
-
-const IS_SERVER$5 = typeof window === "undefined";
-function useMediaQuery(query, {
-  defaultValue = false,
-  initializeWithValue = true
-} = {}) {
-  const getMatches = (query2) => {
-    if (IS_SERVER$5) {
-      return defaultValue;
-    }
-    return window.matchMedia(query2).matches;
-  };
-  const [matches, setMatches] = useState(() => {
-    if (initializeWithValue) {
-      return getMatches(query);
-    }
-    return defaultValue;
-  });
-  function handleChange() {
-    setMatches(getMatches(query));
-  }
-  useIsomorphicLayoutEffect(() => {
-    const matchMedia = window.matchMedia(query);
-    handleChange();
-    if (matchMedia.addListener) {
-      matchMedia.addListener(handleChange);
-    } else {
-      matchMedia.addEventListener("change", handleChange);
-    }
-    return () => {
-      if (matchMedia.removeListener) {
-        matchMedia.removeListener(handleChange);
-      } else {
-        matchMedia.removeEventListener("change", handleChange);
-      }
-    };
-  }, [query]);
-  return matches;
-}
-
-const COLOR_SCHEME_QUERY$1 = "(prefers-color-scheme: dark)";
-const LOCAL_STORAGE_KEY$1 = "sse-hooks-dark-mode";
-function useDarkMode(options = {}) {
-  const {
-    defaultValue,
-    localStorageKey = LOCAL_STORAGE_KEY$1,
-    initializeWithValue = true
-  } = options;
-  const isDarkOS = useMediaQuery(COLOR_SCHEME_QUERY$1, {
-    initializeWithValue,
-    defaultValue
-  });
-  const [isDarkMode, setDarkMode] = useLocalStorage(
-    localStorageKey,
-    defaultValue ?? isDarkOS ?? false,
-    { initializeWithValue }
-  );
-  useIsomorphicLayoutEffect(() => {
-    if (isDarkOS !== isDarkMode) {
-      setDarkMode(isDarkOS);
-    }
-  }, [isDarkOS]);
-  return {
-    isDarkMode,
-    toggle: () => {
-      setDarkMode((prev) => !prev);
-    },
-    enable: () => {
-      setDarkMode(true);
-    },
-    disable: () => {
-      setDarkMode(false);
-    },
-    set: (value) => {
-      setDarkMode(value);
-    }
-  };
-}
-
-function useUnmount(func) {
-  const funcRef = useRef(func);
-  funcRef.current = func;
-  useEffect(
-    () => () => {
-      funcRef.current();
-    },
-    []
-  );
-}
-
-function useDebounceCallback(func, delay = 500, options) {
-  const debouncedFunc = useRef();
-  useUnmount(() => {
-    if (debouncedFunc.current) {
-      debouncedFunc.current.cancel();
-    }
-  });
-  const debounced = useMemo(() => {
-    const debouncedFuncInstance = debounce(func, delay, options);
-    const wrappedFunc = (...args) => {
-      return debouncedFuncInstance(...args);
-    };
-    wrappedFunc.cancel = () => {
-      debouncedFuncInstance.cancel();
-    };
-    wrappedFunc.isPending = () => {
-      return !!debouncedFunc.current;
-    };
-    wrappedFunc.flush = () => {
-      return debouncedFuncInstance.flush();
-    };
-    return wrappedFunc;
-  }, [func, delay, options]);
-  useEffect(() => {
-    debouncedFunc.current = debounce(func, delay, options);
-  }, [func, delay, options]);
-  return debounced;
-}
-
-function useDebounceValue(initialValue, delay, options) {
-  const eq = options?.equalityFn ?? ((left, right) => left === right);
-  const unwrappedInitialValue = initialValue instanceof Function ? initialValue() : initialValue;
-  const [debouncedValue, setDebouncedValue] = useState(
-    unwrappedInitialValue
-  );
-  const previousValueRef = useRef(unwrappedInitialValue);
-  const updateDebouncedValue = useDebounceCallback(
-    setDebouncedValue,
-    delay,
-    options
-  );
-  if (!eq(previousValueRef.current, unwrappedInitialValue)) {
-    updateDebouncedValue(unwrappedInitialValue);
-    previousValueRef.current = unwrappedInitialValue;
-  }
-  return [debouncedValue, updateDebouncedValue];
-}
-
-function useDocumentTitle(title, options = {}) {
-  const { preserveTitleOnUnmount = true } = options;
-  const defaultTitle = useRef(null);
-  useIsomorphicLayoutEffect(() => {
-    defaultTitle.current = window.document.title;
-  }, []);
-  useIsomorphicLayoutEffect(() => {
-    window.document.title = title;
-  }, [title]);
-  useUnmount(() => {
-    if (!preserveTitleOnUnmount && defaultTitle.current) {
-      window.document.title = defaultTitle.current;
-    }
-  });
-}
-
-function useFetch(url, options = {}) {
-  const [state, setState] = useState({
-    data: null,
-    loading: false,
-    error: null
-  });
-  const abortControllerRef = useRef(null);
-  const optionsRef = useRef(options);
-  useEffect(() => {
-    optionsRef.current = options;
-  }, [options]);
-  const execute = useCallback(
-    async (executeUrl, executeOptions) => {
-      const targetUrl = executeUrl || url;
-      if (!targetUrl) {
-        const error = new Error("No URL provided");
-        setState((prev) => ({ ...prev, error, loading: false }));
-        optionsRef.current.onError?.(error);
-        throw error;
-      }
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-      abortControllerRef.current = new AbortController();
-      setState((prev) => ({ ...prev, loading: true, error: null }));
-      try {
-        const { immediate, onSuccess, onError, ...fetchOptions } = optionsRef.current;
-        const response = await fetch(targetUrl, {
-          ...fetchOptions,
-          ...executeOptions,
-          signal: abortControllerRef.current.signal
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        let data;
-        const contentType = response.headers.get("content-type");
-        if (contentType && contentType.includes("application/json")) {
-          data = await response.json();
-        } else {
-          data = await response.text();
-        }
-        setState({ data, loading: false, error: null });
-        onSuccess?.(data);
-        return data;
-      } catch (error) {
-        const fetchError = error;
-        if (fetchError.name !== "AbortError") {
-          setState((prev) => ({ ...prev, loading: false, error: fetchError }));
-          optionsRef.current.onError?.(fetchError);
-        }
-        throw fetchError;
-      }
-    },
-    [url]
-  );
-  const abort = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-  }, []);
-  const reset = useCallback(() => {
-    abort();
-    setState({ data: null, loading: false, error: null });
-  }, [abort]);
-  useEffect(() => {
-    if (options.immediate && url) {
-      execute();
-    }
-  }, [url, options.immediate, execute]);
-  useEffect(() => {
-    return () => {
-      abort();
-    };
-  }, [abort]);
-  return {
-    ...state,
-    execute,
-    abort,
-    reset
-  };
-}
-function useGet(url, options = {}) {
-  return useFetch(url, { ...options, method: "GET" });
-}
-function usePost(url, options = {}) {
-  return useFetch(url, { ...options, method: "POST" });
-}
-function usePut(url, options = {}) {
-  return useFetch(url, { ...options, method: "PUT" });
-}
-function useDelete(url, options = {}) {
-  return useFetch(url, { ...options, method: "DELETE" });
-}
-
-function useHover(elementRef) {
-  const [value, setValue] = useState(false);
-  const handleMouseEnter = () => {
-    setValue(true);
-  };
-  const handleMouseLeave = () => {
-    setValue(false);
-  };
-  useEventListener("mouseenter", handleMouseEnter, elementRef);
-  useEventListener("mouseleave", handleMouseLeave, elementRef);
-  return value;
-}
-
-function useIndexedDB(databaseName, storeName, options = {}) {
-  const [data, setData] = useState(null);
-  const [error, setError] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [db, setDb] = useState(null);
-  const { version = 1, onUpgradeNeeded } = options;
-  useEffect(() => {
-    if (typeof window === "undefined") return;
-    const initDB = async () => {
-      try {
-        setLoading(true);
-        setError(null);
-        const request = indexedDB.open(databaseName, version);
-        request.onerror = () => {
-          setError(`Failed to open database: ${request.error?.message}`);
-          setLoading(false);
-        };
-        request.onsuccess = () => {
-          setDb(request.result);
-          setLoading(false);
-        };
-        request.onupgradeneeded = (event) => {
-          const database = request.result;
-          const oldVersion = event.oldVersion;
-          const newVersion = event.newVersion || version;
-          if (!database.objectStoreNames.contains(storeName)) {
-            database.createObjectStore(storeName);
-          }
-          if (onUpgradeNeeded) {
-            onUpgradeNeeded(database, oldVersion, newVersion);
-          }
-        };
-      } catch (err) {
-        setError(`IndexedDB initialization error: ${err}`);
-        setLoading(false);
-      }
-    };
-    initDB();
-    return () => {
-      if (db) {
-        db.close();
-      }
-    };
-  }, [databaseName, storeName, version, onUpgradeNeeded]);
-  const setItem = useCallback(
-    async (key, value) => {
-      if (!db) {
-        throw new Error("Database not initialized");
-      }
-      return new Promise((resolve, reject) => {
-        const transaction = db.transaction([storeName], "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.put(value, key);
-        request.onsuccess = () => {
-          setData(value);
-          resolve();
-        };
-        request.onerror = () => {
-          const errorMsg = `Failed to set item: ${request.error?.message}`;
-          setError(errorMsg);
-          reject(new Error(errorMsg));
-        };
-      });
-    },
-    [db, storeName]
-  );
-  const getItem = useCallback(
-    async (key) => {
-      if (!db) {
-        throw new Error("Database not initialized");
-      }
-      return new Promise((resolve, reject) => {
-        const transaction = db.transaction([storeName], "readonly");
-        const store = transaction.objectStore(storeName);
-        const request = store.get(key);
-        request.onsuccess = () => {
-          const result = request.result || null;
-          setData(result);
-          resolve(result);
-        };
-        request.onerror = () => {
-          const errorMsg = `Failed to get item: ${request.error?.message}`;
-          setError(errorMsg);
-          reject(new Error(errorMsg));
-        };
-      });
-    },
-    [db, storeName]
-  );
-  const removeItem = useCallback(
-    async (key) => {
-      if (!db) {
-        throw new Error("Database not initialized");
-      }
-      return new Promise((resolve, reject) => {
-        const transaction = db.transaction([storeName], "readwrite");
-        const store = transaction.objectStore(storeName);
-        const request = store.delete(key);
-        request.onsuccess = () => {
-          setData(null);
-          resolve();
-        };
-        request.onerror = () => {
-          const errorMsg = `Failed to remove item: ${request.error?.message}`;
-          setError(errorMsg);
-          reject(new Error(errorMsg));
-        };
-      });
-    },
-    [db, storeName]
-  );
-  const clear = useCallback(async () => {
-    if (!db) {
-      throw new Error("Database not initialized");
-    }
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([storeName], "readwrite");
-      const store = transaction.objectStore(storeName);
-      const request = store.clear();
-      request.onsuccess = () => {
-        setData(null);
-        resolve();
-      };
-      request.onerror = () => {
-        const errorMsg = `Failed to clear store: ${request.error?.message}`;
-        setError(errorMsg);
-        reject(new Error(errorMsg));
-      };
-    });
-  }, [db, storeName]);
-  const getAllKeys = useCallback(async () => {
-    if (!db) {
-      throw new Error("Database not initialized");
-    }
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction([storeName], "readonly");
-      const store = transaction.objectStore(storeName);
-      const request = store.getAllKeys();
-      request.onsuccess = () => {
-        resolve(request.result);
-      };
-      request.onerror = () => {
-        const errorMsg = `Failed to get keys: ${request.error?.message}`;
-        setError(errorMsg);
-        reject(new Error(errorMsg));
-      };
-    });
-  }, [db, storeName]);
-  return {
-    data,
-    error,
-    loading,
-    setItem,
-    getItem,
-    removeItem,
-    clear,
-    getAllKeys
-  };
-}
-
-function useIntersectionObserver({
-  threshold = 0,
-  root = null,
-  rootMargin = "0%",
-  freezeOnceVisible = false,
-  initialIsIntersecting = false,
-  onChange
-} = {}) {
-  const [ref, setRef] = useState(null);
-  const [state, setState] = useState(() => ({
-    isIntersecting: initialIsIntersecting,
-    entry: void 0
-  }));
-  const callbackRef = useRef();
-  callbackRef.current = onChange;
-  const frozen = state.entry?.isIntersecting && freezeOnceVisible;
-  useEffect(() => {
-    if (!ref) return;
-    if (!("IntersectionObserver" in window)) return;
-    if (frozen) return;
-    const observer = new IntersectionObserver(
-      (entries) => {
-        const thresholds = Array.isArray(observer.thresholds) ? observer.thresholds : [observer.thresholds];
-        entries.forEach((entry) => {
-          const isIntersecting = entry.isIntersecting && thresholds.some(
-            (threshold2) => entry.intersectionRatio >= threshold2
-          );
-          setState({ isIntersecting, entry });
-          if (callbackRef.current) {
-            callbackRef.current(isIntersecting, entry);
-          }
-        });
-      },
-      { threshold, root, rootMargin }
-    );
-    observer.observe(ref);
-    return () => {
-      observer.disconnect();
-    };
-  }, [
-    ref,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    JSON.stringify(threshold),
-    root,
-    rootMargin,
-    frozen,
-    freezeOnceVisible
-  ]);
-  const prevRef = useRef(null);
-  useEffect(() => {
-    if (!ref && state.entry?.target && !freezeOnceVisible && !frozen && prevRef.current !== state.entry.target) {
-      prevRef.current = state.entry.target;
-      setState({ isIntersecting: initialIsIntersecting, entry: void 0 });
-    }
-  }, [ref, state.entry, freezeOnceVisible, frozen, initialIsIntersecting]);
-  const result = [
-    setRef,
-    !!state.isIntersecting,
-    state.entry
-  ];
-  result.ref = result[0];
-  result.isIntersecting = result[1];
-  result.entry = result[2];
-  return result;
-}
-
-function useIsClient() {
-  const [isClient, setClient] = useState(false);
-  useEffect(() => {
-    setClient(true);
-  }, []);
-  return isClient;
-}
-
-function useIsMounted() {
-  const isMounted = useRef(false);
-  useEffect(() => {
-    isMounted.current = true;
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  return useCallback(() => isMounted.current, []);
-}
-
-function useMap(initialState = /* @__PURE__ */ new Map()) {
-  const [map, setMap] = useState(new Map(initialState));
-  const actions = {
-    set: useCallback((key, value) => {
-      setMap((prev) => {
-        const copy = new Map(prev);
-        copy.set(key, value);
-        return copy;
-      });
-    }, []),
-    setAll: useCallback((entries) => {
-      setMap(() => new Map(entries));
-    }, []),
-    remove: useCallback((key) => {
-      setMap((prev) => {
-        const copy = new Map(prev);
-        copy.delete(key);
-        return copy;
-      });
-    }, []),
-    reset: useCallback(() => {
-      setMap(() => /* @__PURE__ */ new Map());
-    }, [])
-  };
-  return [map, actions];
-}
-
-const useMediaSession = (options) => {
-  const actionHandlersRef = useRef(/* @__PURE__ */ new Set());
-  const isSupported = typeof navigator !== "undefined" && "mediaSession" in navigator;
-  const setMetadata = useCallback(
-    (metadata) => {
-      if (!isSupported) return;
-      try {
-        navigator.mediaSession.metadata = new MediaMetadata(metadata);
-      } catch (error) {
-        console.warn("Failed to set media metadata:", error);
-      }
-    },
-    [isSupported]
-  );
-  const setPlaybackState = useCallback(
-    (state) => {
-      if (!isSupported) return;
-      try {
-        navigator.mediaSession.playbackState = state;
-      } catch (error) {
-        console.warn("Failed to set playback state:", error);
-      }
-    },
-    [isSupported]
-  );
-  const setActionHandler = useCallback(
-    (action, handler) => {
-      if (!isSupported) return;
-      try {
-        navigator.mediaSession.setActionHandler(action, handler);
-        if (handler) {
-          actionHandlersRef.current.add(action);
-        } else {
-          actionHandlersRef.current.delete(action);
-        }
-      } catch (error) {
-        console.warn(`Failed to set action handler for ${action}:`, error);
-      }
-    },
-    [isSupported]
-  );
-  const clearActionHandlers = useCallback(() => {
-    if (!isSupported) return;
-    actionHandlersRef.current.forEach((action) => {
-      try {
-        navigator.mediaSession.setActionHandler(action, null);
-      } catch (error) {
-        console.warn(`Failed to clear action handler for ${action}:`, error);
-      }
-    });
-    actionHandlersRef.current.clear();
-  }, [isSupported]);
-  useEffect(() => {
-    if (options?.metadata) {
-      setMetadata(options.metadata);
-    }
-  }, [setMetadata, options?.metadata]);
-  useEffect(() => {
-    if (options?.playbackState) {
-      setPlaybackState(options.playbackState);
-    }
-  }, [setPlaybackState, options?.playbackState]);
-  useEffect(() => {
-    if (options?.actionHandlers) {
-      Object.entries(options.actionHandlers).forEach(([action, handler]) => {
-        if (handler) {
-          setActionHandler(action, handler);
-        }
-      });
-    }
-    return () => {
-      clearActionHandlers();
-    };
-  }, [setActionHandler, clearActionHandlers, options?.actionHandlers]);
-  return {
-    isSupported,
-    setMetadata,
-    setPlaybackState,
-    setActionHandler,
-    clearActionHandlers
-  };
-};
-
-const IS_SERVER$4 = typeof window === "undefined";
-function useReadLocalStorage(key, options = {}) {
-  let { initializeWithValue = true } = options;
-  if (IS_SERVER$4) {
-    initializeWithValue = false;
-  }
-  const deserializer = useCallback(
-    (value) => {
-      if (options.deserializer) {
-        return options.deserializer(value);
-      }
-      if (value === "undefined") {
-        return void 0;
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch (error) {
-        console.error("Error parsing JSON:", error);
-        return null;
-      }
-      return parsed;
-    },
-    [options]
-  );
-  const readValue = useCallback(() => {
-    if (IS_SERVER$4) {
-      return null;
-    }
-    try {
-      const raw = window.localStorage.getItem(key);
-      return raw ? deserializer(raw) : null;
-    } catch (error) {
-      console.warn(`Error reading localStorage key \u201C${key}\u201D:`, error);
-      return null;
-    }
-  }, [key, deserializer]);
-  const [storedValue, setStoredValue] = useState(() => {
-    if (initializeWithValue) {
-      return readValue();
-    }
-    return void 0;
-  });
-  useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = useCallback(
-    (event) => {
-      if (event.key && event.key !== key) {
-        return;
-      }
-      setStoredValue(readValue());
-    },
-    [key, readValue]
-  );
-  useEventListener("storage", handleStorageChange);
-  useEventListener("local-storage", handleStorageChange);
-  return storedValue;
-}
-
-const initialSize = {
-  width: void 0,
-  height: void 0
-};
-function useResizeObserver(options) {
-  const { ref, box = "content-box" } = options;
-  const [{ width, height }, setSize] = useState(initialSize);
-  const isMounted = useIsMounted();
-  const previousSize = useRef({ ...initialSize });
-  const onResize = useRef(void 0);
-  onResize.current = options.onResize;
-  useEffect(() => {
-    if (!ref.current) return;
-    if (typeof window === "undefined" || !("ResizeObserver" in window)) return;
-    const observer = new ResizeObserver(([entry]) => {
-      const boxProp = box === "border-box" ? "borderBoxSize" : box === "device-pixel-content-box" ? "devicePixelContentBoxSize" : "contentBoxSize";
-      const newWidth = extractSize(entry, boxProp, "inlineSize");
-      const newHeight = extractSize(entry, boxProp, "blockSize");
-      const hasChanged = previousSize.current.width !== newWidth || previousSize.current.height !== newHeight;
-      if (hasChanged) {
-        const newSize = { width: newWidth, height: newHeight };
-        previousSize.current.width = newWidth;
-        previousSize.current.height = newHeight;
-        if (onResize.current) {
-          onResize.current(newSize);
-        } else {
-          if (isMounted()) {
-            setSize(newSize);
-          }
-        }
-      }
-    });
-    observer.observe(ref.current, { box });
-    return () => {
-      observer.disconnect();
-    };
-  }, [box, ref, isMounted]);
-  return { width, height };
-}
-function extractSize(entry, box, sizeType) {
-  if (!entry[box]) {
-    if (box === "contentBoxSize") {
-      return entry.contentRect[sizeType === "inlineSize" ? "width" : "height"];
-    }
-    return void 0;
-  }
-  return Array.isArray(entry[box]) ? entry[box][0][sizeType] : (
-    // @ts-ignore Support Firefox's non-standard behavior
-    entry[box][sizeType]
-  );
-}
-
-const IS_SERVER$3 = typeof window === "undefined";
-function useScreen(options = {}) {
-  let { initializeWithValue = true } = options;
-  if (IS_SERVER$3) {
-    initializeWithValue = false;
-  }
-  const readScreen = () => {
-    if (IS_SERVER$3) {
-      return void 0;
-    }
-    return window.screen;
-  };
-  const [screen, setScreen] = useState(() => {
-    if (initializeWithValue) {
-      return readScreen();
-    }
-    return void 0;
-  });
-  const debouncedSetScreen = useDebounceCallback(
-    setScreen,
-    options.debounceDelay
-  );
-  function handleSize() {
-    const newScreen = readScreen();
-    const setSize = options.debounceDelay ? debouncedSetScreen : setScreen;
-    if (newScreen) {
-      const {
-        width,
-        height,
-        availHeight,
-        availWidth,
-        colorDepth,
-        orientation,
-        pixelDepth
-      } = newScreen;
-      setSize({
-        width,
-        height,
-        availHeight,
-        availWidth,
-        colorDepth,
-        orientation,
-        pixelDepth
-      });
-    }
-  }
-  useEventListener("resize", handleSize);
-  useIsomorphicLayoutEffect(() => {
-    handleSize();
-  }, []);
-  return screen;
-}
-
-const cachedScriptStatuses = /* @__PURE__ */ new Map();
-function getScriptNode(src) {
-  const node = document.querySelector(
-    `script[src="${src}"]`
-  );
-  const status = node?.getAttribute("data-status");
-  return {
-    node,
-    status
-  };
-}
-function useScript(src, options) {
-  const [status, setStatus] = useState(() => {
-    if (!src || options?.shouldPreventLoad) {
-      return "idle";
-    }
-    if (typeof window === "undefined") {
-      return "loading";
-    }
-    return cachedScriptStatuses.get(src) ?? "loading";
-  });
-  useEffect(() => {
-    if (!src || options?.shouldPreventLoad) {
-      return;
-    }
-    const cachedScriptStatus = cachedScriptStatuses.get(src);
-    if (cachedScriptStatus === "ready" || cachedScriptStatus === "error") {
-      setStatus(cachedScriptStatus);
-      return;
-    }
-    const script = getScriptNode(src);
-    let scriptNode = script.node;
-    if (!scriptNode) {
-      scriptNode = document.createElement("script");
-      scriptNode.src = src;
-      scriptNode.async = true;
-      if (options?.id) {
-        scriptNode.id = options.id;
-      }
-      scriptNode.setAttribute("data-status", "loading");
-      document.body.appendChild(scriptNode);
-      const setAttributeFromEvent = (event) => {
-        const scriptStatus = event.type === "load" ? "ready" : "error";
-        scriptNode?.setAttribute("data-status", scriptStatus);
-      };
-      scriptNode.addEventListener("load", setAttributeFromEvent);
-      scriptNode.addEventListener("error", setAttributeFromEvent);
-    } else {
-      setStatus(script.status ?? cachedScriptStatus ?? "loading");
-    }
-    const setStateFromEvent = (event) => {
-      const newStatus = event.type === "load" ? "ready" : "error";
-      setStatus(newStatus);
-      cachedScriptStatuses.set(src, newStatus);
-    };
-    scriptNode.addEventListener("load", setStateFromEvent);
-    scriptNode.addEventListener("error", setStateFromEvent);
-    return () => {
-      if (scriptNode) {
-        scriptNode.removeEventListener("load", setStateFromEvent);
-        scriptNode.removeEventListener("error", setStateFromEvent);
-      }
-      if (scriptNode && options?.removeOnUnmount) {
-        scriptNode.remove();
-        cachedScriptStatuses.delete(src);
-      }
-    };
-  }, [src, options?.shouldPreventLoad, options?.removeOnUnmount, options?.id]);
-  return status;
-}
-
-const IS_SERVER$2 = typeof window === "undefined";
-function useScrollLock(options = {}) {
-  const { autoLock = true, lockTarget, widthReflow = true } = options;
-  const [isLocked, setIsLocked] = useState(false);
-  const target = useRef(null);
-  const originalStyle = useRef(null);
-  const lock = () => {
-    if (target.current) {
-      const { overflow, paddingRight } = target.current.style;
-      originalStyle.current = { overflow, paddingRight };
-      if (widthReflow) {
-        const offsetWidth = target.current === document.body ? window.innerWidth : target.current.offsetWidth;
-        const currentPaddingRight = parseInt(window.getComputedStyle(target.current).paddingRight, 10) || 0;
-        const scrollbarWidth = offsetWidth - target.current.scrollWidth;
-        target.current.style.paddingRight = `${scrollbarWidth + currentPaddingRight}px`;
-      }
-      target.current.style.overflow = "hidden";
-      setIsLocked(true);
-    }
-  };
-  const unlock = () => {
-    if (target.current && originalStyle.current) {
-      target.current.style.overflow = originalStyle.current.overflow;
-      if (widthReflow) {
-        target.current.style.paddingRight = originalStyle.current.paddingRight;
-      }
-    }
-    setIsLocked(false);
-  };
-  useIsomorphicLayoutEffect(() => {
-    if (IS_SERVER$2) return;
-    if (lockTarget) {
-      target.current = typeof lockTarget === "string" ? document.querySelector(lockTarget) : lockTarget;
-    }
-    if (!target.current) {
-      target.current = document.body;
-    }
-    if (autoLock) {
-      lock();
-    }
-    return () => {
-      unlock();
-    };
-  }, [autoLock, lockTarget, widthReflow]);
-  return { isLocked, lock, unlock };
-}
-
-const IS_SERVER$1 = typeof window === "undefined";
-function useSessionStorage(key, initialValue, options = {}) {
-  const { initializeWithValue = true } = options;
-  const serializer = useCallback(
-    (value) => {
-      if (options.serializer) {
-        return options.serializer(value);
-      }
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = useCallback(
-    (value) => {
-      if (options.deserializer) {
-        return options.deserializer(value);
-      }
-      if (value === "undefined") {
-        return void 0;
-      }
-      const defaultValue = initialValue instanceof Function ? initialValue() : initialValue;
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch (error) {
-        console.error("Error parsing JSON:", error);
-        return defaultValue;
-      }
-      return parsed;
-    },
-    [options, initialValue]
-  );
-  const readValue = useCallback(() => {
-    const initialValueToUse = initialValue instanceof Function ? initialValue() : initialValue;
-    if (IS_SERVER$1) {
-      return initialValueToUse;
-    }
-    try {
-      const raw = window.sessionStorage.getItem(key);
-      return raw ? deserializer(raw) : initialValueToUse;
-    } catch (error) {
-      console.warn(`Error reading sessionStorage key \u201C${key}\u201D:`, error);
-      return initialValueToUse;
-    }
-  }, [initialValue, key, deserializer]);
-  const [storedValue, setStoredValue] = useState(() => {
-    if (initializeWithValue) {
-      return readValue();
-    }
-    return initialValue instanceof Function ? initialValue() : initialValue;
-  });
-  const setValue = useEventCallback((value) => {
-    if (IS_SERVER$1) {
-      console.warn(
-        `Tried setting sessionStorage key \u201C${key}\u201D even though environment is not a client`
-      );
-    }
-    try {
-      const newValue = value instanceof Function ? value(readValue()) : value;
-      window.sessionStorage.setItem(key, serializer(newValue));
-      setStoredValue(newValue);
-      window.dispatchEvent(new StorageEvent("session-storage", { key }));
-    } catch (error) {
-      console.warn(`Error setting sessionStorage key \u201C${key}\u201D:`, error);
-    }
-  });
-  const removeValue = useEventCallback(() => {
-    if (IS_SERVER$1) {
-      console.warn(
-        `Tried removing sessionStorage key \u201C${key}\u201D even though environment is not a client`
-      );
-    }
-    const defaultValue = initialValue instanceof Function ? initialValue() : initialValue;
-    window.sessionStorage.removeItem(key);
-    setStoredValue(defaultValue);
-    window.dispatchEvent(new StorageEvent("session-storage", { key }));
-  });
-  useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = useCallback(
-    (event) => {
-      if (event.key && event.key !== key) {
-        return;
-      }
-      setStoredValue(readValue());
-    },
-    [key, readValue]
-  );
-  useEventListener("storage", handleStorageChange);
-  useEventListener("session-storage", handleStorageChange);
-  return [storedValue, setValue, removeValue];
-}
-
-function useStep(maxStep) {
-  const [currentStep, setCurrentStep] = useState(1);
-  const canGoToNextStep = currentStep + 1 <= maxStep;
-  const canGoToPrevStep = currentStep - 1 > 0;
-  const setStep = useCallback(
-    (step) => {
-      const newStep = step instanceof Function ? step(currentStep) : step;
-      if (newStep >= 1 && newStep <= maxStep) {
-        setCurrentStep(newStep);
-        return;
-      }
-      throw new Error("Step not valid");
-    },
-    [maxStep, currentStep]
-  );
-  const goToNextStep = useCallback(() => {
-    if (canGoToNextStep) {
-      setCurrentStep((step) => step + 1);
-    }
-  }, [canGoToNextStep]);
-  const goToPrevStep = useCallback(() => {
-    if (canGoToPrevStep) {
-      setCurrentStep((step) => step - 1);
-    }
-  }, [canGoToPrevStep]);
-  const reset = useCallback(() => {
-    setCurrentStep(1);
-  }, []);
-  return [
-    currentStep,
-    {
-      goToNextStep,
-      goToPrevStep,
-      canGoToNextStep,
-      canGoToPrevStep,
-      setStep,
-      reset
-    }
-  ];
-}
-
-const COLOR_SCHEME_QUERY = "(prefers-color-scheme: dark)";
-const LOCAL_STORAGE_KEY = "sse-hooks-ternary-dark-mode";
-function useTernaryDarkMode({
-  defaultValue = "system",
-  localStorageKey = LOCAL_STORAGE_KEY,
-  initializeWithValue = true
-} = {}) {
-  const isDarkOS = useMediaQuery(COLOR_SCHEME_QUERY, { initializeWithValue });
-  const [mode, setMode] = useLocalStorage(localStorageKey, defaultValue, {
-    initializeWithValue
-  });
-  const isDarkMode = mode === "dark" || mode === "system" && isDarkOS;
-  const toggleTernaryDarkMode = () => {
-    const modes = ["light", "system", "dark"];
-    setMode((prevMode) => {
-      const nextIndex = (modes.indexOf(prevMode) + 1) % modes.length;
-      return modes[nextIndex];
-    });
-  };
-  return {
-    isDarkMode,
-    ternaryDarkMode: mode,
-    setTernaryDarkMode: setMode,
-    toggleTernaryDarkMode
-  };
-}
-
-function useTimeout(callback, delay) {
-  const savedCallback = useRef(callback);
-  useIsomorphicLayoutEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  useEffect(() => {
-    if (!delay && delay !== 0) {
-      return;
-    }
-    const id = setTimeout(() => {
-      savedCallback.current();
-    }, delay);
-    return () => {
-      clearTimeout(id);
-    };
-  }, [delay]);
-}
-
-function useToggle(defaultValue) {
-  const [value, setValue] = useState(!!defaultValue);
-  const toggle = useCallback(() => {
-    setValue((x) => !x);
-  }, []);
-  return [value, toggle, setValue];
-}
-
-const DEFAULT_CONSTRAINTS = {
-  video: true,
-  audio: true
-};
-const useUserMedia = (initialConstraints = DEFAULT_CONSTRAINTS) => {
-  const [stream, setStream] = useState(null);
-  const [error, setError] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const streamRef = useRef(null);
-  const isSupported = typeof navigator !== "undefined" && "mediaDevices" in navigator && "getUserMedia" in navigator.mediaDevices;
-  const stopCapture = useCallback(() => {
-    if (streamRef.current) {
-      streamRef.current.getTracks().forEach((track) => {
-        track.stop();
-      });
-      streamRef.current = null;
-      setStream(null);
-    }
-    setError(null);
-  }, []);
-  const startCapture = useCallback(
-    async (constraints = initialConstraints) => {
-      if (!isSupported) {
-        setError("getUserMedia is not supported in this browser");
-        return;
-      }
-      stopCapture();
-      setIsLoading(true);
-      setError(null);
-      try {
-        const mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
-        streamRef.current = mediaStream;
-        setStream(mediaStream);
-      } catch (err) {
-        let errorMessage = "Failed to access media devices";
-        if (err instanceof Error) {
-          switch (err.name) {
-            case "NotAllowedError":
-              errorMessage = "Permission denied. Please allow camera/microphone access.";
-              break;
-            case "NotFoundError":
-              errorMessage = "No camera or microphone found.";
-              break;
-            case "NotReadableError":
-              errorMessage = "Camera or microphone is already in use.";
-              break;
-            case "OverconstrainedError":
-              errorMessage = "Camera or microphone constraints cannot be satisfied.";
-              break;
-            case "SecurityError":
-              errorMessage = "Security error. Make sure you're using HTTPS.";
-              break;
-            case "AbortError":
-              errorMessage = "Media access was aborted.";
-              break;
-            default:
-              errorMessage = err.message || errorMessage;
-          }
-        }
-        setError(errorMessage);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [isSupported, initialConstraints, stopCapture]
-  );
-  useEffect(() => {
-    return () => {
-      stopCapture();
-    };
-  }, [stopCapture]);
-  return {
-    stream,
-    error,
-    isLoading,
-    isSupported,
-    startCapture,
-    stopCapture
-  };
-};
-
-const IS_SERVER = typeof window === "undefined";
-function useWindowSize(options = {}) {
-  let { initializeWithValue = true } = options;
-  if (IS_SERVER) {
-    initializeWithValue = false;
-  }
-  const [windowSize, setWindowSize] = useState(() => {
-    if (initializeWithValue) {
-      return {
-        width: window.innerWidth,
-        height: window.innerHeight
-      };
-    }
-    return {
-      width: void 0,
-      height: void 0
-    };
-  });
-  const debouncedSetWindowSize = useDebounceCallback(
-    setWindowSize,
-    options.debounceDelay
-  );
-  function handleSize() {
-    const setSize = options.debounceDelay ? debouncedSetWindowSize : setWindowSize;
-    setSize({
-      width: window.innerWidth,
-      height: window.innerHeight
-    });
-  }
-  useEventListener("resize", handleSize);
-  useIsomorphicLayoutEffect(() => {
-    handleSize();
-  }, []);
-  return windowSize;
-}
-
-export { ComputedRefImpl, Dep, EffectFlags, Link, ReactiveFlags, RefImpl, TrackOpTypes, TriggerOpTypes, __DEV__, batch, computed, endBatch, extend, getActiveSub, globalVersion, isArray, isFunction, isIntegerKey, isMap, isObject, isSymbol, ref, refreshComputed, setActiveSub, shouldTrack, startBatch, targetMap, track, useAudioRecorder, useBatteryHook as useBattery, useBoolean, useClickAnyWhere, useClickAway, useComputed, useCookie, useCopyToClipboard, useCountdown, useCounter, useDarkMode, useDebounceCallback, useDebounceValue, useDelete, useDocumentTitle, useEventCallback, useEventListener, useFetch, useForkRef, useGet, useHover, useIndexedDB, useIntersectionObserver, useInterval, useIsClient, useIsMounted, useIsomorphicLayoutEffect, useLocalStorage, useMap, useMediaQuery, useMediaSession, usePost, usePut, useReactive, useReadLocalStorage, useResizeObserver, useScreen, useScript, useScrollLock, useSessionStorage, useStep, useTernaryDarkMode, useTimeout, useToggle, useUnmount, useUserMedia, useWindowSize, withDefaults };