sse-hooks 1.3.0 → 2.0.0

package/dist/index.cjs

@@ -1,3108 +0,0 @@
-'use strict';
-
-const React = require('react');
-const debounce = require('lodash.debounce');
-require('react-dom');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const React__default = /*#__PURE__*/_interopDefaultCompat(React);
-const debounce__default = /*#__PURE__*/_interopDefaultCompat(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"
-};
-
-exports.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++;
-    exports.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 = exports.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] = React.useState(0);
-  const forceUpdate = () => setTick((t) => t + 1);
-  const subscriberRef = React.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);
-  React.useEffect(() => {
-    return () => {
-    };
-  }, []);
-  return value;
-}
-function useComputed(getter, deps = []) {
-  const cRef = React.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 = React.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] = React.useState(false);
-  const [isPaused, setIsPaused] = React.useState(false);
-  const [stream, setStream] = React.useState(null);
-  const [mediaRecorder, setMediaRecorder] = React.useState(
-    null
-  );
-  const [audioBlob, setAudioBlob] = React.useState(null);
-  const [audioUrl, setAudioUrl] = React.useState(null);
-  const [duration, setDuration] = React.useState(0);
-  const [error, setError] = React.useState(null);
-  const [analysisData, setAnalysisData] = React.useState(
-    null
-  );
-  const chunksRef = React.useRef([]);
-  const startTimeRef = React.useRef(0);
-  const pausedTimeRef = React.useRef(0);
-  const intervalRef = React.useRef(null);
-  const audioContextRef = React.useRef(null);
-  const analyserRef = React.useRef(null);
-  const sourceRef = React.useRef(null);
-  const animationFrameRef = React.useRef(null);
-  const isSupported = typeof navigator !== "undefined" && !!navigator.mediaDevices && !!navigator.mediaDevices.getUserMedia && !!window.MediaRecorder;
-  const updateDuration = React.useCallback(() => {
-    if (startTimeRef.current) {
-      const elapsed = Date.now() - startTimeRef.current - pausedTimeRef.current;
-      setDuration(Math.floor(elapsed / 1e3));
-    }
-  }, []);
-  const analyzeAudio = React.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 = React.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 = React.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 = React.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 = React.useCallback(() => {
-    if (mediaRecorder && mediaRecorder.state === "recording") {
-      mediaRecorder.pause();
-    }
-  }, [mediaRecorder]);
-  const resumeRecording = React.useCallback(() => {
-    if (mediaRecorder && mediaRecorder.state === "paused") {
-      mediaRecorder.resume();
-    }
-  }, [mediaRecorder]);
-  const clearRecording = React.useCallback(() => {
-    if (audioUrl) {
-      URL.revokeObjectURL(audioUrl);
-    }
-    setAudioBlob(null);
-    setAudioUrl(null);
-    setDuration(0);
-    setAnalysisData(null);
-    setError(null);
-  }, [audioUrl]);
-  const downloadRecording = React.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]
-  );
-  React.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] = React.useState({
-    isSupported: true,
-    fetched: false
-  });
-  React.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] = React.useState(defaultValue);
-  const setTrue = React.useCallback(() => {
-    setValue(true);
-  }, []);
-  const setFalse = React.useCallback(() => {
-    setValue(false);
-  }, []);
-  const toggle = React.useCallback(() => {
-    setValue((x) => !x);
-  }, []);
-  return { value, setValue, setTrue, setFalse, toggle };
-}
-
-const breakpointsTailwind = {
-  sm: 640,
-  md: 768,
-  lg: 1024,
-  xl: 1280,
-  "2xl": 1536
-};
-const breakpointsBootstrapV5 = {
-  sm: 576,
-  md: 768,
-  lg: 992,
-  xl: 1200,
-  xxl: 1400
-};
-const breakpointsVuetify = {
-  xs: 600,
-  sm: 960,
-  md: 1264,
-  lg: 1904
-};
-const breakpointsAntDesign = {
-  xs: 480,
-  sm: 576,
-  md: 768,
-  lg: 992,
-  xl: 1200,
-  xxl: 1600
-};
-const breakpointsSematic = {
-  mobileS: 320,
-  mobileM: 375,
-  mobileL: 425,
-  tablet: 768,
-  laptop: 1024,
-  laptopL: 1440,
-  desktop4K: 2560
-};
-
-const useIsomorphicLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
-
-const IS_SERVER$7 = typeof window === "undefined";
-function useMediaQuery(query, {
-  defaultValue = false,
-  initializeWithValue = true
-} = {}) {
-  const getMatches = (query2) => {
-    if (IS_SERVER$7) {
-      return defaultValue;
-    }
-    return window.matchMedia(query2).matches;
-  };
-  const [matches, setMatches] = React.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;
-}
-
-function match(query) {
-  if (typeof window === "undefined") return false;
-  return window.matchMedia(query).matches;
-}
-function useBreakpoint(breakpoints) {
-  return {
-    /**
-     * Hook that returns a boolean if screen width is greater than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useGreater: (k) => {
-      return useMediaQuery(`(min-width: ${breakpoints[k]}px)`);
-    },
-    /**
-     * Hook that returns a boolean if screen width is smaller than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     * @param k {string} breakpoint
-     *
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useSmaller: (k) => {
-      return useMediaQuery(`(max-width: ${breakpoints[k]}px)`);
-    },
-    /**
-     * Hook that returns a boolean if screen width is between two given breakpoint.
-     *
-     * @param a {string} breakpoint
-     * @param b {string} breakpoint
-     *
-     * @returns boolean
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    useBetween: (a, b) => {
-      return useMediaQuery(
-        `(min-width: ${breakpoints[a]}px) and (max-width: ${breakpoints[b]}px)`
-      );
-    },
-    /**
-     * Utility function that returns a boolean if screen width is greater than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isGreater(k) {
-      return match(`(min-width: ${breakpoints[k]}px)`);
-    },
-    /**
-     * Utility function that returns a boolean if screen width is smaller than given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isSmaller(k) {
-      return match(`(max-width: ${breakpoints[k]}px)`);
-    },
-    /**
-     * Utility function that returns a boolean if screen width is between two given breakpoint.
-     *
-     * @param k {string} breakpoint
-     *
-     * @see https://react-hooks-library.vercel.app/core/BreakPointHooks
-     **/
-    isInBetween(a, b) {
-      return match(
-        `(min-width: ${breakpoints[a]}px) and (max-width: ${breakpoints[b]}px)`
-      );
-    }
-  };
-}
-
-function useEventListener(eventName, handler, element, options) {
-  const savedHandler = React.useRef(handler);
-  useIsomorphicLayoutEffect(() => {
-    savedHandler.current = handler;
-  }, [handler]);
-  React.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__default.useRef(void 0);
-  const refEffect = React__default.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__default.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 = React.useRef(() => {
-    throw new Error("Cannot call an event handler while rendering.");
-  });
-  useIsomorphicLayoutEffect(() => {
-    ref.current = fn;
-  }, [fn]);
-  return React.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__default.useRef(null);
-  const handleRef = useForkRef(externalRef, internalRef);
-  const movedRef = React__default.useRef(false);
-  const activatedRef = React__default.useRef(false);
-  const syntheticEventRef = React__default.useRef(false);
-  React__default.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__default.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__default.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 DEFAULT_CONSTRAINTS = {
-  video: true,
-  audio: true
-};
-const useUserMedia = (initialConstraints = DEFAULT_CONSTRAINTS) => {
-  const [stream, setStream] = React.useState(null);
-  const [error, setError] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const streamRef = React.useRef(null);
-  const isSupported = typeof navigator !== "undefined" && "mediaDevices" in navigator && "getUserMedia" in navigator.mediaDevices;
-  const stopCapture = React.useCallback(() => {
-    if (streamRef.current) {
-      streamRef.current.getTracks().forEach((track) => {
-        track.stop();
-      });
-      streamRef.current = null;
-      setStream(null);
-    }
-    setError(null);
-  }, []);
-  const startCapture = React.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]
-  );
-  React.useEffect(() => {
-    return () => {
-      stopCapture();
-    };
-  }, [stopCapture]);
-  return {
-    stream,
-    error,
-    isLoading,
-    isSupported,
-    startCapture,
-    stopCapture
-  };
-};
-
-const DEFAULT_OPTIONS = {
-  video: true,
-  audio: false
-};
-function useScreenShare(initialOptions = DEFAULT_OPTIONS) {
-  const [stream, setStream] = React.useState(null);
-  const [error, setError] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const streamRef = React.useRef(null);
-  const isSupported = typeof navigator !== "undefined" && "mediaDevices" in navigator && "getDisplayMedia" in navigator.mediaDevices;
-  const stopCapture = React.useCallback(() => {
-    if (streamRef.current) {
-      streamRef.current.getTracks().forEach((track) => {
-        track.stop();
-      });
-      streamRef.current = null;
-      setStream(null);
-    }
-    setError(null);
-  }, []);
-  const startCapture = React.useCallback(
-    async (options = initialOptions) => {
-      if (!isSupported) {
-        setError("getDisplayMedia is not supported in this browser");
-        return;
-      }
-      stopCapture();
-      setIsLoading(true);
-      setError(null);
-      try {
-        const mediaStream = await navigator.mediaDevices.getDisplayMedia(options);
-        const videoTrack = mediaStream.getVideoTracks()[0];
-        if (videoTrack) {
-          videoTrack.onended = () => {
-            stopCapture();
-          };
-        }
-        streamRef.current = mediaStream;
-        setStream(mediaStream);
-      } catch (err) {
-        let errorMessage = "Failed to start screen sharing";
-        if (err instanceof Error) {
-          switch (err.name) {
-            case "NotAllowedError":
-              errorMessage = "Permission denied or user cancelled the selection.";
-              break;
-            case "NotFoundError":
-              errorMessage = "No screen video source found.";
-              break;
-            case "NotReadableError":
-              errorMessage = "Could not capture the screen (OS or hardware error).";
-              break;
-            case "OverconstrainedError":
-              errorMessage = "The specified constraints cannot be satisfied.";
-              break;
-            case "AbortError":
-              errorMessage = "Screen sharing selection was aborted.";
-              break;
-            default:
-              errorMessage = err.message || errorMessage;
-          }
-        }
-        setError(errorMessage);
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [isSupported, initialOptions, stopCapture]
-  );
-  React.useEffect(() => {
-    return () => {
-      stopCapture();
-    };
-  }, [stopCapture]);
-  return {
-    stream,
-    error,
-    isLoading,
-    isSupported,
-    startCapture,
-    stopCapture
-  };
-}
-
-const useNetworkInformation = () => {
-  const [networkInfo, setNetworkInfo] = React.useState(
-    null
-  );
-  const [isOnline, setIsOnline] = React.useState(
-    typeof navigator !== "undefined" ? navigator.onLine : true
-  );
-  const isSupported = typeof navigator !== "undefined" && "connection" in navigator && navigator.connection !== void 0;
-  const updateNetworkInfo = React.useCallback(() => {
-    if (!isSupported || !navigator.connection) return;
-    const connection = navigator.connection;
-    setNetworkInfo({
-      downlink: connection.downlink,
-      downlinkMax: connection.downlinkMax,
-      effectiveType: connection.effectiveType,
-      rtt: connection.rtt,
-      saveData: connection.saveData,
-      type: connection.type
-    });
-  }, [isSupported]);
-  const handleOnlineStatusChange = React.useCallback(() => {
-    setIsOnline(navigator.onLine);
-  }, []);
-  const handleConnectionChange = React.useCallback(() => {
-    updateNetworkInfo();
-  }, [updateNetworkInfo]);
-  React.useEffect(() => {
-    if (typeof window === "undefined") return;
-    updateNetworkInfo();
-    window.addEventListener("online", handleOnlineStatusChange);
-    window.addEventListener("offline", handleOnlineStatusChange);
-    if (isSupported) {
-      const connection = navigator.connection;
-      connection.addEventListener("change", handleConnectionChange);
-    }
-    return () => {
-      window.removeEventListener("online", handleOnlineStatusChange);
-      window.removeEventListener("offline", handleOnlineStatusChange);
-      if (isSupported) {
-        const connection = navigator.connection;
-        connection.removeEventListener("change", handleConnectionChange);
-      }
-    };
-  }, [
-    isSupported,
-    updateNetworkInfo,
-    handleOnlineStatusChange,
-    handleConnectionChange
-  ]);
-  return {
-    networkInfo,
-    isOnline,
-    isSupported,
-    refresh: updateNetworkInfo
-  };
-};
-
-const QUALITY_PRESETS = {
-  low: {
-    width: { ideal: 320 },
-    height: { ideal: 240 },
-    frameRate: { max: 15 }
-  },
-  medium: {
-    width: { ideal: 640 },
-    height: { ideal: 480 },
-    frameRate: { max: 24 }
-  },
-  high: {
-    width: { ideal: 1280 },
-    height: { ideal: 720 },
-    frameRate: { max: 30 }
-  }
-};
-const useMediaQuality = (stream) => {
-  const [quality, setQuality] = React.useState("high");
-  const [isChanging, setIsChanging] = React.useState(false);
-  const applyQuality = React.useCallback(
-    async (level) => {
-      if (!stream) return;
-      const videoTrack = stream.getVideoTracks()[0];
-      if (!videoTrack) return;
-      if (level === quality && !isChanging) return;
-      setIsChanging(true);
-      try {
-        await videoTrack.applyConstraints(QUALITY_PRESETS[level]);
-        setQuality(level);
-        console.log(`Video quality switched to: ${level}`);
-      } catch (err) {
-        console.warn("Camera hardware could not satisfy constraints:", err);
-      } finally {
-        setIsChanging(false);
-      }
-    },
-    [stream, quality, isChanging]
-  );
-  return { quality, isChanging, setQuality: applyQuality };
-};
-
-const useConferenceSystem = (options = {}) => {
-  const camera = useUserMedia();
-  const screen = useScreenShare();
-  const network = useNetworkInformation();
-  const {
-    quality,
-    setQuality: applyQuality,
-    isChanging: isQualityChanging
-  } = useMediaQuality(camera.stream);
-  const [isAutoQuality, setIsAutoQuality] = React.useState(
-    options.defaultAutoQuality ?? true
-  );
-  React.useEffect(() => {
-    if (!isAutoQuality || !camera.stream || !network.networkInfo) return;
-    const { downlink, effectiveType, saveData } = network.networkInfo;
-    let targetQuality = "high";
-    if (saveData) {
-      targetQuality = "low";
-    } else if (effectiveType === "2g" || effectiveType === "slow-2g") {
-      targetQuality = "low";
-    } else if (downlink && downlink < 1.5) {
-      targetQuality = "low";
-    } else if (downlink && downlink < 5) {
-      targetQuality = "medium";
-    } else {
-      targetQuality = "high";
-    }
-    if (quality !== targetQuality) {
-      applyQuality(targetQuality);
-    }
-  }, [
-    network.networkInfo,
-    isAutoQuality,
-    camera.stream,
-    quality,
-    applyQuality
-  ]);
-  return {
-    camera: {
-      stream: camera.stream,
-      start: camera.startCapture,
-      stop: camera.stopCapture,
-      isActive: !!camera.stream,
-      error: camera.error,
-      isLoading: camera.isLoading
-    },
-    screen: {
-      stream: screen.stream,
-      start: screen.startCapture,
-      stop: screen.stopCapture,
-      isActive: !!screen.stream,
-      error: screen.error
-    },
-    quality: {
-      current: quality,
-      isChanging: isQualityChanging,
-      set: applyQuality,
-      // Manual Override
-      isAuto: isAutoQuality,
-      toggleAuto: () => setIsAutoQuality((prev) => !prev)
-    },
-    network: {
-      isOnline: network.isOnline,
-      speed: network.networkInfo?.downlink || 0,
-      // Mbps
-      type: network.networkInfo?.effectiveType || "unknown"
-    }
-  };
-};
-
-const IS_SERVER$6 = typeof document === "undefined";
-function parseCookies() {
-  if (IS_SERVER$6) 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 = React.useCallback(
-    (value) => {
-      if (options.serializer) return options.serializer(value);
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = React.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 = React.useCallback(() => {
-    const fallback = initialValue instanceof Function ? initialValue() : initialValue;
-    if (IS_SERVER$6) return fallback;
-    const cookies = parseCookies();
-    if (!(cookieKey in cookies)) return fallback;
-    return deserializer(cookies[cookieKey]);
-  }, [cookieKey, deserializer, initialValue]);
-  const [storedValue, setStoredValue] = React.useState(() => {
-    if (initializeWithValue) return readValue();
-    return initialValue instanceof Function ? initialValue() : initialValue;
-  });
-  const setValue = useEventCallback((value) => {
-    if (IS_SERVER$6) 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$6) 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 } })
-    );
-  });
-  React.useEffect(() => {
-    setStoredValue(readValue());
-  }, [cookieKey]);
-  const handleChange = React.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] = React.useState(null);
-  const copy = React.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] = React.useState(initialValue ?? 0);
-  const increment = React.useCallback(() => {
-    setCount((x) => x + 1);
-  }, []);
-  const decrement = React.useCallback(() => {
-    setCount((x) => x - 1);
-  }, []);
-  const reset = React.useCallback(() => {
-    setCount(initialValue ?? 0);
-  }, [initialValue]);
-  return {
-    count,
-    increment,
-    decrement,
-    reset,
-    setCount
-  };
-}
-
-function useInterval(callback, delay) {
-  const savedCallback = React.useRef(callback);
-  useIsomorphicLayoutEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  React.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 = React.useCallback(() => {
-    stopCountdown();
-    resetCounter();
-  }, [stopCountdown, resetCounter]);
-  const countdownCallback = React.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$5 = typeof window === "undefined";
-function useLocalStorage(key, initialValue, options = {}) {
-  const { initializeWithValue = true } = options;
-  const serializer = React.useCallback(
-    (value) => {
-      if (options.serializer) {
-        return options.serializer(value);
-      }
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = React.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 = React.useCallback(() => {
-    const initialValueToUse = initialValue instanceof Function ? initialValue() : initialValue;
-    if (IS_SERVER$5) {
-      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] = React.useState(() => {
-    if (initializeWithValue) {
-      return readValue();
-    }
-    return initialValue instanceof Function ? initialValue() : initialValue;
-  });
-  const setValue = useEventCallback((value) => {
-    if (IS_SERVER$5) {
-      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$5) {
-      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 }));
-  });
-  React.useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = React.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 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 = React.useRef(func);
-  funcRef.current = func;
-  React.useEffect(
-    () => () => {
-      funcRef.current();
-    },
-    []
-  );
-}
-
-function useDebounceCallback(func, delay = 500, options) {
-  const debouncedFunc = React.useRef();
-  useUnmount(() => {
-    if (debouncedFunc.current) {
-      debouncedFunc.current.cancel();
-    }
-  });
-  const debounced = React.useMemo(() => {
-    const debouncedFuncInstance = debounce__default(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]);
-  React.useEffect(() => {
-    debouncedFunc.current = debounce__default(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] = React.useState(
-    unwrappedInitialValue
-  );
-  const previousValueRef = React.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 = React.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] = React.useState({
-    data: null,
-    loading: false,
-    error: null
-  });
-  const abortControllerRef = React.useRef(null);
-  const optionsRef = React.useRef(options);
-  React.useEffect(() => {
-    optionsRef.current = options;
-  }, [options]);
-  const execute = React.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 = React.useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-  }, []);
-  const reset = React.useCallback(() => {
-    abort();
-    setState({ data: null, loading: false, error: null });
-  }, [abort]);
-  React.useEffect(() => {
-    if (options.immediate && url) {
-      execute();
-    }
-  }, [url, options.immediate, execute]);
-  React.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] = React.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] = React.useState(null);
-  const [error, setError] = React.useState(null);
-  const [loading, setLoading] = React.useState(false);
-  const [db, setDb] = React.useState(null);
-  const { version = 1, onUpgradeNeeded } = options;
-  React.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 = React.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 = React.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 = React.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 = React.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 = React.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] = React.useState(null);
-  const [state, setState] = React.useState(() => ({
-    isIntersecting: initialIsIntersecting,
-    entry: void 0
-  }));
-  const callbackRef = React.useRef();
-  callbackRef.current = onChange;
-  const frozen = state.entry?.isIntersecting && freezeOnceVisible;
-  React.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 = React.useRef(null);
-  React.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] = React.useState(false);
-  React.useEffect(() => {
-    setClient(true);
-  }, []);
-  return isClient;
-}
-
-function useIsMounted() {
-  const isMounted = React.useRef(false);
-  React.useEffect(() => {
-    isMounted.current = true;
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-  return React.useCallback(() => isMounted.current, []);
-}
-
-const kbdKeysMap = {
-  meta: "",
-  ctrl: "",
-  alt: "",
-  win: "\u229E",
-  command: "\u2318",
-  shift: "\u21E7",
-  control: "\u2303",
-  option: "\u2325",
-  enter: "\u21B5",
-  delete: "\u2326",
-  backspace: "\u232B",
-  escape: "Esc",
-  tab: "\u21E5",
-  capslock: "\u21EA",
-  arrowup: "\u2191",
-  arrowright: "\u2192",
-  arrowdown: "\u2193",
-  arrowleft: "\u2190",
-  pageup: "\u21DE",
-  pagedown: "\u21DF",
-  home: "\u2196",
-  end: "\u2198"
-};
-const useKbd = () => {
-  const [isMac, setIsMac] = React.useState(false);
-  React.useEffect(() => {
-    const isClient = typeof window !== "undefined" && typeof navigator !== "undefined";
-    if (isClient) {
-      const isMacUserAgent = /Macintosh/.test(navigator.userAgent);
-      setIsMac(isMacUserAgent);
-    }
-  }, []);
-  const kbdKeysSpecificMap = {
-    meta: isMac ? kbdKeysMap.command : "Ctrl",
-    ctrl: isMac ? kbdKeysMap.control : "Ctrl",
-    alt: isMac ? kbdKeysMap.option : "Alt"
-  };
-  const getKbdKey = React.useCallback(
-    (value) => {
-      if (!value) {
-        return void 0;
-      }
-      if (["meta", "alt", "ctrl"].includes(value)) {
-        return kbdKeysSpecificMap[value];
-      }
-      return kbdKeysMap[value] || value;
-    },
-    [isMac]
-  );
-  return {
-    isMac,
-    getKbdKey
-  };
-};
-
-function useMap(initialState = /* @__PURE__ */ new Map()) {
-  const [map, setMap] = React.useState(new Map(initialState));
-  const actions = {
-    set: React.useCallback((key, value) => {
-      setMap((prev) => {
-        const copy = new Map(prev);
-        copy.set(key, value);
-        return copy;
-      });
-    }, []),
-    setAll: React.useCallback((entries) => {
-      setMap(() => new Map(entries));
-    }, []),
-    remove: React.useCallback((key) => {
-      setMap((prev) => {
-        const copy = new Map(prev);
-        copy.delete(key);
-        return copy;
-      });
-    }, []),
-    reset: React.useCallback(() => {
-      setMap(() => /* @__PURE__ */ new Map());
-    }, [])
-  };
-  return [map, actions];
-}
-
-const useMediaSession = (options) => {
-  const actionHandlersRef = React.useRef(/* @__PURE__ */ new Set());
-  const isSupported = typeof navigator !== "undefined" && "mediaSession" in navigator;
-  const setMetadata = React.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 = React.useCallback(
-    (state) => {
-      if (!isSupported) return;
-      try {
-        navigator.mediaSession.playbackState = state;
-      } catch (error) {
-        console.warn("Failed to set playback state:", error);
-      }
-    },
-    [isSupported]
-  );
-  const setActionHandler = React.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 = React.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]);
-  React.useEffect(() => {
-    if (options?.metadata) {
-      setMetadata(options.metadata);
-    }
-  }, [setMetadata, options?.metadata]);
-  React.useEffect(() => {
-    if (options?.playbackState) {
-      setPlaybackState(options.playbackState);
-    }
-  }, [setPlaybackState, options?.playbackState]);
-  React.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
-  };
-};
-
-var Device = /* @__PURE__ */ ((Device2) => {
-  Device2["Browser"] = "browser";
-  Device2["Server"] = "server";
-  Device2["Native"] = "native";
-  return Device2;
-})(Device || {});
-
-const { Browser, Server, Native } = Device;
-const canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
-const canUseNative = typeof navigator != "undefined" && navigator.product == "ReactNative";
-const device = canUseNative ? Native : canUseDOM ? Browser : Server;
-const SSRObject = {
-  isBrowser: device === Browser,
-  isServer: device === Server,
-  isNative: device === Native,
-  device,
-  canUseWorkers: typeof Worker !== "undefined",
-  canUseEventListeners: device === Browser && !!window.addEventListener,
-  canUseViewport: device === Browser && !!window.screen
-};
-const assign = (...args) => args.reduce((acc, obj) => ({ ...acc, ...obj }), {});
-const values = (obj) => Object.keys(obj).map((key) => obj[key]);
-const toArrayObject = () => assign((values(SSRObject), SSRObject));
-let useSSRObject = toArrayObject();
-const weAreServer = () => {
-  SSRObject.isServer = true;
-  useSSRObject = toArrayObject();
-};
-const useSSR = () => useSSRObject;
-
-const errorMessage1 = "You must either add a `ref` to the element you are interacting with or pass an `event` to openPortal(e) or togglePortal(e) when the `programmaticallyOpen` option is not set to `true`.";
-
-const IS_SERVER$4 = typeof window === "undefined";
-function useReadLocalStorage(key, options = {}) {
-  let { initializeWithValue = true } = options;
-  if (IS_SERVER$4) {
-    initializeWithValue = false;
-  }
-  const deserializer = React.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 = React.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] = React.useState(() => {
-    if (initializeWithValue) {
-      return readValue();
-    }
-    return void 0;
-  });
-  React.useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = React.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] = React.useState(initialSize);
-  const isMounted = useIsMounted();
-  const previousSize = React.useRef({ ...initialSize });
-  const onResize = React.useRef(void 0);
-  onResize.current = options.onResize;
-  React.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]
-  );
-}
-
-function useRoleGuard(requiredRoles, options = {}) {
-  const {
-    user: providedUser,
-    redirectTo = "/unauthorized",
-    onUnauthorized,
-    sessionKey = "user"
-  } = options;
-  const [user, setUser] = React.useState(providedUser || null);
-  const [isLoading, setIsLoading] = React.useState(!providedUser);
-  React.useEffect(() => {
-    if (!providedUser && typeof window !== "undefined") {
-      try {
-        const sessionUser = sessionStorage.getItem(sessionKey);
-        if (sessionUser) {
-          const parsedUser = JSON.parse(sessionUser);
-          setUser(parsedUser);
-        }
-      } catch (error) {
-        console.error("Error parsing user from session:", error);
-      } finally {
-        setIsLoading(false);
-      }
-    }
-  }, [providedUser, sessionKey]);
-  const hasAnyRole = React.useCallback(
-    (roles) => {
-      if (!user || !user.roles) return false;
-      return roles.some((role) => user.roles.includes(role));
-    },
-    [user]
-  );
-  const hasAllRoles = React.useCallback(
-    (roles) => {
-      if (!user || !user.roles) return false;
-      return roles.every((role) => user.roles.includes(role));
-    },
-    [user]
-  );
-  const checkAccess = React.useCallback(
-    (roles) => {
-      return hasAnyRole(roles);
-    },
-    [hasAnyRole]
-  );
-  const hasAccess = checkAccess(requiredRoles);
-  const redirect = React.useCallback(() => {
-    if (typeof window !== "undefined" && redirectTo) {
-      window.location.href = redirectTo;
-    }
-  }, [redirectTo]);
-  React.useEffect(() => {
-    if (!isLoading && !hasAccess) {
-      if (onUnauthorized) {
-        onUnauthorized();
-      } else if (redirectTo && typeof window !== "undefined") {
-        redirect();
-      }
-    }
-  }, [hasAccess, isLoading, onUnauthorized, redirect, redirectTo]);
-  return {
-    hasAccess,
-    hasAnyRole,
-    hasAllRoles,
-    isLoading,
-    user,
-    checkAccess,
-    redirect
-  };
-}
-
-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] = React.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] = React.useState(() => {
-    if (!src || options?.shouldPreventLoad) {
-      return "idle";
-    }
-    if (typeof window === "undefined") {
-      return "loading";
-    }
-    return cachedScriptStatuses.get(src) ?? "loading";
-  });
-  React.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] = React.useState(false);
-  const target = React.useRef(null);
-  const originalStyle = React.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 = React.useCallback(
-    (value) => {
-      if (options.serializer) {
-        return options.serializer(value);
-      }
-      return JSON.stringify(value);
-    },
-    [options]
-  );
-  const deserializer = React.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 = React.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] = React.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 }));
-  });
-  React.useEffect(() => {
-    setStoredValue(readValue());
-  }, [key]);
-  const handleStorageChange = React.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] = React.useState(1);
-  const canGoToNextStep = currentStep + 1 <= maxStep;
-  const canGoToPrevStep = currentStep - 1 > 0;
-  const setStep = React.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 = React.useCallback(() => {
-    if (canGoToNextStep) {
-      setCurrentStep((step) => step + 1);
-    }
-  }, [canGoToNextStep]);
-  const goToPrevStep = React.useCallback(() => {
-    if (canGoToPrevStep) {
-      setCurrentStep((step) => step - 1);
-    }
-  }, [canGoToPrevStep]);
-  const reset = React.useCallback(() => {
-    setCurrentStep(1);
-  }, []);
-  return [
-    currentStep,
-    {
-      goToNextStep,
-      goToPrevStep,
-      canGoToNextStep,
-      canGoToPrevStep,
-      setStep,
-      reset
-    }
-  ];
-}
-
-function useSymbol() {
-  const [symbols, setSymbols] = React.useState([]);
-  const symbolsRef = React.useRef(/* @__PURE__ */ new Set());
-  const createSymbol = React.useCallback((description) => {
-    const newSymbol = Symbol(description);
-    setSymbols((prev) => [...prev, newSymbol]);
-    symbolsRef.current.add(newSymbol);
-    return newSymbol;
-  }, []);
-  const getGlobalSymbol = React.useCallback((key) => {
-    return Symbol.for(key);
-  }, []);
-  const getSymbolKey = React.useCallback((symbol) => {
-    return Symbol.keyFor(symbol);
-  }, []);
-  const isSymbol = React.useCallback((value) => {
-    return typeof value === "symbol";
-  }, []);
-  const getDescription = React.useCallback((symbol) => {
-    return symbol.description;
-  }, []);
-  const addSymbol = React.useCallback((symbol) => {
-    if (!symbolsRef.current.has(symbol)) {
-      setSymbols((prev) => [...prev, symbol]);
-      symbolsRef.current.add(symbol);
-    }
-  }, []);
-  const removeSymbol = React.useCallback((symbol) => {
-    if (symbolsRef.current.has(symbol)) {
-      setSymbols((prev) => prev.filter((s) => s !== symbol));
-      symbolsRef.current.delete(symbol);
-    }
-  }, []);
-  const clearSymbols = React.useCallback(() => {
-    setSymbols([]);
-    symbolsRef.current.clear();
-  }, []);
-  const wellKnownSymbols = React.useMemo(
-    () => ({
-      iterator: Symbol.iterator,
-      asyncIterator: Symbol.asyncIterator,
-      hasInstance: Symbol.hasInstance,
-      isConcatSpreadable: Symbol.isConcatSpreadable,
-      species: Symbol.species,
-      toPrimitive: Symbol.toPrimitive,
-      toStringTag: Symbol.toStringTag,
-      unscopables: Symbol.unscopables,
-      match: Symbol.match,
-      matchAll: Symbol.matchAll,
-      replace: Symbol.replace,
-      search: Symbol.search,
-      split: Symbol.split
-    }),
-    []
-  );
-  return {
-    createSymbol,
-    getGlobalSymbol,
-    getSymbolKey,
-    isSymbol,
-    getDescription,
-    wellKnownSymbols,
-    symbols,
-    addSymbol,
-    removeSymbol,
-    clearSymbols
-  };
-}
-
-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 = React.useRef(callback);
-  useIsomorphicLayoutEffect(() => {
-    savedCallback.current = callback;
-  }, [callback]);
-  React.useEffect(() => {
-    if (!delay && delay !== 0) {
-      return;
-    }
-    const id = setTimeout(() => {
-      savedCallback.current();
-    }, delay);
-    return () => {
-      clearTimeout(id);
-    };
-  }, [delay]);
-}
-
-function useToggle(defaultValue) {
-  const [value, setValue] = React.useState(!!defaultValue);
-  const toggle = React.useCallback(() => {
-    setValue((x) => !x);
-  }, []);
-  return [value, toggle, setValue];
-}
-
-const IS_SERVER = typeof window === "undefined";
-function useWindowSize(options = {}) {
-  let { initializeWithValue = true } = options;
-  if (IS_SERVER) {
-    initializeWithValue = false;
-  }
-  const [windowSize, setWindowSize] = React.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;
-}
-
-exports.ComputedRefImpl = ComputedRefImpl;
-exports.Dep = Dep;
-exports.Device = Device;
-exports.EffectFlags = EffectFlags;
-exports.Link = Link;
-exports.ReactiveFlags = ReactiveFlags;
-exports.RefImpl = RefImpl;
-exports.TrackOpTypes = TrackOpTypes;
-exports.TriggerOpTypes = TriggerOpTypes;
-exports.__DEV__ = __DEV__;
-exports.batch = batch;
-exports.breakpointsAntDesign = breakpointsAntDesign;
-exports.breakpointsBootstrapV5 = breakpointsBootstrapV5;
-exports.breakpointsSematic = breakpointsSematic;
-exports.breakpointsTailwind = breakpointsTailwind;
-exports.breakpointsVuetify = breakpointsVuetify;
-exports.computed = computed;
-exports.endBatch = endBatch;
-exports.errorMessage1 = errorMessage1;
-exports.extend = extend;
-exports.getActiveSub = getActiveSub;
-exports.isArray = isArray;
-exports.isFunction = isFunction;
-exports.isIntegerKey = isIntegerKey;
-exports.isMap = isMap;
-exports.isObject = isObject;
-exports.isSymbol = isSymbol;
-exports.kbdKeysMap = kbdKeysMap;
-exports.ref = ref;
-exports.refreshComputed = refreshComputed;
-exports.setActiveSub = setActiveSub;
-exports.shouldTrack = shouldTrack;
-exports.startBatch = startBatch;
-exports.targetMap = targetMap;
-exports.track = track;
-exports.useAudioRecorder = useAudioRecorder;
-exports.useBattery = useBatteryHook;
-exports.useBoolean = useBoolean;
-exports.useBreakpoint = useBreakpoint;
-exports.useClickAnyWhere = useClickAnyWhere;
-exports.useClickAway = useClickAway;
-exports.useComputed = useComputed;
-exports.useConferenceSystem = useConferenceSystem;
-exports.useCookie = useCookie;
-exports.useCopyToClipboard = useCopyToClipboard;
-exports.useCountdown = useCountdown;
-exports.useCounter = useCounter;
-exports.useDarkMode = useDarkMode;
-exports.useDebounceCallback = useDebounceCallback;
-exports.useDebounceValue = useDebounceValue;
-exports.useDelete = useDelete;
-exports.useDocumentTitle = useDocumentTitle;
-exports.useEventCallback = useEventCallback;
-exports.useEventListener = useEventListener;
-exports.useFetch = useFetch;
-exports.useForkRef = useForkRef;
-exports.useGet = useGet;
-exports.useHover = useHover;
-exports.useIndexedDB = useIndexedDB;
-exports.useIntersectionObserver = useIntersectionObserver;
-exports.useInterval = useInterval;
-exports.useIsClient = useIsClient;
-exports.useIsMounted = useIsMounted;
-exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;
-exports.useKbd = useKbd;
-exports.useLocalStorage = useLocalStorage;
-exports.useMap = useMap;
-exports.useMediaQuality = useMediaQuality;
-exports.useMediaQuery = useMediaQuery;
-exports.useMediaSession = useMediaSession;
-exports.useNetworkInformation = useNetworkInformation;
-exports.usePost = usePost;
-exports.usePut = usePut;
-exports.useReactive = useReactive;
-exports.useReadLocalStorage = useReadLocalStorage;
-exports.useResizeObserver = useResizeObserver;
-exports.useRoleGuard = useRoleGuard;
-exports.useSSR = useSSR;
-exports.useScreen = useScreen;
-exports.useScreenShare = useScreenShare;
-exports.useScript = useScript;
-exports.useScrollLock = useScrollLock;
-exports.useSessionStorage = useSessionStorage;
-exports.useStep = useStep;
-exports.useSymbol = useSymbol;
-exports.useTernaryDarkMode = useTernaryDarkMode;
-exports.useTimeout = useTimeout;
-exports.useToggle = useToggle;
-exports.useUnmount = useUnmount;
-exports.useUserMedia = useUserMedia;
-exports.useWindowSize = useWindowSize;
-exports.weAreServer = weAreServer;
-exports.withDefaults = withDefaults;