@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/dist/hooks-Bpi-jDiO.js

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