@therealtinhtute/baroiplayer 1.0.1 → 1.0.3

package/dist/hooks-BhW_i-9L.js

@@ -0,0 +1,2013 @@
+import * as re from "react";
+import N, { useEffect as q, useOptimistic as ce, useRef as W, useTransition as le, useCallback as A, useMemo as ue, useState as Q } from "react";
+import { c as H, d as pe, e as j, M as K } from "./context-Af84FynT.js";
+import { s as ve } from "./utils-nTO4AnHo.js";
+function Ie({ enabled: e = !0, state: t, controls: n, seekStep: s = 10, volumeStep: u = 0.1 }) {
+  const o = (a) => {
+    if (!e)
+      return;
+    const d = a.target;
+    if (!(d.tagName === "INPUT" || d.tagName === "TEXTAREA" || d.contentEditable === "true"))
+      switch (a.code) {
+        case "Space":
+        case "KeyK":
+          a.preventDefault(), n.toggle();
+          break;
+        case "KeyM":
+          a.preventDefault(), n.toggleMute();
+          break;
+        case "KeyF":
+          a.preventDefault(), n.toggleFullscreen();
+          break;
+        case "ArrowLeft":
+          a.preventDefault(), n.seek(Math.max(0, t.currentTime - s));
+          break;
+        case "ArrowRight":
+          a.preventDefault(), n.seek(Math.min(t.duration, t.currentTime + s));
+          break;
+        case "ArrowUp":
+          a.preventDefault(), n.setVolume(Math.min(1, t.volume + u));
+          break;
+        case "ArrowDown":
+          a.preventDefault(), n.setVolume(Math.max(0, t.volume - u));
+          break;
+        case "Digit0":
+        case "Digit1":
+        case "Digit2":
+        case "Digit3":
+        case "Digit4":
+        case "Digit5":
+        case "Digit6":
+        case "Digit7":
+        case "Digit8":
+        case "Digit9":
+          a.preventDefault();
+          const D = parseInt(a.code.replace("Digit", ""), 10) / 10;
+          n.seek(t.duration * D);
+          break;
+        case "Home":
+          a.preventDefault(), n.seek(0);
+          break;
+        case "End":
+          a.preventDefault(), n.seek(t.duration);
+          break;
+      }
+  };
+  return q(() => {
+    if (e)
+      return document.addEventListener("keydown", o), () => {
+        document.removeEventListener("keydown", o);
+      };
+  }, [e, o]), {
+    handleKeyDown: o
+  };
+}
+function ye(e, t) {
+  if (!t.optimistic)
+    return e;
+  switch (t.type) {
+    case "PLAY":
+      return { ...e, isPlaying: !0, error: null };
+    case "PAUSE":
+      return { ...e, isPlaying: !1 };
+    case "SEEK":
+      return { ...e, currentTime: t.detail };
+    case "SET_VOLUME":
+      return { ...e, volume: Math.max(0, Math.min(1, t.detail)) };
+    case "MUTE":
+      return { ...e, isMuted: !0 };
+    case "UNMUTE":
+      return { ...e, isMuted: !1 };
+    case "TOGGLE_MUTE":
+      return { ...e, isMuted: !e.isMuted };
+    case "ENTER_FULLSCREEN":
+      return { ...e, isFullscreen: !0 };
+    case "EXIT_FULLSCREEN":
+      return { ...e, isFullscreen: !1 };
+    case "SET_PLAYBACK_RATE":
+      return { ...e, playbackRate: t.detail };
+    case "TOGGLE_SUBTITLES":
+      return { ...e, subtitlesShowing: !e.subtitlesShowing };
+    case "PREVIEW_TIME":
+      return { ...e, previewTime: t.detail };
+    case "CLEAR_PREVIEW":
+      return {
+        ...e,
+        previewTime: null,
+        previewImage: null,
+        previewCoords: null
+      };
+    default:
+      return e;
+  }
+}
+function Ee(e) {
+  const t = N.useSyncExternalStore(e.subscribe, e.getState, e.getState), [n, s] = ce(t, ye), u = N.useCallback(async (d) => {
+    d.optimistic && s(d), await e.dispatchOptimistic(d);
+  }, [e, s]), o = N.useMemo(() => ({
+    // Play/Pause with immediate feedback
+    togglePlayPause: async () => {
+      const d = {
+        type: n.isPlaying ? "PAUSE" : "PLAY",
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(d);
+    },
+    // Volume control with immediate slider feedback
+    setVolumeOptimistic: async (d) => {
+      const S = {
+        type: "SET_VOLUME",
+        detail: Math.max(0, Math.min(1, d)),
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(S);
+    },
+    // Seek with immediate scrub feedback
+    seekOptimistic: async (d) => {
+      const S = {
+        type: "SEEK",
+        detail: d,
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(S);
+    },
+    // Mute toggle with immediate icon change
+    toggleMuteOptimistic: async () => {
+      const d = {
+        type: "TOGGLE_MUTE",
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(d);
+    },
+    // Fullscreen toggle with immediate layout change
+    toggleFullscreenOptimistic: async () => {
+      const d = {
+        type: n.isFullscreen ? "EXIT_FULLSCREEN" : "ENTER_FULLSCREEN",
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(d);
+    },
+    // Playback rate with immediate feedback
+    setPlaybackRateOptimistic: async (d) => {
+      const S = {
+        type: "SET_PLAYBACK_RATE",
+        detail: d,
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(S);
+    },
+    // Subtitle toggle with immediate visibility change
+    toggleSubtitlesOptimistic: async () => {
+      const d = {
+        type: "TOGGLE_SUBTITLES",
+        optimistic: !0,
+        timestamp: Date.now()
+      };
+      await u(d);
+    }
+  }), [n, u]), a = N.useMemo(() => ({
+    isPlaying: n.isPlaying,
+    currentTime: n.currentTime,
+    volume: n.volume,
+    isMuted: n.isMuted,
+    isFullscreen: n.isFullscreen,
+    playbackRate: n.playbackRate,
+    subtitlesShowing: n.subtitlesShowing,
+    previewTime: n.previewTime,
+    // Computed values
+    progress: n.duration > 0 ? n.currentTime / n.duration : 0,
+    formattedTime: me(n.currentTime),
+    formattedDuration: me(n.duration),
+    // State checks
+    canPlay: !n.isLoading && !n.error,
+    hasError: !!n.error,
+    isBuffering: n.isLoading
+  }), [n]);
+  return {
+    state: n,
+    actualState: t,
+    ...a,
+    ...o,
+    dispatchOptimistic: u
+  };
+}
+function me(e) {
+  if (!e || !isFinite(e))
+    return "0:00";
+  const t = Math.floor(e / 60), n = Math.floor(e % 60), s = Math.floor(t / 60);
+  return s > 0 ? `${s}:${String(t % 60).padStart(2, "0")}:${String(n).padStart(2, "0")}` : `${t}:${String(n).padStart(2, "0")}`;
+}
+function $(e, t) {
+  return ((n, s = !1) => {
+    const u = {
+      type: e,
+      detail: n,
+      optimistic: s,
+      timestamp: Date.now()
+    };
+    return s ? t.dispatchOptimistic(u) : (t.dispatch(u), Promise.resolve());
+  });
+}
+function we(e) {
+  const [t, n] = N.useState(e.getActionState());
+  return N.useEffect(() => e.subscribe(() => {
+    const u = e.getActionState();
+    n((o) => JSON.stringify(o) !== JSON.stringify(u) ? u : o);
+  }), [e]), t;
+}
+function Te(e) {
+  const t = N.useMemo(() => ({
+    // Playback actions
+    play: $(H.PLAY, e),
+    pause: $(H.PAUSE, e),
+    seek: $(H.SEEK, e),
+    // Volume actions  
+    setVolume: $(H.SET_VOLUME, e),
+    mute: $(H.MUTE, e),
+    unmute: $(H.UNMUTE, e),
+    toggleMute: $(H.TOGGLE_MUTE, e),
+    // Media state actions
+    setDuration: $(H.SET_DURATION, e),
+    setCurrentTime: $(H.SET_CURRENT_TIME, e),
+    setBuffered: $(H.SET_BUFFERED, e),
+    setLoading: $(H.SET_LOADING, e),
+    setError: $(H.SET_ERROR, e),
+    // Display actions
+    enterFullscreen: $(H.ENTER_FULLSCREEN, e),
+    exitFullscreen: $(H.EXIT_FULLSCREEN, e),
+    enterPiP: $(H.ENTER_PIP, e),
+    exitPiP: $(H.EXIT_PIP, e),
+    // Advanced actions
+    setPlaybackRate: $(H.SET_PLAYBACK_RATE, e),
+    setSubtitleTrack: $(H.SET_SUBTITLE_TRACK, e),
+    setRendition: $(H.SET_RENDITION, e),
+    toggleSubtitles: $(H.TOGGLE_SUBTITLES, e),
+    // Preview actions
+    previewTime: $(H.PREVIEW_TIME, e),
+    clearPreview: $(H.CLEAR_PREVIEW, e)
+  }), [e]), n = we(e), s = N.useMemo(() => ({
+    // These actions benefit from immediate UI feedback
+    togglePlayPause: async (o) => {
+      o ? await t.pause(!0) : await t.play(!0);
+    },
+    seekWithPreview: async (o) => {
+      await t.previewTime(o, !0), await t.seek(o, !0);
+    },
+    adjustVolume: async (o, a) => {
+      const d = Math.max(0, Math.min(1, a + o));
+      await t.setVolume(d, !0);
+    },
+    toggleFullscreenOptimistic: async (o) => {
+      o ? await t.exitFullscreen(!0) : await t.enterFullscreen(!0);
+    }
+  }), [t]), u = N.useCallback(async () => {
+    const { lastAction: o } = n;
+    o && n.error && await e.dispatchOptimistic({
+      ...o,
+      retryCount: (o.retryCount || 0) + 1
+    });
+  }, [e, n]);
+  return {
+    ...t,
+    ...s,
+    actionState: n,
+    retryLastAction: u,
+    isLoading: n.pending,
+    hasError: !!n.error,
+    errorMessage: n.error,
+    retryCount: n.retryCount
+  };
+}
+function Oe(e) {
+  const t = W(null), n = W(null), [s, u] = le(), [o, a] = le();
+  N.useRef(0);
+  const d = N.useRef(0), S = N.useRef(0);
+  W();
+  const D = W(0), R = pe(), g = "getOptimisticState" in R, r = j((i) => i.isPlaying), y = j((i) => i.currentTime), p = j((i) => i.duration), l = j((i) => i.volume), v = j((i) => i.isMuted), M = j((i) => i.isLoading), h = j((i) => i.isBuffering), c = j((i) => i.error), T = j((i) => i.buffered), E = j((i) => i.isFullscreen), b = R, w = g ? Ee(b) : null, m = g ? Te(b) : null, [z, F] = N.useState({
+    frameRate: 0,
+    averageRenderTime: 0,
+    droppedFrames: 0,
+    bufferHealth: 0
+  }), [O, P] = ce(l, (i, k) => Math.max(0, Math.min(1, k)));
+  ce(y, (i, k) => Math.max(0, Math.min(p || 0, k))), q(() => {
+    const i = t.current;
+    if (!i)
+      return;
+    const k = {
+      volume: e.volume,
+      muted: e.muted,
+      autoplay: e.autoPlay,
+      loop: e.loop,
+      preload: e.preload,
+      crossOrigin: e.crossOrigin
+    };
+    Object.entries(k).forEach(([B, Y]) => {
+      Y !== void 0 && (i[B] = Y);
+    }), i.setAttribute("preload", e.preloadStrategy === "eager" ? "auto" : "metadata"), e.bufferingStrategy === "aggressive" && i.setAttribute("buffered", "auto"), i instanceof HTMLVideoElement && (i.style.willChange = "transform", i.style.transform = "translateZ(0)");
+  }, [
+    e.volume,
+    e.muted,
+    e.autoPlay,
+    e.loop,
+    e.preload,
+    e.crossOrigin,
+    e.preloadStrategy,
+    e.bufferingStrategy
+  ]);
+  const L = A(() => {
+    const i = t.current;
+    if (!i)
+      return;
+    const k = performance.now();
+    if (e.enableTimeUpdateThrottling !== !1) {
+      if (k - D.current < (e.timeUpdateThrottleMs || 100))
+        return;
+      D.current = k;
+    }
+    u(() => {
+      g && m && m.setCurrentTime(i.currentTime);
+    });
+  }, [e.enableTimeUpdateThrottling, e.timeUpdateThrottleMs, g, m]), I = A(() => {
+    u(() => {
+      g && m && m.play(!0);
+    }), e.onPlay?.();
+  }, [g, m, e.onPlay]), U = A(() => {
+    u(() => {
+      g && m && m.pause(!0);
+    }), e.onPause?.();
+  }, [g, m, e.onPause]), _ = A(() => {
+    const i = t.current;
+    i && u(() => {
+      g && m && (m.setVolume(i.volume, !0), i.muted ? m.mute(!0) : m.unmute(!0));
+    });
+  }, [g, m]), C = A(() => {
+    a(() => {
+    });
+  }, []), ee = A(() => {
+  }, []), f = A(() => {
+    const i = t.current;
+    i && u(() => {
+      g && m && m.setBuffered(i.buffered);
+    });
+  }, [g, m]), V = A(() => {
+    const i = performance.now();
+    if (i - S.current > 0 && (d.current++, d.current >= 60)) {
+      const B = Math.round(d.current * 1e3 / (i - S.current));
+      F((Y) => ({
+        ...Y,
+        frameRate: B,
+        droppedFrames: Math.max(0, 60 - B)
+      })), d.current = 0, S.current = i;
+    }
+  }, []);
+  q(() => {
+    const i = t.current;
+    if (!i)
+      return;
+    const k = [
+      { event: "timeupdate", handler: L, passive: !0 },
+      { event: "play", handler: I },
+      { event: "pause", handler: U },
+      { event: "volumechange", handler: _ },
+      { event: "seeking", handler: C },
+      { event: "seeked", handler: ee },
+      { event: "progress", handler: f, passive: !0 },
+      { event: "loadedmetadata", handler: () => V() },
+      { event: "loadeddata", handler: () => V() }
+    ];
+    k.forEach(({ event: te, handler: ne, passive: ie }) => {
+      const oe = ie ? { passive: !0 } : {};
+      i.addEventListener(te, ne, oe);
+    });
+    let B;
+    const Y = () => {
+      V(), B = requestAnimationFrame(Y);
+    };
+    return e.enablePerformanceMonitoring && Y(), () => {
+      k.forEach(({ event: te, handler: ne }) => {
+        i.removeEventListener(te, ne);
+      }), B && cancelAnimationFrame(B);
+    };
+  }, [
+    L,
+    I,
+    U,
+    _,
+    C,
+    ee,
+    f,
+    V,
+    e.enablePerformanceMonitoring
+  ]);
+  const se = ue(() => {
+    const i = async () => {
+      const x = t.current;
+      if (x)
+        if (g && m)
+          await m.play(!0);
+        else
+          try {
+            await x.play();
+          } catch (X) {
+            console.error("Failed to play media:", X);
+          }
+    }, k = () => {
+      const x = t.current;
+      x && (g && m ? m.pause(!0) : x.pause());
+    };
+    return {
+      play: i,
+      pause: k,
+      toggle: () => {
+        r ? k() : i();
+      },
+      seek: (x) => {
+        const X = t.current;
+        if (!X)
+          return;
+        const Z = Math.max(0, Math.min(x, p || 0));
+        g && m ? a(() => {
+          m.seek(Z, !0);
+        }) : X.currentTime = Z;
+      },
+      setVolume: (x) => {
+        const X = t.current;
+        if (!X)
+          return;
+        const Z = Math.max(0, Math.min(1, x));
+        g && m ? (P(Z), u(() => {
+          m.setVolume(Z, !0);
+        })) : X.volume = Z;
+      },
+      toggleMute: () => {
+        const x = t.current;
+        x && (g && m ? m.toggleMute(!0) : x.muted = !x.muted);
+      },
+      enterFullscreen: async () => {
+        const x = n.current;
+        if (!(!x || !document.fullscreenEnabled))
+          try {
+            await x.requestFullscreen(), g && m && m.enterFullscreen(!0);
+          } catch (X) {
+            console.error("Failed to enter fullscreen:", X);
+          }
+      },
+      exitFullscreen: async () => {
+        if (document.fullscreenElement)
+          try {
+            await document.exitFullscreen(), g && m && m.exitFullscreen(!0);
+          } catch (x) {
+            console.error("Failed to exit fullscreen:", x);
+          }
+      }
+    };
+  }, [
+    r,
+    p,
+    g,
+    m,
+    u,
+    a,
+    P
+  ]), ae = ue(() => ({
+    isPlaying: w?.isPlaying ?? r,
+    currentTime: w?.currentTime ?? y,
+    duration: w?.duration ?? p,
+    volume: w?.volume ?? O,
+    isMuted: w?.isMuted ?? v,
+    isLoading: w?.isBuffering ?? M,
+    isBuffering: w?.isBuffering ?? h,
+    error: w?.error ?? c,
+    buffered: w?.buffered ?? T,
+    isFullscreen: w?.isFullscreen ?? E,
+    progress: p > 0 ? y / p : 0,
+    isTransitioning: s || o,
+    canPlay: !M && !h && !c
+  }), [
+    w,
+    r,
+    y,
+    p,
+    O,
+    v,
+    M,
+    h,
+    c,
+    T,
+    E,
+    s,
+    o
+  ]);
+  return {
+    // Refs
+    mediaRef: t,
+    containerRef: n,
+    // State
+    state: ae,
+    actualState: w?.actualState,
+    // Controls
+    controls: se,
+    // Performance metrics
+    performanceMetrics: z,
+    isTransitioning: s || o,
+    // Enhanced features
+    actions: w?.actions,
+    actionState: w?.actionState,
+    // Optimistic features
+    optimisticState: w,
+    isEnhanced: g
+  };
+}
+function Ue(e = {}) {
+  const {
+    maxMemoryUsage: t = 100,
+    // 100MB default
+    cleanupInterval: n = 3e4,
+    // 30 seconds default
+    enableGC: s = !0,
+    monitorMemory: u = !0
+  } = e;
+  W();
+  const o = W(/* @__PURE__ */ new Set()), a = W(/* @__PURE__ */ new Map()), d = W(/* @__PURE__ */ new Set()), S = W(/* @__PURE__ */ new Set()), D = A(() => {
+    if (typeof window > "u" || !("memory" in performance))
+      return { used: 0, total: 0, limit: 0 };
+    const h = performance.memory;
+    return {
+      used: h.usedJSHeapSize,
+      total: h.totalJSHeapSize,
+      limit: h.jsHeapSizeLimit
+    };
+  }, []), [R, g] = N.useState({
+    used: 0,
+    total: 0,
+    limit: 0,
+    usage: 0,
+    isHighUsage: !1
+  });
+  q(() => {
+    if (!u)
+      return;
+    const h = () => {
+      const T = D(), E = T.used / 1024 / 1024, b = E > t;
+      g({
+        ...T,
+        usage: E,
+        isHighUsage: b
+      }), b && s && r();
+    };
+    h();
+    const c = p(h, n);
+    return d.current.add(c), () => {
+      clearInterval(c), d.current.delete(c);
+    };
+  }, [u, D, t, s, n]);
+  const r = A(() => {
+    d.current.forEach((h) => {
+      clearTimeout(h);
+    }), d.current.clear(), S.current.forEach((h) => {
+      cancelAnimationFrame(h);
+    }), S.current.clear(), o.current.forEach((h) => {
+      h.disconnect();
+    }), o.current.clear(), a.current.forEach((h, c) => {
+      h.forEach(({ event: T, handler: E }) => {
+        c.removeEventListener(T, E);
+      });
+    }), a.current.clear(), s && "gc" in window && window.gc();
+  }, [s]), y = A((h, c, T, E) => (h.addEventListener(c, T, E), a.current.has(h) || a.current.set(h, []), a.current.get(h).push({ event: c, handler: T }), () => {
+    h.removeEventListener(c, T);
+    const b = a.current.get(h);
+    if (b) {
+      const w = b.findIndex((m) => m.event === c && m.handler === T);
+      w > -1 && b.splice(w, 1), b.length === 0 && a.current.delete(h);
+    }
+  }), []), p = A((h, c) => {
+    const T = p(h, c);
+    return d.current.add(T), () => {
+      clearInterval(T), d.current.delete(T);
+    };
+  }, []), l = A((h, c) => {
+    const T = l(h, c);
+    return d.current.add(T), () => {
+      clearTimeout(T), d.current.delete(T);
+    };
+  }, []), v = A((h) => {
+    const c = v(h);
+    return S.current.add(c), () => {
+      cancelAnimationFrame(c), S.current.delete(c);
+    };
+  }, []), M = A((h) => (o.current.add(h), () => {
+    h.disconnect(), o.current.delete(h);
+  }), []);
+  return q(() => () => {
+    r();
+  }, [r]), {
+    // Memory stats
+    memoryStats: R,
+    getMemoryUsage: D,
+    // Cleanup functions
+    performCleanup: r,
+    // Safe API functions
+    addEventListener: y,
+    setInterval: p,
+    setTimeout: l,
+    requestAnimationFrame: v,
+    addObserver: M,
+    // Utilities
+    formatBytes: (h) => {
+      if (h === 0)
+        return "0 Bytes";
+      const c = 1024, T = ["Bytes", "KB", "MB", "GB"], E = Math.floor(Math.log(h) / Math.log(c));
+      return parseFloat((h / Math.pow(c, E)).toFixed(2)) + " " + T[E];
+    }
+  };
+}
+function be({
+  enabled: e = !0,
+  state: t,
+  controls: n,
+  seekStep: s = 10,
+  volumeStep: u = 0.1
+}) {
+  const o = (a) => {
+    if (!e) return;
+    const d = a.target;
+    if (!(d.tagName === "INPUT" || d.tagName === "TEXTAREA" || d.contentEditable === "true"))
+      switch (a.code) {
+        case "Space":
+        case "KeyK":
+          a.preventDefault(), n.toggle();
+          break;
+        case "KeyM":
+          a.preventDefault(), n.toggleMute();
+          break;
+        case "KeyF":
+          a.preventDefault(), n.toggleFullscreen();
+          break;
+        case "ArrowLeft":
+          a.preventDefault(), n.seek(Math.max(0, t.currentTime - s));
+          break;
+        case "ArrowRight":
+          a.preventDefault(), n.seek(Math.min(t.duration, t.currentTime + s));
+          break;
+        case "ArrowUp":
+          a.preventDefault(), n.setVolume(Math.min(1, t.volume + u));
+          break;
+        case "ArrowDown":
+          a.preventDefault(), n.setVolume(Math.max(0, t.volume - u));
+          break;
+        case "Digit0":
+        case "Digit1":
+        case "Digit2":
+        case "Digit3":
+        case "Digit4":
+        case "Digit5":
+        case "Digit6":
+        case "Digit7":
+        case "Digit8":
+        case "Digit9":
+          a.preventDefault();
+          const D = parseInt(a.code.replace("Digit", ""), 10) / 10;
+          n.seek(t.duration * D);
+          break;
+        case "Home":
+          a.preventDefault(), n.seek(0);
+          break;
+        case "End":
+          a.preventDefault(), n.seek(t.duration);
+          break;
+      }
+  };
+  return q(() => {
+    if (e)
+      return document.addEventListener("keydown", o), () => {
+        document.removeEventListener("keydown", o);
+      };
+  }, [e, o]), {
+    handleKeyDown: o
+  };
+}
+const Ve = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  useKeyboardControls: be
+}, Symbol.toStringTag, { value: "Module" }));
+function G(e, t) {
+  return ((n, s = !1) => {
+    const u = {
+      type: e,
+      detail: n,
+      optimistic: s,
+      timestamp: Date.now()
+    };
+    return s ? t.dispatchOptimistic(u) : (t.dispatch(u), Promise.resolve());
+  });
+}
+function Se(e) {
+  const [t, n] = N.useState(e.getActionState());
+  return N.useEffect(() => e.subscribe(() => {
+    const u = e.getActionState();
+    n(
+      (o) => JSON.stringify(o) !== JSON.stringify(u) ? u : o
+    );
+  }), [e]), t;
+}
+function _e(e) {
+  const t = N.useMemo(() => ({
+    // Playback actions
+    play: G(K.PLAY, e),
+    pause: G(K.PAUSE, e),
+    seek: G(K.SEEK, e),
+    // Volume actions  
+    setVolume: G(K.SET_VOLUME, e),
+    mute: G(K.MUTE, e),
+    unmute: G(K.UNMUTE, e),
+    toggleMute: G(K.TOGGLE_MUTE, e),
+    // Media state actions
+    setDuration: G(K.SET_DURATION, e),
+    setCurrentTime: G(K.SET_CURRENT_TIME, e),
+    setBuffered: G(K.SET_BUFFERED, e),
+    setLoading: G(K.SET_LOADING, e),
+    setError: G(K.SET_ERROR, e),
+    // Display actions
+    enterFullscreen: G(K.ENTER_FULLSCREEN, e),
+    exitFullscreen: G(K.EXIT_FULLSCREEN, e),
+    enterPiP: G(K.ENTER_PIP, e),
+    exitPiP: G(K.EXIT_PIP, e),
+    // Advanced actions
+    setPlaybackRate: G(K.SET_PLAYBACK_RATE, e),
+    setSubtitleTrack: G(K.SET_SUBTITLE_TRACK, e),
+    setRendition: G(K.SET_RENDITION, e),
+    toggleSubtitles: G(K.TOGGLE_SUBTITLES, e),
+    // Preview actions
+    previewTime: G(K.PREVIEW_TIME, e),
+    clearPreview: G(K.CLEAR_PREVIEW, e)
+  }), [e]), n = Se(e), s = N.useMemo(() => ({
+    // These actions benefit from immediate UI feedback
+    togglePlayPause: async (o) => {
+      o ? await t.pause(!0) : await t.play(!0);
+    },
+    seekWithPreview: async (o) => {
+      await t.previewTime(o, !0), await t.seek(o, !0);
+    },
+    adjustVolume: async (o, a) => {
+      const d = Math.max(0, Math.min(1, a + o));
+      await t.setVolume(d, !0);
+    },
+    toggleFullscreenOptimistic: async (o) => {
+      o ? await t.exitFullscreen(!0) : await t.enterFullscreen(!0);
+    }
+  }), [t]), u = N.useCallback(async () => {
+    const { lastAction: o } = n;
+    o && n.error && await e.dispatchOptimistic({
+      ...o,
+      retryCount: (o.retryCount || 0) + 1
+    });
+  }, [e, n]);
+  return {
+    ...t,
+    ...s,
+    actionState: n,
+    retryLastAction: u,
+    isLoading: n.pending,
+    hasError: !!n.error,
+    errorMessage: n.error,
+    retryCount: n.retryCount
+  };
+}
+function Me() {
+  const [e, t] = Q({
+    isPlaying: !1,
+    currentTime: 0,
+    duration: 0,
+    volume: 1,
+    isMuted: !1,
+    isLoading: !1,
+    isFullscreen: !1,
+    error: null,
+    buffered: null
+  }), n = (r) => {
+    t((y) => ({ ...y, ...r }));
+  };
+  return {
+    state: e,
+    updateState: n,
+    setPlaying: (r) => {
+      n({ isPlaying: r });
+    },
+    setCurrentTime: (r) => {
+      n({ currentTime: r });
+    },
+    setDuration: (r) => {
+      n({ duration: r });
+    },
+    setVolume: (r) => {
+      n({ volume: Math.max(0, Math.min(1, r)) });
+    },
+    setMuted: (r) => {
+      n({ isMuted: r });
+    },
+    setLoading: (r) => {
+      n({ isLoading: r });
+    },
+    setFullscreen: (r) => {
+      n({ isFullscreen: r });
+    },
+    setError: (r) => {
+      n({ error: r });
+    },
+    setBuffered: (r) => {
+      n({ buffered: r });
+    }
+  };
+}
+function Le(e) {
+  const t = W(null), n = W(null), {
+    state: s,
+    setPlaying: u,
+    setCurrentTime: o,
+    setDuration: a,
+    setVolume: d,
+    setMuted: S,
+    setLoading: D,
+    setFullscreen: R,
+    setError: g,
+    setBuffered: r
+  } = Me();
+  q(() => {
+    const f = t.current;
+    f && (e.volume !== void 0 && (f.volume = e.volume, d(e.volume)), e.muted !== void 0 && (f.muted = e.muted, S(e.muted)), e.autoPlay !== void 0 && (f.autoplay = e.autoPlay), e.loop !== void 0 && (f.loop = e.loop), e.preload !== void 0 && (f.preload = e.preload), e.crossOrigin !== void 0 && (f.crossOrigin = e.crossOrigin));
+  }, [e, d, S]);
+  const y = () => {
+    u(!0), e.onPlay?.();
+  }, p = () => {
+    u(!1), e.onPause?.();
+  }, l = () => {
+    const f = t.current;
+    f && (o(f.currentTime), e.onTimeUpdate?.(f.currentTime));
+  }, v = () => {
+    const f = t.current;
+    f && (a(f.duration), e.onDurationChange?.(f.duration));
+  }, M = () => {
+    const f = t.current;
+    f && (d(f.volume), S(f.muted), e.onVolumeChange?.(f.volume));
+  }, h = () => {
+    D(!0), g(null), e.onLoadStart?.();
+  }, c = () => {
+    D(!1), e.onLoadedData?.();
+  }, T = () => {
+    const f = t.current;
+    if (!f) return;
+    const V = f.error?.message || "An error occurred while loading the media";
+    g(V), D(!1), e.onError?.(V);
+  }, E = () => {
+    u(!1), e.onEnded?.();
+  }, b = () => {
+    const f = t.current;
+    f && r(f.buffered);
+  };
+  q(() => {
+    const f = t.current;
+    if (f)
+      return f.addEventListener("play", y), f.addEventListener("pause", p), f.addEventListener("timeupdate", l), f.addEventListener("durationchange", v), f.addEventListener("volumechange", M), f.addEventListener("loadstart", h), f.addEventListener("loadeddata", c), f.addEventListener("error", T), f.addEventListener("ended", E), f.addEventListener("progress", b), () => {
+        f.removeEventListener("play", y), f.removeEventListener("pause", p), f.removeEventListener("timeupdate", l), f.removeEventListener("durationchange", v), f.removeEventListener("volumechange", M), f.removeEventListener("loadstart", h), f.removeEventListener("loadeddata", c), f.removeEventListener("error", T), f.removeEventListener("ended", E), f.removeEventListener("progress", b);
+      };
+  }, [
+    y,
+    p,
+    l,
+    v,
+    M,
+    h,
+    c,
+    T,
+    E,
+    b
+  ]);
+  const w = async () => {
+    const f = t.current;
+    if (f)
+      try {
+        await f.play();
+      } catch (V) {
+        console.error("Failed to play media:", V), g("Failed to play media");
+      }
+  }, m = () => {
+    const f = t.current;
+    f && f.pause();
+  }, z = () => {
+    s.isPlaying ? m() : w();
+  }, F = (f) => {
+    const V = t.current;
+    V && (V.currentTime = Math.max(0, Math.min(f, V.duration || 0)));
+  }, O = (f) => {
+    const V = t.current;
+    if (!V) return;
+    const se = Math.max(0, Math.min(1, f));
+    V.volume = se;
+  }, P = () => {
+    const f = t.current;
+    f && (f.muted = !0);
+  }, L = () => {
+    const f = t.current;
+    f && (f.muted = !1);
+  }, I = () => {
+    const f = t.current;
+    f && (f.muted = !f.muted);
+  }, U = async () => {
+    const f = n.current;
+    if (!(!f || !document.fullscreenEnabled))
+      try {
+        await f.requestFullscreen(), R(!0);
+      } catch (V) {
+        console.error("Failed to enter fullscreen:", V);
+      }
+  }, _ = async () => {
+    if (document.fullscreenElement)
+      try {
+        await document.exitFullscreen(), R(!1);
+      } catch (f) {
+        console.error("Failed to exit fullscreen:", f);
+      }
+  }, C = () => {
+    document.fullscreenElement ? _() : U();
+  };
+  return q(() => {
+    const f = () => {
+      R(!!document.fullscreenElement);
+    };
+    return document.addEventListener("fullscreenchange", f), () => {
+      document.removeEventListener("fullscreenchange", f);
+    };
+  }, [R]), {
+    state: s,
+    controls: {
+      play: w,
+      pause: m,
+      toggle: z,
+      seek: F,
+      setVolume: O,
+      mute: P,
+      unmute: L,
+      toggleMute: I,
+      enterFullscreen: U,
+      exitFullscreen: _,
+      toggleFullscreen: C
+    },
+    mediaRef: t,
+    containerRef: n
+  };
+}
+const J = {
+  mobile: 768,
+  desktop: 1280
+};
+function fe() {
+  if (typeof window > "u") return "unknown";
+  const e = window.navigator.userAgent.toLowerCase();
+  return /iphone|ipad|ipod/.test(e) ? "ios" : /android/.test(e) ? "android" : /windows|mac|linux/.test(e) ? "desktop" : "unknown";
+}
+function ge() {
+  return typeof window > "u" ? !1 : "ontouchstart" in window || navigator.maxTouchPoints > 0 || // @ts-ignore - for older browsers
+  navigator.msMaxTouchPoints > 0;
+}
+function he() {
+  return typeof window > "u" ? !1 : "vibrate" in navigator || // @ts-ignore - for newer Vibration API
+  "vibration" in navigator || // @ts-ignore - for iOS haptic feedback
+  "ondevicemotion" in window;
+}
+function de() {
+  const [e, t] = re.useState(() => {
+    if (typeof window > "u")
+      return {
+        isMobile: !1,
+        isTablet: !1,
+        isDesktop: !0,
+        isTouchDevice: !1,
+        platform: "unknown",
+        supportsHaptics: !1,
+        screenSize: { width: 1920, height: 1080 },
+        orientation: "landscape"
+      };
+    const n = window.innerWidth, s = window.innerHeight;
+    return {
+      isMobile: n < J.mobile,
+      isTablet: n >= J.mobile && n < J.desktop,
+      isDesktop: n >= J.desktop,
+      isTouchDevice: ge(),
+      platform: fe(),
+      supportsHaptics: he(),
+      screenSize: { width: n, height: s },
+      orientation: n > s ? "landscape" : "portrait"
+    };
+  });
+  return re.useEffect(() => {
+    const n = () => {
+      const a = window.innerWidth, d = window.innerHeight;
+      t({
+        isMobile: a < J.mobile,
+        isTablet: a >= J.mobile && a < J.desktop,
+        isDesktop: a >= J.desktop,
+        isTouchDevice: ge(),
+        platform: fe(),
+        supportsHaptics: he(),
+        screenSize: { width: a, height: d },
+        orientation: a > d ? "landscape" : "portrait"
+      });
+    };
+    window.addEventListener("resize", n), window.addEventListener("orientationchange", n);
+    const s = window.matchMedia(`(max-width: ${J.mobile - 1}px)`), u = window.matchMedia(`(min-width: ${J.mobile}px) and (max-width: ${J.desktop - 1}px)`), o = window.matchMedia(`(min-width: ${J.desktop}px)`);
+    return s.addEventListener("change", n), u.addEventListener("change", n), o.addEventListener("change", n), () => {
+      window.removeEventListener("resize", n), window.removeEventListener("orientationchange", n), s.removeEventListener("change", n), u.removeEventListener("change", n), o.removeEventListener("change", n);
+    };
+  }, []), e;
+}
+function Be() {
+  const { platform: e, isMobile: t } = de();
+  re.useEffect(() => {
+    if (t) {
+      if (e === "ios") {
+        const n = (s) => {
+          s.touches.length > 1 && s.preventDefault();
+        };
+        return document.addEventListener("touchstart", n, { passive: !1 }), document.body.style.webkitOverflowScrolling = "touch", () => {
+          document.removeEventListener("touchstart", n);
+        };
+      }
+      e === "android" && (document.body.style.touchAction = "manipulation"), document.documentElement.style.setProperty("--webkit-transform", "translateZ(0)"), document.documentElement.style.setProperty("--transform", "translateZ(0)");
+    }
+  }, [e, t]);
+}
+function ke() {
+  const { supportsHaptics: e } = de();
+  return { triggerHaptic: re.useCallback((n = "light") => {
+    if (!e) return;
+    const u = {
+      light: [10],
+      medium: [20],
+      heavy: [30],
+      success: [10, 10, 10],
+      warning: [20, 20],
+      error: [50, 20, 50]
+    }[n];
+    "vibrate" in navigator && navigator.vibrate(u);
+  }, [e]), supportsHaptics: e };
+}
+const Pe = {
+  enabledGestures: ["tap", "double-tap", "long-press", "swipe-left", "swipe-right", "swipe-up", "swipe-down", "pinch-in", "pinch-out"],
+  tapThreshold: 200,
+  doubleTapThreshold: 300,
+  longPressThreshold: 500,
+  swipeThreshold: 50,
+  swipeVelocityThreshold: 0.5,
+  pinchThreshold: 0.1,
+  rotationThreshold: 15,
+  enableHapticFeedback: !0
+};
+function Fe(e, t, n = {}) {
+  const s = { ...Pe, ...n }, { isTouchDevice: u } = de(), { triggerHaptic: o } = ke(), a = re.useRef({
+    isTracking: !1,
+    touches: [],
+    startTouches: []
+  }), d = (p) => ({
+    id: p.identifier,
+    x: p.clientX,
+    y: p.clientY,
+    timestamp: Date.now()
+  }), S = (p, l) => Math.sqrt(Math.pow(l.x - p.x, 2) + Math.pow(l.y - p.y, 2)), D = (p, l) => {
+    const v = Math.max(l.timestamp - p.timestamp, 1);
+    return {
+      x: (l.x - p.x) / v,
+      y: (l.y - p.y) / v
+    };
+  }, R = (p, l, v, M = {}) => ({
+    type: p,
+    startPoint: { x: l.x, y: l.y },
+    currentPoint: { x: v.x, y: v.y },
+    duration: v.timestamp - l.timestamp,
+    target: e.current,
+    preventDefault: () => {
+    },
+    ...M
+  }), g = re.useCallback((p) => {
+    if (!s.enabledGestures.length) return;
+    const l = Array.from(p.touches).map(d), v = a.current;
+    v.isTracking = !0, v.touches = l, v.startTouches = [...l], v.longPressTimer && clearTimeout(v.longPressTimer), l.length === 1 && s.enabledGestures.includes("long-press") && (v.longPressTimer = setTimeout(() => {
+      if (v.touches.length === 1 && l[0]) {
+        const M = R("long-press", l[0], l[0]);
+        t(M), s.enableHapticFeedback && o("heavy");
+      }
+    }, s.longPressThreshold)), l.length === 2 && l[0] && l[1] && (v.initialDistance = S(l[0], l[1]), v.initialScale = 1, v.lastScale = 1);
+  }, [s, t, o]), r = re.useCallback((p) => {
+    const l = a.current;
+    if (!l.isTracking) return;
+    const v = Array.from(p.touches).map(d);
+    if (l.touches = v, v.length === 2 && l.initialDistance && v[0] && v[1]) {
+      const M = S(v[0], v[1]), h = M / l.initialDistance;
+      if (Math.abs(h - (l.lastScale || 1)) > s.pinchThreshold) {
+        const T = h > (l.lastScale || 1) ? "pinch-out" : "pinch-in";
+        if (s.enabledGestures.includes(T)) {
+          const E = {
+            x: (v[0].x + v[1].x) / 2,
+            y: (v[0].y + v[1].y) / 2,
+            timestamp: Date.now()
+          }, b = {
+            x: ((l.startTouches[0]?.x ?? 0) + (l.startTouches[1]?.x ?? 0)) / 2,
+            y: ((l.startTouches[0]?.y ?? 0) + (l.startTouches[1]?.y ?? 0)) / 2,
+            timestamp: l.startTouches[0]?.timestamp ?? Date.now()
+          }, w = R(T, b, E, {
+            scale: h,
+            distance: M
+          });
+          t(w), l.lastScale = h;
+        }
+      }
+    }
+    if (l.longPressTimer && v.length === 1 && l.startTouches[0] && v[0]) {
+      const M = l.startTouches[0], h = v[0];
+      S(M, h) > s.swipeThreshold && (clearTimeout(l.longPressTimer), l.longPressTimer = void 0);
+    }
+  }, [s, t]), y = re.useCallback((p) => {
+    const l = a.current;
+    if (!l.isTracking) return;
+    const v = Array.from(p.changedTouches).map(d), M = Date.now();
+    if (l.longPressTimer && (clearTimeout(l.longPressTimer), l.longPressTimer = void 0), l.startTouches.length === 1 && v.length === 1 && l.startTouches[0] && v[0]) {
+      const h = l.startTouches[0], c = v[0], T = S(h, c), E = c.timestamp - h.timestamp;
+      if (T > s.swipeThreshold) {
+        const b = D(h, c), w = Math.abs(b.x), m = Math.abs(b.y);
+        if (w > s.swipeVelocityThreshold || m > s.swipeVelocityThreshold) {
+          let z;
+          if (w > m ? z = b.x > 0 ? "swipe-right" : "swipe-left" : z = b.y > 0 ? "swipe-down" : "swipe-up", s.enabledGestures.includes(z)) {
+            const F = R(z, h, c, {
+              velocity: b,
+              distance: T
+            });
+            t(F), s.enableHapticFeedback && o("light");
+          }
+        }
+      } else if (E < s.tapThreshold && T < s.swipeThreshold)
+        if (l.lastTap && M - l.lastTap.timestamp < s.doubleTapThreshold && S({ ...l.lastTap.point }, c) < s.swipeThreshold) {
+          if (s.enabledGestures.includes("double-tap")) {
+            const b = R("double-tap", h, c);
+            t(b), s.enableHapticFeedback && o("medium");
+          }
+          l.lastTap = void 0;
+        } else {
+          if (s.enabledGestures.includes("tap")) {
+            const b = R("tap", h, c);
+            t(b), s.enableHapticFeedback && o("light");
+          }
+          l.lastTap = {
+            timestamp: M,
+            point: { x: c.x, y: c.y }
+          };
+        }
+    }
+    p.touches.length === 0 && (l.isTracking = !1, l.touches = [], l.startTouches = [], l.initialDistance = void 0, l.initialScale = void 0, l.lastScale = void 0);
+  }, [s, t, o]);
+  return re.useEffect(() => {
+    const p = e.current;
+    if (!(!p || !u))
+      return p.addEventListener("touchstart", g, { passive: !1 }), p.addEventListener("touchmove", r, { passive: !1 }), p.addEventListener("touchend", y, { passive: !1 }), p.addEventListener("touchcancel", y, { passive: !1 }), () => {
+        p.removeEventListener("touchstart", g), p.removeEventListener("touchmove", r), p.removeEventListener("touchend", y), p.removeEventListener("touchcancel", y);
+      };
+  }, [g, r, y, u]), {
+    isGestureEnabled: u && s.enabledGestures.length > 0
+  };
+}
+function Ne(e, t) {
+  const n = re.useCallback((u) => {
+    const { type: o, distance: a, scale: d } = u;
+    switch (o) {
+      case "double-tap":
+        t.onPlayPause?.();
+        break;
+      case "swipe-left":
+        const S = Math.min((a || 0) / 10, 30);
+        t.onSeek?.("backward", S);
+        break;
+      case "swipe-right":
+        const D = Math.min((a || 0) / 10, 30);
+        t.onSeek?.("forward", D);
+        break;
+      case "swipe-up":
+        if (u.startPoint.x > (e.current?.clientWidth || 0) / 2) {
+          const R = Math.min((a || 0) / 100, 0.2);
+          t.onVolumeChange?.("up", R);
+        }
+        break;
+      case "swipe-down":
+        if (u.startPoint.x > (e.current?.clientWidth || 0) / 2) {
+          const R = Math.min((a || 0) / 100, 0.2);
+          t.onVolumeChange?.("down", R);
+        }
+        break;
+      case "pinch-out":
+        t.onZoom?.(d || 1);
+        break;
+      case "pinch-in":
+        t.onZoom?.(d || 1);
+        break;
+      case "long-press":
+        t.onToggleFullscreen?.();
+        break;
+    }
+  }, [t, e]);
+  return Fe(e, n, {
+    enabledGestures: ["tap", "double-tap", "long-press", "swipe-left", "swipe-right", "swipe-up", "swipe-down", "pinch-in", "pinch-out"],
+    enableHapticFeedback: !0,
+    swipeThreshold: 30,
+    swipeVelocityThreshold: 0.3
+  });
+}
+function He(e) {
+  const t = W(null), [n, s] = Q({
+    isPlaying: !1,
+    currentTime: 0,
+    duration: 0,
+    volume: 1,
+    isMuted: !1,
+    isFullscreen: !1,
+    isLoading: !0,
+    isSeeking: !1,
+    isBuffering: !1,
+    bufferedRanges: []
+  });
+  return q(() => {
+    const r = t.current;
+    if (!r) return;
+    const y = () => {
+      s((F) => ({ ...F, currentTime: r.currentTime }));
+    }, p = () => {
+      s((F) => ({ ...F, duration: r.duration }));
+    }, l = () => {
+      s((F) => ({ ...F, isPlaying: !0, isBuffering: !1 }));
+    }, v = () => {
+      s((F) => ({ ...F, isPlaying: !1 }));
+    }, M = () => {
+      s((F) => ({
+        ...F,
+        volume: r.volume,
+        isMuted: r.muted
+      }));
+    }, h = () => {
+      s((F) => ({ ...F, isLoading: !0 }));
+    }, c = () => {
+      s((F) => ({ ...F, isLoading: !1 }));
+    }, T = () => {
+      s((F) => ({ ...F, isSeeking: !0 }));
+    }, E = () => {
+      s((F) => ({ ...F, isSeeking: !1 }));
+    }, b = () => {
+      s((F) => ({ ...F, isBuffering: !0 }));
+    }, w = () => {
+      s((F) => ({ ...F, isBuffering: !1, isLoading: !1 }));
+    }, m = () => {
+      s((F) => ({ ...F, isLoading: !1, isBuffering: !1 }));
+    }, z = () => {
+      if (!r.buffered || r.buffered.length === 0 || r.duration === 0) {
+        s((O) => ({ ...O, bufferedRanges: [] }));
+        return;
+      }
+      const F = [];
+      for (let O = 0; O < r.buffered.length; O++) {
+        const P = r.buffered.start(O), L = r.buffered.end(O);
+        F.push({
+          start: P,
+          end: L,
+          percentage: (L - P) / r.duration * 100
+        });
+      }
+      s((O) => ({ ...O, bufferedRanges: F }));
+    };
+    return r.addEventListener("timeupdate", y), r.addEventListener("loadedmetadata", p), r.addEventListener("play", l), r.addEventListener("pause", v), r.addEventListener("volumechange", M), r.addEventListener("loadstart", h), r.addEventListener("loadeddata", c), r.addEventListener("seeking", T), r.addEventListener("seeked", E), r.addEventListener("waiting", b), r.addEventListener("playing", w), r.addEventListener("canplay", m), r.addEventListener("progress", z), () => {
+      r.removeEventListener("timeupdate", y), r.removeEventListener("loadedmetadata", p), r.removeEventListener("play", l), r.removeEventListener("pause", v), r.removeEventListener("volumechange", M), r.removeEventListener("loadstart", h), r.removeEventListener("loadeddata", c), r.removeEventListener("seeking", T), r.removeEventListener("seeked", E), r.removeEventListener("waiting", b), r.removeEventListener("playing", w), r.removeEventListener("canplay", m), r.removeEventListener("progress", z);
+    };
+  }, []), {
+    videoRef: t,
+    state: n,
+    controls: {
+      togglePlay: () => {
+        const r = t.current;
+        r && (n.isPlaying ? r.pause() : r.play());
+      },
+      seekForward: (r = 10) => {
+        const y = t.current;
+        y && (y.currentTime = Math.min(n.duration, y.currentTime + r));
+      },
+      seekBackward: (r = 10) => {
+        const y = t.current;
+        y && (y.currentTime = Math.max(0, y.currentTime - r));
+      },
+      toggleMute: () => {
+        const r = t.current;
+        r && (r.muted = !n.isMuted);
+      },
+      setVolume: (r) => {
+        const y = t.current;
+        y && (y.volume = r, r > 0 && n.isMuted && (y.muted = !1));
+      },
+      toggleFullscreen: () => {
+        const r = e.current;
+        r && (n.isFullscreen ? document.exitFullscreen && document.exitFullscreen() : r.requestFullscreen && r.requestFullscreen(), s((y) => ({ ...y, isFullscreen: !y.isFullscreen })));
+      },
+      seekTo: (r) => {
+        const y = t.current;
+        !y || n.duration === 0 || (y.currentTime = Math.max(0, Math.min(n.duration, r)));
+      }
+    }
+  };
+}
+function De({
+  subtitleSrc: e,
+  subtitleTracks: t = [],
+  defaultFontSize: n = "medium",
+  onLoadError: s
+} = {}) {
+  const [u, o] = Q(!1), [a, d] = Q([]), [S, D] = Q(""), [R, g] = Q(null), [r, y] = Q(n), [p, l] = Q(null), [v, M] = Q(!1), h = {
+    small: "text-sm",
+    medium: "text-base",
+    large: "text-lg"
+  }, c = !!(e || t && t.length > 0), T = (P) => {
+    const L = P.split(":"), I = L[2] ? parseFloat(L[2]) : 0, U = L[1] ? parseInt(L[1], 10) * 60 : 0;
+    return (L[0] ? parseInt(L[0], 10) * 3600 : 0) + U + I;
+  }, E = (P) => {
+    const [L, I] = P.split(","), U = (L || "").split(":"), _ = I ? parseInt(I, 10) / 1e3 : 0, C = U[2] ? parseInt(U[2], 10) : 0, ee = U[1] ? parseInt(U[1], 10) * 60 : 0;
+    return (U[0] ? parseInt(U[0], 10) * 3600 : 0) + ee + C + _;
+  }, b = async (P) => {
+    M(!0), l(null);
+    try {
+      const L = await fetch(P);
+      if (!L.ok)
+        throw new Error(`Failed to load subtitles: ${L.status} ${L.statusText}`);
+      const I = await L.text(), U = [], _ = I.split(`
+`);
+      let C = 0;
+      const ee = I.includes("WEBVTT") || P.endsWith(".vtt"), f = P.endsWith(".srt") || /^\d+$/.test(_[0]?.trim() || "");
+      if (ee)
+        for (; C < _.length; ) {
+          if (_[C]?.includes("-->")) {
+            const [V, se] = (_[C] || "").split("-->").map((B) => B.trim()), ae = T(V || ""), i = T(se || "");
+            C++;
+            let k = "";
+            for (; C < _.length && _[C]?.trim() !== ""; )
+              k += (k ? " " : "") + _[C]?.trim(), C++;
+            k && U.push({ start: ae, end: i, text: k });
+          }
+          C++;
+        }
+      else if (f)
+        for (; C < _.length; ) {
+          if (/^\d+$/.test(_[C]?.trim() || "") && (C++, _[C]?.includes("-->"))) {
+            const [V, se] = (_[C] || "").split("-->").map((B) => B.trim()), ae = E(V || ""), i = E(se || "");
+            C++;
+            let k = "";
+            for (; C < _.length && _[C]?.trim() !== ""; )
+              k += (k ? " " : "") + _[C]?.trim(), C++;
+            k && U.push({ start: ae, end: i, text: k });
+          }
+          C++;
+        }
+      else
+        throw new Error("Unsupported subtitle format. Only VTT and SRT are supported.");
+      if (U.length === 0)
+        throw new Error("No subtitle cues found in file");
+      d(U), M(!1);
+    } catch (L) {
+      const I = L instanceof Error ? L : new Error("Failed to load subtitles");
+      console.error("Failed to load subtitles:", I), l(I), M(!1), d([]), s?.(I);
+    }
+  }, w = (P) => !u || a.length === 0 ? "" : a.find(
+    (I) => P >= I.start && P <= I.end
+  )?.text || "", m = () => {
+    o((P) => {
+      const L = !P;
+      if (L && !p) {
+        if (a.length === 0 && !v) {
+          const I = e || t[0]?.src;
+          I && (b(I), t[0] && g(t[0].id));
+        }
+      } else L || D("");
+      return L;
+    });
+  }, z = (P) => {
+    if (!P) {
+      o(!1), g(null), D("");
+      return;
+    }
+    const L = t.find((I) => I.id === P);
+    L?.src && (g(P), b(L.src), o(!0));
+  }, F = (P) => {
+    y(P);
+  }, O = {
+    fontSize: h[r],
+    className: `${h[r]} font-medium`
+  };
+  return q(() => {
+    u || D("");
+  }, [u]), q(() => {
+  }, []), {
+    // State
+    subtitlesEnabled: u,
+    currentSubtitle: S,
+    subtitleCues: a,
+    currentTrackId: R,
+    fontSize: r,
+    loadError: p,
+    isLoading: v,
+    hasSubtitles: c,
+    // Actions
+    toggleSubtitles: m,
+    selectSubtitleTrack: z,
+    changeSubtitleFontSize: F,
+    setCurrentSubtitle: D,
+    // Utilities
+    getCurrentSubtitle: w,
+    getSubtitleStyles: O,
+    // Track info
+    availableTracks: t
+  };
+}
+const Ke = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  useEnhancedSubtitles: De
+}, Symbol.toStringTag, { value: "Module" }));
+function $e(e, t) {
+  const [n, s] = Q(!0), [u, o] = Q(!1), a = W(null), d = () => {
+    s(!0), a.current && clearTimeout(a.current), e && !t && (a.current = setTimeout(() => {
+      s(!1);
+    }, 3e3));
+  }, S = () => {
+    d();
+  }, D = () => {
+    s(!0);
+  }, R = () => {
+    e && s(!1);
+  };
+  return q(() => (d(), () => {
+    a.current && clearTimeout(a.current);
+  }), [d]), {
+    controlsVisible: n,
+    showVolumeSlider: u,
+    setShowVolumeSlider: o,
+    handleMouseMove: S,
+    handleMouseEnter: D,
+    handleMouseLeave: R
+  };
+}
+function Ge({
+  videoControls: e,
+  toggleSubtitles: t,
+  takeScreenshot: n,
+  duration: s
+}) {
+  const u = (o) => {
+    const a = document.querySelector("video");
+    if (a)
+      switch (o.key.toLowerCase()) {
+        case " ":
+        case "k":
+          o.preventDefault(), e.togglePlay();
+          break;
+        case "j":
+          o.preventDefault(), e.seekBackward();
+          break;
+        case "l":
+          o.preventDefault(), e.seekForward();
+          break;
+        case "arrowleft":
+          o.preventDefault(), a.currentTime = Math.max(0, a.currentTime - 5);
+          break;
+        case "arrowright":
+          o.preventDefault(), a.currentTime = Math.min(s, a.currentTime + 5);
+          break;
+        case "arrowup":
+          o.preventDefault(), a.volume = Math.min(1, a.volume + 0.1);
+          break;
+        case "arrowdown":
+          o.preventDefault(), a.volume = Math.max(0, a.volume - 0.1);
+          break;
+        case "m":
+          o.preventDefault(), e.toggleMute();
+          break;
+        case "f":
+          o.preventDefault(), e.toggleFullscreen();
+          break;
+        case "c":
+          o.preventDefault(), t();
+          break;
+        case "s":
+          o.preventDefault(), n(o.ctrlKey || o.metaKey);
+          break;
+      }
+  };
+  q(() => (document.addEventListener("keydown", u), () => document.removeEventListener("keydown", u)), [u]);
+}
+function ze(e) {
+  return { takeScreenshot: (n = !1) => {
+    if (!e.current) return;
+    const s = e.current, u = document.createElement("canvas");
+    u.width = s.videoWidth, u.height = s.videoHeight;
+    const o = u.getContext("2d");
+    if (o)
+      try {
+        o.drawImage(s, 0, 0), u.toBlob((a) => {
+          if (!a) {
+            console.error("Failed to create blob from canvas");
+            return;
+          }
+          if (n)
+            if (navigator.clipboard && window.ClipboardItem) {
+              const d = new ClipboardItem({ "image/png": a });
+              navigator.clipboard.write([d]).catch((S) => {
+                console.error("Failed to copy to clipboard:", S);
+              });
+            } else
+              console.warn("Clipboard API not supported");
+          else {
+            const d = URL.createObjectURL(a), S = document.createElement("a");
+            S.href = d, S.download = `screenshot-${Date.now()}.png`, S.click(), URL.revokeObjectURL(d);
+          }
+        }, "image/png");
+      } catch (a) {
+        a instanceof Error && a.message.includes("tainted") ? (console.error("Canvas is tainted - video source may not have proper CORS headers. Try setting crossOrigin='anonymous' on the video element."), alert("Screenshot failed: The video source doesn't allow screenshots due to CORS policy. Please ensure the video server includes proper CORS headers or set crossOrigin='anonymous' on the video player.")) : (console.error("Screenshot failed:", a), alert("Screenshot failed: " + (a instanceof Error ? a.message : "Unknown error")));
+      }
+  } };
+}
+function We(e) {
+  const t = W(null), n = W(null), [s, u] = le(), [o, a] = le();
+  N.useRef(0);
+  const d = N.useRef(0), S = N.useRef(0);
+  W(void 0);
+  const D = W(0), R = pe(), g = "getOptimisticState" in R, r = j((i) => i.isPlaying), y = j((i) => i.currentTime), p = j((i) => i.duration), l = j((i) => i.volume), v = j((i) => i.isMuted), M = j((i) => i.isLoading), h = j((i) => i.isBuffering), c = j((i) => i.error), T = j((i) => i.buffered), E = j((i) => i.isFullscreen), b = R, w = g ? Ee(b) : null, m = g ? Te(b) : null, [z, F] = N.useState({
+    frameRate: 0,
+    averageRenderTime: 0,
+    droppedFrames: 0,
+    bufferHealth: 0
+  }), [O, P] = ce(l, (i, k) => Math.max(0, Math.min(1, k)));
+  ce(y, (i, k) => Math.max(0, Math.min(p || 0, k))), q(() => {
+    const i = t.current;
+    if (!i) return;
+    const k = {
+      volume: e.volume,
+      muted: e.muted,
+      autoplay: e.autoPlay,
+      loop: e.loop,
+      preload: e.preload,
+      crossOrigin: e.crossOrigin
+    };
+    Object.entries(k).forEach(([B, Y]) => {
+      Y !== void 0 && (i[B] = Y);
+    }), i.setAttribute("preload", e.preloadStrategy === "eager" ? "auto" : "metadata"), e.bufferingStrategy === "aggressive" && i.setAttribute("buffered", "auto"), i instanceof HTMLVideoElement && (i.style.willChange = "transform", i.style.transform = "translateZ(0)");
+  }, [
+    e.volume,
+    e.muted,
+    e.autoPlay,
+    e.loop,
+    e.preload,
+    e.crossOrigin,
+    e.preloadStrategy,
+    e.bufferingStrategy
+  ]);
+  const L = A(() => {
+    const i = t.current;
+    if (!i) return;
+    const k = performance.now();
+    if (e.enableTimeUpdateThrottling !== !1) {
+      if (k - D.current < (e.timeUpdateThrottleMs || 100))
+        return;
+      D.current = k;
+    }
+    u(() => {
+      g && m && m.setCurrentTime(i.currentTime);
+    });
+  }, [e.enableTimeUpdateThrottling, e.timeUpdateThrottleMs, g, m]), I = A(() => {
+    u(() => {
+      g && m && m.play(!0);
+    }), e.onPlay?.();
+  }, [g, m, e.onPlay]), U = A(() => {
+    u(() => {
+      g && m && m.pause(!0);
+    }), e.onPause?.();
+  }, [g, m, e.onPause]), _ = A(() => {
+    const i = t.current;
+    i && u(() => {
+      g && m && (m.setVolume(i.volume, !0), i.muted ? m.mute(!0) : m.unmute(!0));
+    });
+  }, [g, m]), C = A(() => {
+    a(() => {
+    });
+  }, []), ee = A(() => {
+  }, []), f = A(() => {
+    const i = t.current;
+    i && u(() => {
+      g && m && m.setBuffered(i.buffered);
+    });
+  }, [g, m]), V = A(() => {
+    const i = performance.now();
+    if (i - S.current > 0 && (d.current++, d.current >= 60)) {
+      const B = Math.round(d.current * 1e3 / (i - S.current));
+      F((Y) => ({
+        ...Y,
+        frameRate: B,
+        droppedFrames: Math.max(0, 60 - B)
+      })), d.current = 0, S.current = i;
+    }
+  }, []);
+  q(() => {
+    const i = t.current;
+    if (!i) return;
+    const k = [
+      { event: "timeupdate", handler: L, passive: !0 },
+      { event: "play", handler: I },
+      { event: "pause", handler: U },
+      { event: "volumechange", handler: _ },
+      { event: "seeking", handler: C },
+      { event: "seeked", handler: ee },
+      { event: "progress", handler: f, passive: !0 },
+      { event: "loadedmetadata", handler: () => V() },
+      { event: "loadeddata", handler: () => V() }
+    ];
+    k.forEach(({ event: te, handler: ne, passive: ie }) => {
+      const oe = ie ? { passive: !0 } : {};
+      i.addEventListener(te, ne, oe);
+    });
+    let B;
+    const Y = () => {
+      V(), B = requestAnimationFrame(Y);
+    };
+    return e.enablePerformanceMonitoring && Y(), () => {
+      k.forEach(({ event: te, handler: ne }) => {
+        i.removeEventListener(te, ne);
+      }), B && cancelAnimationFrame(B);
+    };
+  }, [
+    L,
+    I,
+    U,
+    _,
+    C,
+    ee,
+    f,
+    V,
+    e.enablePerformanceMonitoring
+  ]);
+  const se = ue(() => {
+    const i = async () => {
+      const x = t.current;
+      if (x)
+        if (g && m)
+          await m.play(!0);
+        else
+          try {
+            await x.play();
+          } catch (X) {
+            console.error("Failed to play media:", X);
+          }
+    }, k = () => {
+      const x = t.current;
+      x && (g && m ? m.pause(!0) : x.pause());
+    }, B = () => {
+      r ? k() : i();
+    }, Y = (x) => {
+      const X = t.current;
+      if (!X) return;
+      const Z = Math.max(0, Math.min(x, p || 0));
+      g && m ? a(() => {
+        m.seek(Z, !0);
+      }) : X.currentTime = Z;
+    }, te = (x) => {
+      const X = t.current;
+      if (!X) return;
+      const Z = Math.max(0, Math.min(1, x));
+      g && m ? (P(Z), u(() => {
+        m.setVolume(Z, !0);
+      })) : X.volume = Z;
+    }, ne = () => {
+      const x = t.current;
+      x && (g && m ? m.toggleMute(!0) : x.muted = !x.muted);
+    }, ie = async () => {
+      const x = n.current;
+      if (!(!x || !document.fullscreenEnabled))
+        try {
+          await x.requestFullscreen(), g && m && m.enterFullscreen(!0);
+        } catch (X) {
+          console.error("Failed to enter fullscreen:", X);
+        }
+    }, oe = async () => {
+      if (document.fullscreenElement)
+        try {
+          await document.exitFullscreen(), g && m && m.exitFullscreen(!0);
+        } catch (x) {
+          console.error("Failed to exit fullscreen:", x);
+        }
+    };
+    return {
+      play: i,
+      pause: k,
+      toggle: B,
+      seek: Y,
+      setVolume: te,
+      toggleMute: ne,
+      enterFullscreen: ie,
+      exitFullscreen: oe,
+      toggleFullscreen: () => {
+        document.fullscreenElement ? oe() : ie();
+      }
+    };
+  }, [
+    r,
+    p,
+    g,
+    m,
+    u,
+    a,
+    P
+  ]), ae = ue(() => ({
+    isPlaying: w?.isPlaying ?? r,
+    currentTime: w?.currentTime ?? y,
+    duration: w?.duration ?? p,
+    volume: w?.volume ?? O,
+    isMuted: w?.isMuted ?? v,
+    isLoading: w?.isBuffering ?? M,
+    isBuffering: w?.isBuffering ?? h,
+    error: w?.error ?? c,
+    buffered: w?.buffered ?? T,
+    isFullscreen: w?.isFullscreen ?? E,
+    progress: p > 0 ? y / p : 0,
+    isTransitioning: s || o,
+    canPlay: !M && !h && !c
+  }), [
+    w,
+    r,
+    y,
+    p,
+    O,
+    v,
+    M,
+    h,
+    c,
+    T,
+    E,
+    s,
+    o
+  ]);
+  return {
+    // Refs
+    mediaRef: t,
+    containerRef: n,
+    // State
+    state: ae,
+    actualState: w?.actualState,
+    // Controls
+    controls: se,
+    // Performance metrics
+    performanceMetrics: z,
+    isTransitioning: s || o,
+    // Enhanced features
+    actions: w?.actions,
+    actionState: w?.actionState,
+    // Optimistic features
+    optimisticState: w,
+    isEnhanced: g
+  };
+}
+const je = (e, t = {}) => {
+  const {
+    trackUserBehavior: n = !0,
+    adaptToNetwork: s = !0,
+    strategy: u = "balanced",
+    maxPreloadItems: o = 3,
+    preloadRadius: a = 2
+  } = t, d = W({
+    mouseMovements: 0,
+    scrollEvents: 0,
+    keyPresses: 0,
+    focusEvents: 0,
+    timeOnPage: 0,
+    engagementScore: 0,
+    lastInteraction: Date.now()
+  }), S = W(null), D = W(/* @__PURE__ */ new Set()), R = W([]), g = A(() => {
+    const c = d.current, T = Math.min(c.timeOnPage / 6e4, 1), E = Math.min(
+      (c.mouseMovements + c.scrollEvents + c.keyPresses) / 100,
+      1
+    );
+    return (T * 0.4 + E * 0.6) * 100;
+  }, []), r = A((c, T = 1) => {
+    const E = d.current;
+    E[c] = typeof E[c] == "number" ? E[c] + T : Date.now(), E.engagementScore = g(), E.lastInteraction = Date.now();
+  }, [g]), y = A(() => {
+    if (!S.current || !s)
+      return { type: "unknown", downlink: 10, effectiveType: "4g", saveData: !1 };
+    const c = S.current;
+    return {
+      type: c.type,
+      downlink: c.downlink || 10,
+      effectiveType: c.effectiveType || "4g",
+      saveData: c.saveData || !1,
+      rtt: c.rtt || 100
+    };
+  }, [s]), p = A((c, T, E = 0) => {
+    if (D.current.has(c.src))
+      return { shouldPreload: !1, priority: "low", reason: "Already preloaded" };
+    const b = Math.abs(T - E);
+    if (b > a)
+      return { shouldPreload: !1, priority: "low", reason: "Outside preload radius" };
+    const w = d.current, m = y(), z = w.engagementScore, F = Date.now() - w.lastInteraction;
+    if (m.saveData)
+      return { shouldPreload: !1, priority: "low", reason: "Data saver mode" };
+    let O = !1, P = "medium", L = "";
+    switch (u) {
+      case "conservative":
+        O = z > 70 && m.effectiveType !== "2g" && b === 1, P = O ? "medium" : "low", L = O ? "High engagement and optimal network" : "Conservative strategy";
+        break;
+      case "aggressive":
+        O = z > 30 && m.effectiveType !== "slow-2g", P = z > 70 ? "high" : z > 50 ? "medium" : "low", L = O ? "Aggressive preloading" : "Low engagement";
+        break;
+      case "balanced":
+      default:
+        const I = m.effectiveType === "4g" ? 1 : m.effectiveType === "3g" ? 0.7 : 0.3, U = z * I;
+        O = U > 40 && b <= 2, P = U > 70 ? "high" : U > 55 ? "medium" : "low", L = O ? `Balanced: score ${U.toFixed(1)}` : "Low adjusted score";
+        break;
+    }
+    return O && ((c.type === "hls" || c.type === "m3u8") && (P = P === "low" ? "medium" : "high"), F < 5e3 && (P = "high", L += " + Recent interaction"), (c.type === "mp4" || c.type === "webm") && (P = P === "low" ? "medium" : P)), { shouldPreload: O, priority: P, reason: L };
+  }, [u, a, y, g]), l = A(async (c, T) => {
+    try {
+      const E = document.createElement("link");
+      switch (E.rel = "preload", E.href = c.src, c.type) {
+        case "hls":
+        case "m3u8":
+          E.as = "fetch";
+          break;
+        case "mp4":
+        case "webm":
+          E.as = "video";
+          break;
+        case "mp3":
+        case "wav":
+        case "ogg":
+          E.as = "audio";
+          break;
+        default:
+          E.as = "fetch";
+      }
+      E.crossOrigin = "anonymous", document.head.appendChild(E), D.current.add(c.src), console.debug(`Preloaded: ${c.src} (${T})`), setTimeout(() => {
+        document.head.contains(E) && document.head.removeChild(E);
+      }, 3e4);
+    } catch (E) {
+      console.warn("Failed to preload source:", c.src, E);
+    }
+  }, []), v = A(() => {
+    if (R.current.length === 0) return;
+    const T = [...R.current].sort((E, b) => b.priority - E.priority).slice(0, o);
+    R.current = [], T.forEach(({ source: E, priority: b }) => {
+      l(E, b);
+    });
+  }, [o, l]), M = A((c = 0) => {
+    R.current = [], e.forEach((T, E) => {
+      const b = p(T, E, c);
+      if (b.shouldPreload) {
+        const w = b.priority === "high" ? 3 : b.priority === "medium" ? 2 : 1;
+        R.current.push({ source: T, priority: w });
+      }
+    }), v();
+  }, [e, p, v]);
+  return q(() => {
+    if (!n) return;
+    const c = () => r("mouseMovements"), T = () => r("scrollEvents"), E = () => r("keyPresses"), b = () => r("focusEvents");
+    document.addEventListener("mousemove", c, { passive: !0 }), document.addEventListener("scroll", T, { passive: !0 }), document.addEventListener("keydown", E, { passive: !0 }), document.addEventListener("focusin", b, { passive: !0 });
+    const w = setInterval(() => {
+      r("timeOnPage", 1);
+    }, 1e3);
+    return () => {
+      document.removeEventListener("mousemove", c), document.removeEventListener("scroll", T), document.removeEventListener("keydown", E), document.removeEventListener("focusin", b), clearInterval(w);
+    };
+  }, [n, r]), q(() => {
+    if (!s || !("connection" in navigator)) return;
+    const c = navigator.connection;
+    S.current = c;
+    const T = () => {
+      M();
+    };
+    return c.addEventListener("change", T), () => {
+      c.removeEventListener("change", T);
+    };
+  }, [s, M]), q(() => {
+    M();
+  }, [M]), ue(() => ({
+    /**
+     * Manually trigger preloading for specific index
+     */
+    preloadAtIndex: (c) => {
+      M(c);
+    },
+    /**
+     * Get current user behavior data
+     */
+    getUserBehavior: () => ({ ...d.current }),
+    /**
+     * Get current network conditions
+     */
+    getNetworkConditions: y,
+    /**
+     * Clear preloaded items cache
+     */
+    clearCache: () => {
+      D.current.clear();
+    },
+    /**
+     * Get preloading statistics
+     */
+    getStats: () => ({
+      preloadedItems: D.current.size,
+      engagementScore: d.current.engagementScore,
+      queueLength: R.current.length,
+      maxPreloadItems: o
+    })
+  }), [M, y, o]);
+};
+function Re(e) {
+  const [t, n] = Q(!1), [s, u] = Q([]), [o, a] = Q(""), d = (g) => {
+    const r = g.split(":"), y = r[2] ? parseFloat(r[2]) : 0, p = r[1] ? parseInt(r[1], 10) * 60 : 0;
+    return (r[0] ? parseInt(r[0], 10) * 3600 : 0) + p + y;
+  }, S = async (g) => {
+    try {
+      const y = await (await fetch(g)).text(), p = [], l = y.split(`
+`);
+      let v = 0;
+      for (; v < l.length; ) {
+        if (l[v]?.includes("-->")) {
+          const [M, h] = (l[v] || "").split("-->").map((b) => b.trim()), c = d(M || ""), T = d(h || "");
+          v++;
+          let E = "";
+          for (; v < l.length && l[v]?.trim() !== ""; )
+            E += (E ? " " : "") + l[v]?.trim(), v++;
+          E && p.push({ start: c, end: T, text: E });
+        }
+        v++;
+      }
+      u(p);
+    } catch (r) {
+      console.error("Failed to load subtitles:", r);
+    }
+  }, D = (g) => !t || s.length === 0 ? "" : s.find(
+    (y) => g >= y.start && g <= y.end
+  )?.text || "", R = () => {
+    n((g) => {
+      const r = !g;
+      return r && e && s.length === 0 ? S(e) : r || a(""), r;
+    });
+  };
+  return q(() => {
+    t || a("");
+  }, [t]), {
+    subtitlesEnabled: t,
+    currentSubtitle: o,
+    toggleSubtitles: R,
+    getCurrentSubtitle: D,
+    setCurrentSubtitle: a
+  };
+}
+function qe(e) {
+  return ve(
+    "useVideoPlayer",
+    "useMediaPlayer (the primary media player hook)"
+  ), Le(e);
+}
+function Xe(e) {
+  return ve(
+    "useEnhancedSubtitles",
+    "useSubtitles (the current subtitle hook)"
+  ), Re(e);
+}
+export {
+  Be as a,
+  Ne as b,
+  He as c,
+  De as d,
+  $e as e,
+  Ge as f,
+  ze as g,
+  Oe as h,
+  Ue as i,
+  Ie as j,
+  Le as k,
+  be as l,
+  Me as m,
+  We as n,
+  _e as o,
+  Se as p,
+  je as q,
+  Fe as r,
+  Re as s,
+  qe as t,
+  de as u,
+  Xe as v,
+  Ve as w,
+  Ke as x
+};
+//# sourceMappingURL=hooks-BhW_i-9L.js.map