@lightbird/core 0.1.0

package/dist/react/index.cjs

@@ -0,0 +1,915 @@
+'use strict';
+
+var react = require('react');
+
+// src/react/use-video-playback.ts
+function useVideoPlayback(videoRef) {
+  const [isPlaying, setIsPlaying] = react.useState(false);
+  const [progress, setProgress] = react.useState(0);
+  const [duration, setDuration] = react.useState(0);
+  const [volume, setVolumeState] = react.useState(1);
+  const [isMuted, setIsMuted] = react.useState(false);
+  const [playbackRate, setPlaybackRateState] = react.useState(1);
+  const [loop, setLoop] = react.useState(false);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    setIsPlaying(!el.paused);
+    setProgress(el.currentTime);
+    if (el.duration && !Number.isNaN(el.duration)) setDuration(el.duration);
+    setVolumeState(el.volume);
+    setIsMuted(el.muted);
+    const onPlay = () => setIsPlaying(true);
+    const onPause = () => setIsPlaying(false);
+    const onTimeUpdate = () => setProgress(el.currentTime);
+    const onLoadedMetadata = () => setDuration(el.duration);
+    const onVolumeChange = () => {
+      setVolumeState(el.volume);
+      setIsMuted(el.muted);
+    };
+    el.addEventListener("play", onPlay);
+    el.addEventListener("pause", onPause);
+    el.addEventListener("timeupdate", onTimeUpdate);
+    el.addEventListener("loadedmetadata", onLoadedMetadata);
+    el.addEventListener("volumechange", onVolumeChange);
+    return () => {
+      el.removeEventListener("play", onPlay);
+      el.removeEventListener("pause", onPause);
+      el.removeEventListener("timeupdate", onTimeUpdate);
+      el.removeEventListener("loadedmetadata", onLoadedMetadata);
+      el.removeEventListener("volumechange", onVolumeChange);
+    };
+  }, [videoRef]);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (el) el.loop = loop;
+  }, [loop, videoRef]);
+  const togglePlay = react.useCallback(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    if (el.paused) {
+      el.play().catch(() => {
+      });
+    } else {
+      el.pause();
+    }
+  }, [videoRef]);
+  const seek = react.useCallback(
+    (t) => {
+      const el = videoRef.current;
+      if (!el) return;
+      el.currentTime = Math.max(0, Math.min(t, el.duration || 0));
+    },
+    [videoRef]
+  );
+  const setVolume = react.useCallback(
+    (v) => {
+      const el = videoRef.current;
+      if (!el) return;
+      el.volume = v;
+      el.muted = v === 0;
+    },
+    [videoRef]
+  );
+  const toggleMute = react.useCallback(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    el.muted = !el.muted;
+  }, [videoRef]);
+  const setPlaybackRate = react.useCallback(
+    (r) => {
+      const el = videoRef.current;
+      if (!el) return;
+      el.playbackRate = r;
+      setPlaybackRateState(r);
+    },
+    [videoRef]
+  );
+  const frameStep = react.useCallback(
+    (direction) => {
+      const el = videoRef.current;
+      if (!el) return;
+      el.pause();
+      const frameTime = 1 / 30;
+      const delta = direction === "forward" ? frameTime : -frameTime;
+      el.currentTime = Math.max(0, Math.min(el.currentTime + delta, el.duration || 0));
+    },
+    [videoRef]
+  );
+  const toggleLoop = react.useCallback(() => setLoop((l) => !l), []);
+  return {
+    isPlaying,
+    progress,
+    duration,
+    volume,
+    isMuted,
+    playbackRate,
+    loop,
+    togglePlay,
+    seek,
+    setVolume,
+    toggleMute,
+    setPlaybackRate,
+    frameStep,
+    toggleLoop
+  };
+}
+var DEFAULT_FILTERS = {
+  brightness: 100,
+  contrast: 100,
+  saturate: 100,
+  hue: 0
+};
+function useVideoFilters(videoRef) {
+  const [filters, setFilters] = react.useState(DEFAULT_FILTERS);
+  const [zoom, setZoom] = react.useState(1);
+  const rafRef = react.useRef(null);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    if (rafRef.current !== null) cancelAnimationFrame(rafRef.current);
+    rafRef.current = requestAnimationFrame(() => {
+      el.style.filter = `brightness(${filters.brightness}%) contrast(${filters.contrast}%) saturate(${filters.saturate}%) hue-rotate(${filters.hue}deg)`;
+      el.style.transform = `scale(${zoom})`;
+      rafRef.current = null;
+    });
+    return () => {
+      if (rafRef.current !== null) cancelAnimationFrame(rafRef.current);
+    };
+  }, [filters, zoom, videoRef]);
+  const resetFilters = () => {
+    setFilters(DEFAULT_FILTERS);
+    setZoom(1);
+  };
+  return { filters, zoom, setFilters, setZoom, resetFilters };
+}
+
+// src/subtitles/subtitle-converter.ts
+var SubtitleConverter = class {
+  static async convertSrtToVtt(srtContent) {
+    let vttContent = "WEBVTT\n\n";
+    const blocks = srtContent.split(/\n\s*\n/);
+    for (const block of blocks) {
+      const lines = block.trim().split("\n");
+      if (lines.length >= 3) {
+        const timecodeLine = lines[1];
+        const textLines = lines.slice(2);
+        const vttTimecode = timecodeLine.replace(/,/g, ".");
+        vttContent += `${vttTimecode}
+`;
+        vttContent += `${textLines.join("\n")}
+
+`;
+      }
+    }
+    return vttContent;
+  }
+  static async convertFileToVtt(file) {
+    const fileName = file.name.toLowerCase();
+    if (fileName.endsWith(".vtt")) {
+      return file;
+    }
+    if (fileName.endsWith(".srt")) {
+      const srtContent = await file.text();
+      const vttContent = await this.convertSrtToVtt(srtContent);
+      const vttBlob = new Blob([vttContent], { type: "text/vtt" });
+      const vttFileName = file.name.replace(/\.srt$/i, ".vtt");
+      return new File([vttBlob], vttFileName, { type: "text/vtt" });
+    }
+    return file;
+  }
+};
+
+// src/subtitles/subtitle-offset.ts
+function shiftTimestamp(ts, delta) {
+  ts.split(":").length === 3 ? [ts.slice(0, 5), ts.slice(6)] : ["00:00", ts.slice(3)];
+  const parts = ts.split(":");
+  const h = Number(parts[0]);
+  const m = Number(parts[1]);
+  const s = Number(parts[2]);
+  const total = Math.max(0, h * 3600 + m * 60 + s + delta);
+  const hh = Math.floor(total / 3600);
+  const mm = Math.floor(total % 3600 / 60);
+  const ss = total % 60;
+  const ssStr = ss.toFixed(3).padStart(6, "0");
+  return `${String(hh).padStart(2, "0")}:${String(mm).padStart(2, "0")}:${ssStr}`;
+}
+function applyOffsetToVtt(vttText, offsetSeconds) {
+  if (offsetSeconds === 0) return vttText;
+  return vttText.replace(
+    /(\d{2}:\d{2}:\d{2}\.\d{3})\s+-->\s+(\d{2}:\d{2}:\d{2}\.\d{3})/g,
+    (_, start, end) => {
+      const shiftedStart = shiftTimestamp(start, offsetSeconds);
+      const shiftedEnd = shiftTimestamp(end, offsetSeconds);
+      return `${shiftedStart} --> ${shiftedEnd}`;
+    }
+  );
+}
+
+// src/subtitles/subtitle-manager.ts
+function detectEncoding(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    return "UTF-8";
+  }
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254) {
+    return "UTF-16LE";
+  }
+  if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+    return "UTF-16BE";
+  }
+  return "UTF-8";
+}
+async function readSubtitleFile(file) {
+  const buffer = await file.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  const detected = detectEncoding(bytes);
+  const decoder = new TextDecoder(detected);
+  return decoder.decode(buffer);
+}
+function parseVttCues(vttText) {
+  const cues = [];
+  const cueRegex = /(\d{2}:\d{2}:\d{2}\.\d{3})\s+-->\s+(\d{2}:\d{2}:\d{2}\.\d{3})[^\n]*\n([\s\S]*?)(?=\n\n|\n*$)/g;
+  let match;
+  while ((match = cueRegex.exec(vttText)) !== null) {
+    const startTime = timestampToSeconds(match[1]);
+    const endTime = timestampToSeconds(match[2]);
+    const text = match[3].trim().replace(/<[^>]+>/g, "");
+    if (text) cues.push({ startTime, endTime, text });
+  }
+  return cues;
+}
+function timestampToSeconds(ts) {
+  const parts = ts.split(":");
+  const h = Number(parts[0]);
+  const m = Number(parts[1]);
+  const s = Number(parts[2]);
+  return h * 3600 + m * 60 + s;
+}
+var UniversalSubtitleManager = class {
+  constructor(videoElement) {
+    this.records = [];
+    this.videoElement = null;
+    this.nextId = 0;
+    this.videoElement = videoElement || null;
+  }
+  setVideoElement(videoElement) {
+    this.videoElement = videoElement;
+  }
+  async addSubtitleFiles(files) {
+    const newSubtitles = [];
+    for (const file of files) {
+      const ext = file.name.split(".").pop()?.toLowerCase();
+      const langMatch = file.name.match(/\.([a-z]{2,3})\.(?:srt|vtt|ass|ssa)$/i);
+      const lang = langMatch ? langMatch[1] : "unknown";
+      const subtitle = {
+        id: String(this.nextId++),
+        name: `${lang.toUpperCase()} (${file.name})`,
+        lang,
+        type: "external",
+        format: ext ?? "vtt"
+      };
+      let rawVtt;
+      let cues = [];
+      if (ext === "ass" || ext === "ssa") {
+        const rawText = await readSubtitleFile(file);
+        subtitle.url = void 0;
+        const blob = new Blob([rawText], { type: "text/plain" });
+        subtitle.url = URL.createObjectURL(blob);
+        rawVtt = void 0;
+      } else {
+        const fileText = await readSubtitleFile(file);
+        let vttText;
+        if (ext === "srt") {
+          vttText = await SubtitleConverter.convertSrtToVtt(fileText);
+        } else {
+          vttText = fileText;
+        }
+        rawVtt = vttText;
+        cues = parseVttCues(vttText);
+        const blob = new Blob([vttText], { type: "text/vtt" });
+        subtitle.url = URL.createObjectURL(blob);
+      }
+      newSubtitles.push(subtitle);
+      this.records.push({ subtitle, rawVtt, offset: 0, cues });
+      if (this.videoElement && ext !== "ass" && ext !== "ssa" && subtitle.url) {
+        const track = document.createElement("track");
+        track.kind = "subtitles";
+        track.label = subtitle.name;
+        track.srclang = subtitle.lang;
+        track.src = subtitle.url;
+        track.setAttribute("data-id", subtitle.id);
+        track.default = false;
+        track.addEventListener("load", () => {
+          console.log(`Subtitle track loaded: ${subtitle.name}`);
+        });
+        track.addEventListener("error", (e) => {
+          console.error(`Failed to load subtitle track: ${subtitle.name}`, e);
+        });
+        this.videoElement.appendChild(track);
+        const textTrack = track.track;
+        textTrack.mode = "hidden";
+        setTimeout(() => {
+          textTrack.mode = "disabled";
+        }, 100);
+      }
+    }
+    return newSubtitles;
+  }
+  removeSubtitle(id) {
+    const index = this.records.findIndex((r) => r.subtitle.id === id);
+    if (index === -1) return false;
+    const { subtitle } = this.records[index];
+    if (this.videoElement) {
+      const tracks = this.videoElement.querySelectorAll("track");
+      for (const track of tracks) {
+        if (track.getAttribute("data-id") === id) {
+          track.remove();
+          break;
+        }
+      }
+    }
+    if (subtitle.url && subtitle.url.startsWith("blob:")) {
+      URL.revokeObjectURL(subtitle.url);
+    }
+    this.records.splice(index, 1);
+    return true;
+  }
+  switchSubtitle(id) {
+    if (!this.videoElement) return;
+    const tracks = this.videoElement.textTracks;
+    for (let i = 0; i < tracks.length; i++) {
+      tracks[i].mode = "disabled";
+    }
+    if (id === "-1") return;
+    const trackElements = this.videoElement.querySelectorAll("track");
+    for (let i = 0; i < trackElements.length; i++) {
+      const trackElement = trackElements[i];
+      if (trackElement.getAttribute("data-id") === id) {
+        const textTrack = trackElement.track;
+        if (textTrack) {
+          if (trackElement.readyState === 2) {
+            textTrack.mode = "hidden";
+          } else {
+            const onLoad = () => {
+              textTrack.mode = "hidden";
+              trackElement.removeEventListener("load", onLoad);
+            };
+            trackElement.addEventListener("load", onLoad);
+            textTrack.mode = "hidden";
+          }
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * Sets a time offset (in seconds) for a VTT/SRT subtitle.
+   * Regenerates the blob URL with shifted timestamps and updates the track element.
+   */
+  async setOffset(id, offsetSeconds) {
+    const record = this.records.find((r) => r.subtitle.id === id);
+    if (!record || record.rawVtt === void 0) return;
+    if (record.offset === offsetSeconds) return;
+    record.offset = offsetSeconds;
+    if (record.subtitle.url && record.subtitle.url.startsWith("blob:")) {
+      URL.revokeObjectURL(record.subtitle.url);
+    }
+    const shifted = applyOffsetToVtt(record.rawVtt, offsetSeconds);
+    const blob = new Blob([shifted], { type: "text/vtt" });
+    const newUrl = URL.createObjectURL(blob);
+    record.subtitle.url = newUrl;
+    if (this.videoElement) {
+      const trackElements = this.videoElement.querySelectorAll("track");
+      for (const trackEl of trackElements) {
+        if (trackEl.getAttribute("data-id") === id) {
+          trackEl.src = newUrl;
+          break;
+        }
+      }
+    }
+  }
+  /** Returns parsed cue index for a subtitle (empty array for ASS/SSA). */
+  getCues(id) {
+    return this.records.find((r) => r.subtitle.id === id)?.cues ?? [];
+  }
+  /** Returns cues for all loaded VTT/SRT subtitles merged, for global search. */
+  getAllCues() {
+    return this.records.flatMap((r) => r.cues);
+  }
+  getSubtitles() {
+    return this.records.map((r) => r.subtitle);
+  }
+  clearSubtitles() {
+    for (const { subtitle } of this.records) {
+      if (subtitle.url && subtitle.url.startsWith("blob:")) {
+        URL.revokeObjectURL(subtitle.url);
+      }
+    }
+    if (this.videoElement) {
+      const tracks = this.videoElement.querySelectorAll("track");
+      tracks.forEach((track) => track.remove());
+    }
+    this.records = [];
+  }
+  destroy() {
+    this.clearSubtitles();
+    this.videoElement = null;
+  }
+  importSubtitles(subtitles) {
+    this.records = subtitles.map((s) => ({
+      subtitle: s,
+      rawVtt: void 0,
+      offset: 0,
+      cues: []
+    }));
+    this.nextId = Math.max(...subtitles.map((s) => parseInt(s.id)), 0) + 1;
+  }
+};
+
+// src/react/use-subtitles.ts
+function useSubtitles(options) {
+  const [subtitles, setSubtitles] = react.useState([]);
+  const [activeSubtitle, setActiveSubtitle] = react.useState("-1");
+  const managerRef = react.useRef(null);
+  react.useEffect(() => {
+    return () => {
+      managerRef.current?.destroy();
+      managerRef.current = null;
+    };
+  }, []);
+  const initManager = react.useCallback((videoEl) => {
+    managerRef.current?.destroy();
+    managerRef.current = new UniversalSubtitleManager(videoEl);
+  }, []);
+  const importSubtitles = react.useCallback((subs) => {
+    if (!managerRef.current) return;
+    managerRef.current.importSubtitles(subs);
+    setSubtitles(managerRef.current.getSubtitles());
+  }, []);
+  const reset = react.useCallback(() => {
+    managerRef.current?.destroy();
+    managerRef.current = null;
+    setSubtitles([]);
+    setActiveSubtitle("-1");
+  }, []);
+  const addSubtitleFiles = react.useCallback(
+    async (files) => {
+      if (!managerRef.current) return;
+      try {
+        await managerRef.current.addSubtitleFiles(files);
+        setSubtitles(managerRef.current.getSubtitles());
+        options?.onSuccess?.(`Added ${files.length} subtitle file(s).`);
+      } catch (error) {
+        console.error("Failed to add subtitles:", error);
+        options?.onError?.("Failed to add subtitles");
+      }
+    },
+    [options]
+  );
+  const removeSubtitle = react.useCallback(
+    (id) => {
+      if (!managerRef.current) return;
+      const success = managerRef.current.removeSubtitle(id);
+      if (success) {
+        setSubtitles(managerRef.current.getSubtitles());
+        if (activeSubtitle === id) {
+          setActiveSubtitle("-1");
+          managerRef.current.switchSubtitle("-1");
+        }
+        options?.onSuccess?.("Subtitle removed");
+      }
+    },
+    [activeSubtitle, options]
+  );
+  const switchSubtitle = react.useCallback((id) => {
+    setActiveSubtitle(id);
+    managerRef.current?.switchSubtitle(id);
+  }, []);
+  return {
+    subtitles,
+    activeSubtitle,
+    managerRef,
+    initManager,
+    importSubtitles,
+    reset,
+    addSubtitleFiles,
+    removeSubtitle,
+    switchSubtitle
+  };
+}
+var VIDEO_EXTENSIONS = [".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".mp4", ".m4v"];
+var SUBTITLE_EXTENSIONS = [".srt", ".vtt", ".ass", ".ssa"];
+var STORAGE_KEY = "lightbird-playlist";
+async function getFileDuration(url) {
+  return new Promise((resolve) => {
+    const el = document.createElement("video");
+    el.preload = "metadata";
+    el.src = url;
+    el.onloadedmetadata = () => resolve(el.duration);
+    el.onerror = () => resolve(0);
+  });
+}
+function usePlaylist() {
+  const [playlist, setPlaylist] = react.useState([]);
+  const [currentIndex, setCurrentIndex] = react.useState(null);
+  const playlistRef = react.useRef(playlist);
+  react.useEffect(() => {
+    playlistRef.current = playlist;
+  });
+  react.useEffect(() => {
+    try {
+      const saved = localStorage.getItem(STORAGE_KEY);
+      if (saved) {
+        const items = JSON.parse(saved).filter(
+          (i) => i.type === "stream"
+        );
+        if (items.length > 0) setPlaylist(items);
+      }
+    } catch {
+    }
+  }, []);
+  react.useEffect(() => {
+    try {
+      const serializable = playlist.filter((i) => i.type === "stream");
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(serializable));
+    } catch {
+    }
+  }, [playlist]);
+  react.useEffect(() => {
+    return () => {
+      playlistRef.current.forEach((item) => {
+        if (item.file) URL.revokeObjectURL(item.url);
+      });
+    };
+  }, []);
+  const currentItem = currentIndex !== null ? playlist[currentIndex] ?? null : null;
+  const selectItem = react.useCallback((index) => {
+    setCurrentIndex(index);
+  }, []);
+  const appendItem = react.useCallback((item) => {
+    setPlaylist((p) => [...p, item]);
+  }, []);
+  const removeItem = react.useCallback(
+    (index) => {
+      setPlaylist((prev) => {
+        const item = prev[index];
+        if (item?.file) URL.revokeObjectURL(item.url);
+        return prev.filter((_, i) => i !== index);
+      });
+      setCurrentIndex((idx) => {
+        if (idx === null) return idx;
+        if (index === idx) {
+          const newLen = playlistRef.current.length - 1;
+          if (newLen === 0) return null;
+          return Math.min(idx, newLen - 1);
+        }
+        if (index < idx) return idx - 1;
+        return idx;
+      });
+    },
+    []
+  );
+  const reorderItems = react.useCallback((newPlaylist) => {
+    setPlaylist(newPlaylist);
+    setCurrentIndex((idx) => {
+      if (idx === null) return idx;
+      const currentItem2 = playlistRef.current[idx];
+      if (!currentItem2) return idx;
+      const newIdx = newPlaylist.findIndex((i) => i.id === currentItem2.id);
+      return newIdx === -1 ? idx : newIdx;
+    });
+  }, []);
+  const replaceWithFile = react.useCallback((file) => {
+    setPlaylist((prev) => {
+      prev.forEach((item) => {
+        if (item.file) URL.revokeObjectURL(item.url);
+      });
+      const url = URL.createObjectURL(file);
+      return [
+        {
+          id: crypto.randomUUID(),
+          name: file.name,
+          url,
+          type: "video",
+          file
+        }
+      ];
+    });
+    setCurrentIndex(0);
+  }, []);
+  const addFiles = react.useCallback(async (files) => {
+    const items = await Promise.all(
+      files.map(async (file) => {
+        const url = URL.createObjectURL(file);
+        const duration = await getFileDuration(url);
+        return {
+          id: crypto.randomUUID(),
+          name: file.name,
+          url,
+          type: "video",
+          file,
+          duration
+        };
+      })
+    );
+    setPlaylist((prev) => [...prev, ...items]);
+    return items;
+  }, []);
+  const nextItem = react.useCallback(() => {
+    setCurrentIndex((idx) => {
+      if (idx === null || playlistRef.current.length <= 1) return idx;
+      return (idx + 1) % playlistRef.current.length;
+    });
+  }, []);
+  const prevItem = react.useCallback(() => {
+    setCurrentIndex((idx) => {
+      if (idx === null || playlistRef.current.length <= 1) return idx;
+      return (idx - 1 + playlistRef.current.length) % playlistRef.current.length;
+    });
+  }, []);
+  const parseFiles = react.useCallback(
+    (files) => {
+      const videoFiles = [];
+      const subtitleFiles = [];
+      Array.from(files).forEach((file) => {
+        const fileName = file.name.toLowerCase();
+        if (file.type.startsWith("video/") || VIDEO_EXTENSIONS.some((ext) => fileName.endsWith(ext))) {
+          videoFiles.push(file);
+        } else if (SUBTITLE_EXTENSIONS.some((ext) => fileName.endsWith(ext))) {
+          subtitleFiles.push(file);
+        }
+      });
+      return { videoFiles, subtitleFiles };
+    },
+    []
+  );
+  return {
+    playlist,
+    currentIndex,
+    currentItem,
+    selectItem,
+    appendItem,
+    removeItem,
+    reorderItems,
+    addFiles,
+    replaceWithFile,
+    nextItem,
+    prevItem,
+    parseFiles,
+    setPlaylist,
+    setCurrentIndex
+  };
+}
+
+// src/utils/keyboard-shortcuts.ts
+function matchesShortcut(e, binding) {
+  const keyMatches = e.key === binding.key || e.key.toLowerCase() === binding.key.toLowerCase();
+  if (!keyMatches) return false;
+  if (!!binding.modifiers?.ctrl !== e.ctrlKey) return false;
+  if (!!binding.modifiers?.shift !== e.shiftKey) return false;
+  if (!!binding.modifiers?.alt !== e.altKey) return false;
+  return true;
+}
+function isInteractiveElement(el) {
+  if (!el || !(el instanceof HTMLElement)) return false;
+  const tag = el.tagName.toLowerCase();
+  return ["input", "textarea", "select", "button", "a"].includes(tag) || el.contentEditable === "true" || el.getAttribute("contenteditable") !== null;
+}
+
+// src/react/use-keyboard-shortcuts.ts
+function useKeyboardShortcuts(shortcuts, handlers) {
+  react.useEffect(() => {
+    const handler = (e) => {
+      if (isInteractiveElement(document.activeElement)) return;
+      for (const binding of shortcuts) {
+        if (matchesShortcut(e, binding)) {
+          e.preventDefault();
+          handlers[binding.action]?.();
+          break;
+        }
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [shortcuts, handlers]);
+}
+function useFullscreen(containerRef) {
+  const [isFullscreen, setIsFullscreen] = react.useState(false);
+  react.useEffect(() => {
+    const onFullscreenChange = () => setIsFullscreen(!!document.fullscreenElement);
+    document.addEventListener("fullscreenchange", onFullscreenChange);
+    return () => document.removeEventListener("fullscreenchange", onFullscreenChange);
+  }, []);
+  const toggle = react.useCallback(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    if (!document.fullscreenElement) {
+      container.requestFullscreen().catch((err) => {
+        console.error(`Fullscreen error: ${err.message}`);
+      });
+    } else {
+      document.exitFullscreen();
+    }
+  }, [containerRef]);
+  return { isFullscreen, toggle };
+}
+function usePictureInPicture(videoRef) {
+  const [isPiP, setIsPiP] = react.useState(false);
+  const isSupported = typeof document !== "undefined" && "pictureInPictureEnabled" in document && document.pictureInPictureEnabled;
+  react.useEffect(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    const onEnter = () => setIsPiP(true);
+    const onLeave = () => setIsPiP(false);
+    video.addEventListener("enterpictureinpicture", onEnter);
+    video.addEventListener("leavepictureinpicture", onLeave);
+    return () => {
+      video.removeEventListener("enterpictureinpicture", onEnter);
+      video.removeEventListener("leavepictureinpicture", onLeave);
+    };
+  }, [videoRef]);
+  const enter = react.useCallback(async () => {
+    const video = videoRef.current;
+    if (!video) return;
+    try {
+      await video.requestPictureInPicture();
+    } catch (err) {
+      console.error("Failed to enter picture-in-picture:", err);
+    }
+  }, [videoRef]);
+  const exit = react.useCallback(async () => {
+    try {
+      await document.exitPictureInPicture();
+    } catch (err) {
+      console.error("Failed to exit picture-in-picture:", err);
+    }
+  }, []);
+  const toggle = react.useCallback(async () => {
+    if (isPiP) {
+      await exit();
+    } else {
+      await enter();
+    }
+  }, [isPiP, enter, exit]);
+  return { isPiP, isSupported, enter, exit, toggle };
+}
+var STORAGE_PREFIX = "lightbirdplayer-";
+var SAVE_DEBOUNCE_MS = 5e3;
+function useProgressPersistence(videoRef, currentVideoName) {
+  react.useEffect(() => {
+    if (!currentVideoName || !videoRef.current) return;
+    const saved = localStorage.getItem(`${STORAGE_PREFIX}${currentVideoName}`);
+    if (saved) {
+      const time = parseFloat(saved);
+      if (!isNaN(time)) videoRef.current.currentTime = time;
+    }
+  }, [currentVideoName, videoRef]);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el || !currentVideoName) return;
+    let timer = null;
+    const onTimeUpdate = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        localStorage.setItem(`${STORAGE_PREFIX}${currentVideoName}`, String(el.currentTime));
+      }, SAVE_DEBOUNCE_MS);
+    };
+    el.addEventListener("timeupdate", onTimeUpdate);
+    return () => {
+      el.removeEventListener("timeupdate", onTimeUpdate);
+      if (timer) {
+        clearTimeout(timer);
+        localStorage.setItem(`${STORAGE_PREFIX}${currentVideoName}`, String(el.currentTime));
+      }
+    };
+  }, [currentVideoName, videoRef]);
+}
+
+// src/utils/video-info.ts
+function detectContainerFromUrl(url) {
+  const ext = url.split("?")[0].split(".").pop()?.toUpperCase();
+  return ext ?? "Unknown";
+}
+function extractNativeMetadata(videoEl, file) {
+  const container = file ? file.name.split(".").pop()?.toUpperCase() ?? "Unknown" : detectContainerFromUrl(videoEl.currentSrc);
+  return {
+    filename: file?.name ?? videoEl.currentSrc,
+    fileSize: file?.size ?? null,
+    duration: videoEl.duration || 0,
+    container,
+    width: videoEl.videoWidth,
+    height: videoEl.videoHeight,
+    frameRate: null,
+    videoBitrate: null,
+    videoCodec: null,
+    colorSpace: null,
+    audioTracks: [],
+    subtitleTracks: []
+  };
+}
+
+// src/react/use-video-info.ts
+function useVideoInfo(videoRef, currentFile) {
+  const [metadata, setMetadata] = react.useState(null);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    const onLoaded = () => {
+      const native = extractNativeMetadata(el, currentFile ?? void 0);
+      setMetadata((prev) => ({ ...prev, ...native }));
+    };
+    el.addEventListener("loadedmetadata", onLoaded);
+    return () => el.removeEventListener("loadedmetadata", onLoaded);
+  }, [videoRef, currentFile]);
+  react.useEffect(() => {
+    if (!currentFile) setMetadata(null);
+  }, [currentFile]);
+  const enrichMetadata = react.useCallback((extra) => {
+    setMetadata((prev) => prev ? { ...prev, ...extra } : null);
+  }, []);
+  return { metadata, enrichMetadata };
+}
+function useMediaSession(options) {
+  const { title, artwork, onPlay, onPause, onNext, onPrev, onSeekForward, onSeekBackward } = options;
+  react.useEffect(() => {
+    if (!("mediaSession" in navigator) || !navigator.mediaSession) return;
+    if (!title) {
+      navigator.mediaSession.metadata = null;
+      return;
+    }
+    const artworkList = artwork ? [{ src: artwork, sizes: "320x180", type: "image/jpeg" }] : [];
+    navigator.mediaSession.metadata = new MediaMetadata({
+      title,
+      artist: "LightBird",
+      artwork: artworkList
+    });
+  }, [title, artwork]);
+  react.useEffect(() => {
+    if (!("mediaSession" in navigator) || !navigator.mediaSession) return;
+    navigator.mediaSession.setActionHandler("play", onPlay);
+    navigator.mediaSession.setActionHandler("pause", onPause);
+    navigator.mediaSession.setActionHandler("nexttrack", onNext);
+    navigator.mediaSession.setActionHandler("previoustrack", onPrev);
+    navigator.mediaSession.setActionHandler("seekforward", ({ seekOffset }) => onSeekForward());
+    navigator.mediaSession.setActionHandler("seekbackward", ({ seekOffset }) => onSeekBackward());
+    return () => {
+      navigator.mediaSession.setActionHandler("play", null);
+      navigator.mediaSession.setActionHandler("pause", null);
+      navigator.mediaSession.setActionHandler("nexttrack", null);
+      navigator.mediaSession.setActionHandler("previoustrack", null);
+      navigator.mediaSession.setActionHandler("seekforward", null);
+      navigator.mediaSession.setActionHandler("seekbackward", null);
+    };
+  }, [onPlay, onPause, onNext, onPrev, onSeekForward, onSeekBackward]);
+  react.useEffect(() => {
+    return () => {
+      if (!("mediaSession" in navigator) || !navigator.mediaSession) return;
+      navigator.mediaSession.metadata = null;
+    };
+  }, []);
+}
+function useChapters(videoRef, playerRef) {
+  const [chapters, setChapters] = react.useState([]);
+  const [currentChapter, setCurrentChapter] = react.useState(null);
+  react.useEffect(() => {
+    const player = playerRef.current;
+    const loaded = player?.getChapters?.() ?? [];
+    setChapters(loaded);
+    setCurrentChapter(null);
+  }, [playerRef.current]);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el || chapters.length === 0) {
+      setCurrentChapter(null);
+      return;
+    }
+    const onTimeUpdate = () => {
+      const t = el.currentTime;
+      const active = chapters.find((c) => t >= c.startTime && t < c.endTime) ?? null;
+      setCurrentChapter(active);
+    };
+    el.addEventListener("timeupdate", onTimeUpdate);
+    return () => el.removeEventListener("timeupdate", onTimeUpdate);
+  }, [videoRef, chapters]);
+  const goToChapter = react.useCallback(
+    (index) => {
+      const el = videoRef.current;
+      if (!el || !chapters[index]) return;
+      el.currentTime = chapters[index].startTime;
+    },
+    [videoRef, chapters]
+  );
+  return { chapters, currentChapter, goToChapter };
+}
+
+exports.useChapters = useChapters;
+exports.useFullscreen = useFullscreen;
+exports.useKeyboardShortcuts = useKeyboardShortcuts;
+exports.useMediaSession = useMediaSession;
+exports.usePictureInPicture = usePictureInPicture;
+exports.usePlaylist = usePlaylist;
+exports.useProgressPersistence = useProgressPersistence;
+exports.useSubtitles = useSubtitles;
+exports.useVideoFilters = useVideoFilters;
+exports.useVideoInfo = useVideoInfo;
+exports.useVideoPlayback = useVideoPlayback;