@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

package/dist/hooks-CyX6De5M.js

@@ -0,0 +1,1693 @@
+import * as Y from "react";
+import z, { useOptimistic as se, useRef as G, useTransition as ue, useEffect as $, useCallback as B, useMemo as ae, useState as K } from "react";
+import { M as U, c as pe, b as q } from "./context-BYwDoSRX.js";
+import { s as he } from "./utils-Dzpl2ArK.js";
+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 ge(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 ve(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 = ge(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 we(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 = z.useSyncExternalStore(e.subscribe, e.getState, e.getState), [r, s] = se(t, we), 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 Ce(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 = Ee(T), E = ve(T), [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 ye({
+  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 Re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  useKeyboardControls: ye
+}, Symbol.toStringTag, { value: "Module" }));
+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
+  }), 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(), typeof window < "u" && "gc" in window && window.gc();
+  }, []), w = B((m, i) => {
+    const p = setInterval(m, i);
+    return l.current.add(p), () => {
+      clearInterval(p), l.current.delete(p);
+    };
+  }, []);
+  $(() => {
+    if (!d) return;
+    const m = () => {
+      const i = D(), p = i.used / 1024 / 1024, h = p > t;
+      y({
+        ...i,
+        usage: p,
+        isHighUsage: h
+      }), h && s && n();
+    };
+    return m(), w(m, r);
+  }, [d, D, t, s, r, n]);
+  const g = 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);
+      }
+    }),
+    []
+  ), 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: g,
+    setInterval,
+    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 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 Ve = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  useEnhancedSubtitles: ke
+}, Symbol.toStringTag, { value: "Module" }));
+function Ue({
+  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 _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(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")));
+      }
+  } };
+}
+function He(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)));
+      }
+    }
+  };
+}
+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,
+  He as c,
+  ke as d,
+  _e as e,
+  Ue as f,
+  Be as g,
+  Ce as h,
+  Ie as i,
+  ye as j,
+  be as k,
+  Te as l,
+  ve as m,
+  ge as n,
+  Ne as o,
+  Me as p,
+  Pe as q,
+  Ge as r,
+  $e as s,
+  Re as t,
+  ie as u,
+  Ve as v
+};
+//# sourceMappingURL=hooks-CyX6De5M.js.map