@therealtinhtute/baroiplayer 1.0.0

package/dist/hooks-Da2wVXlF.js

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