@lightbird/core 0.4.0 → 0.6.0

package/dist/index.js

@@ -236,6 +236,121 @@ function parseVttTimestamp(ts) {
   return NaN;
 }
 
+// src/utils/language-names.ts
+var LANGUAGE_NAMES = {
+  // English
+  en: "English",
+  eng: "English",
+  // Japanese
+  ja: "Japanese",
+  jpn: "Japanese",
+  // Chinese
+  zh: "Chinese",
+  chi: "Chinese",
+  zho: "Chinese",
+  // Korean
+  ko: "Korean",
+  kor: "Korean",
+  // French
+  fr: "French",
+  fre: "French",
+  fra: "French",
+  // German
+  de: "German",
+  ger: "German",
+  deu: "German",
+  // Spanish
+  es: "Spanish",
+  spa: "Spanish",
+  // Italian
+  it: "Italian",
+  ita: "Italian",
+  // Portuguese
+  pt: "Portuguese",
+  por: "Portuguese",
+  // Russian
+  ru: "Russian",
+  rus: "Russian",
+  // Dutch
+  nl: "Dutch",
+  dut: "Dutch",
+  nld: "Dutch",
+  // Polish
+  pl: "Polish",
+  pol: "Polish",
+  // Arabic
+  ar: "Arabic",
+  ara: "Arabic",
+  // Hindi
+  hi: "Hindi",
+  hin: "Hindi",
+  // Bengali
+  bn: "Bengali",
+  ben: "Bengali",
+  // Turkish
+  tr: "Turkish",
+  tur: "Turkish",
+  // Swedish
+  sv: "Swedish",
+  swe: "Swedish",
+  // Norwegian
+  no: "Norwegian",
+  nor: "Norwegian",
+  // Danish
+  da: "Danish",
+  dan: "Danish",
+  // Finnish
+  fi: "Finnish",
+  fin: "Finnish",
+  // Greek
+  el: "Greek",
+  gre: "Greek",
+  ell: "Greek",
+  // Hebrew
+  he: "Hebrew",
+  heb: "Hebrew",
+  // Thai
+  th: "Thai",
+  tha: "Thai",
+  // Vietnamese
+  vi: "Vietnamese",
+  vie: "Vietnamese",
+  // Indonesian
+  id: "Indonesian",
+  ind: "Indonesian",
+  // Malay
+  ms: "Malay",
+  may: "Malay",
+  msa: "Malay",
+  // Czech
+  cs: "Czech",
+  cze: "Czech",
+  ces: "Czech",
+  // Hungarian
+  hu: "Hungarian",
+  hun: "Hungarian",
+  // Romanian
+  ro: "Romanian",
+  rum: "Romanian",
+  ron: "Romanian",
+  // Ukrainian
+  uk: "Ukrainian",
+  ukr: "Ukrainian",
+  // Tamil
+  ta: "Tamil",
+  tam: "Tamil",
+  // Telugu
+  te: "Telugu",
+  tel: "Telugu"
+};
+var UNDETERMINED = /* @__PURE__ */ new Set(["", "und", "unknown", "mis", "zxx", "mul"]);
+function getLanguageName(code) {
+  if (!code) return void 0;
+  const normalized = code.trim().toLowerCase();
+  if (UNDETERMINED.has(normalized)) return void 0;
+  return LANGUAGE_NAMES[normalized] ?? code.trim();
+}
+
 // src/players/mkv-player.ts
 async function canPlayNatively(objectUrl, timeoutMs = 3e3) {
   return new Promise((resolve) => {
@@ -264,23 +379,76 @@ function parseStreamInfo(logs) {
   const videoTracks = [];
   const audioTracks = [];
   const subtitleTracks = [];
+  let current = null;
   const lines = logs.split("\n");
   for (const line of lines) {
-    const streamMatch = line.match(/Stream #\d+:\d+(?:\((\w+)\))?: (Video|Audio|Subtitle): (\S+)/i);
-    if (!streamMatch) continue;
-    const [, lang, type, codec] = streamMatch;
-    const titleMatch = line.match(/\btitle\s*:\s*([^,\n]+)/i);
-    const title = titleMatch ? titleMatch[1].trim() : void 0;
-    if (type.toLowerCase() === "video") {
-      videoTracks.push({ index: videoTracks.length, type: "video", codec, lang, title });
-    } else if (type.toLowerCase() === "audio") {
-      audioTracks.push({ index: audioTracks.length, type: "audio", codec, lang, title });
-    } else if (type.toLowerCase() === "subtitle") {
-      subtitleTracks.push({ index: subtitleTracks.length, type: "subtitle", codec, lang, title });
+    if (/^\s*Stream #\d+:\d+/.test(line)) {
+      current = null;
+    }
+    const streamMatch = line.match(
+      /Stream #\d+:\d+(?:\((\w+)\))?: (Video|Audio|Subtitle): (.+)$/i
+    );
+    if (streamMatch) {
+      const [, lang, type, rest] = streamMatch;
+      const codec = rest.trim().split(/[\s,]/)[0];
+      const forced = /\(forced\)/i.test(rest);
+      const isDefault = /\(default\)/i.test(rest);
+      const t = type.toLowerCase();
+      const bucket = t === "video" ? videoTracks : t === "audio" ? audioTracks : subtitleTracks;
+      current = {
+        index: bucket.length,
+        type: t,
+        codec,
+        lang,
+        forced,
+        default: isDefault
+      };
+      bucket.push(current);
+      continue;
+    }
+    if (/^\s*(Chapter #|Program )/i.test(line)) {
+      current = null;
+      continue;
+    }
+    if (current && current.title === void 0) {
+      const titleMatch = line.match(/^\s*title\s*:\s*(.+)$/i);
+      if (titleMatch) {
+        current.title = titleMatch[1].trim();
+      }
     }
   }
   return { videoTracks, audioTracks, subtitleTracks };
 }
+function formatTrackName(index, t) {
+  let label = t.title?.trim() || `Track ${index + 1}`;
+  const langName = getLanguageName(t.lang);
+  if (langName) label += ` - [${langName}]`;
+  if (t.forced) label += " [Forced]";
+  return label;
+}
+function buildAudioTracks(tracks) {
+  if (tracks.length === 0) {
+    return [{ id: "0", name: "Default Audio", lang: "unknown" }];
+  }
+  return tracks.map((t, i) => ({
+    id: String(i),
+    name: formatTrackName(i, t),
+    lang: t.lang ?? "unknown"
+  }));
+}
+function buildSubtitleTracks(tracks, trackMap) {
+  trackMap.clear();
+  return tracks.map((t, i) => {
+    const id = String(i);
+    trackMap.set(id, i);
+    return {
+      id,
+      name: formatTrackName(i, t),
+      lang: t.lang ?? "unknown",
+      type: "embedded"
+    };
+  });
+}
 var _MKVPlayer = class _MKVPlayer {
   constructor(file, onProgress) {
     this.videoElement = null;
@@ -399,22 +567,11 @@ var _MKVPlayer = class _MKVPlayer {
       });
       const { audioTracks, subtitleTracks } = parseStreamInfo(result.logs);
       this.chapters = parseChaptersFromFFmpegLog(result.logs, videoElement.duration || 0);
-      this.playerFile.audioTracks = audioTracks.length > 0 ? audioTracks.map((t, i) => ({
-        id: String(i),
-        name: t.title ?? (t.lang ? `Audio ${i + 1} (${t.lang})` : `Audio ${i + 1}`),
-        lang: t.lang ?? "unknown"
-      })) : [{ id: "0", name: "Default Audio", lang: "unknown" }];
-      this.subtitleTrackMap.clear();
-      this.playerFile.subtitleTracks = subtitleTracks.map((t, i) => {
-        const id = String(i);
-        this.subtitleTrackMap.set(id, i);
-        return {
-          id,
-          name: t.title ?? (t.lang ? `Subtitle ${i + 1} (${t.lang})` : `Subtitle ${i + 1}`),
-          lang: t.lang ?? "unknown",
-          type: "embedded"
-        };
-      });
+      this.playerFile.audioTracks = buildAudioTracks(audioTracks);
+      this.playerFile.subtitleTracks = buildSubtitleTracks(
+        subtitleTracks,
+        this.subtitleTrackMap
+      );
       const blob = new Blob([result.data], { type: "video/mp4" });
       const url = URL.createObjectURL(blob);
       this.remuxCache.set(0, url);
@@ -445,22 +602,11 @@ var _MKVPlayer = class _MKVPlayer {
     });
     if (this._cancelled) return;
     const { audioTracks, subtitleTracks } = parseStreamInfo(probeResult.logs);
-    this.playerFile.audioTracks = audioTracks.length > 0 ? audioTracks.map((t, i) => ({
-      id: String(i),
-      name: t.title ?? (t.lang ? `Audio ${i + 1} (${t.lang})` : `Audio ${i + 1}`),
-      lang: t.lang ?? "unknown"
-    })) : [{ id: "0", name: "Default Audio", lang: "unknown" }];
-    this.subtitleTrackMap.clear();
-    this.playerFile.subtitleTracks = subtitleTracks.map((t, i) => {
-      const id = String(i);
-      this.subtitleTrackMap.set(id, i);
-      return {
-        id,
-        name: t.title ?? (t.lang ? `Subtitle ${i + 1} (${t.lang})` : `Subtitle ${i + 1}`),
-        lang: t.lang ?? "unknown",
-        type: "embedded"
-      };
-    });
+    this.playerFile.audioTracks = buildAudioTracks(audioTracks);
+    this.playerFile.subtitleTracks = buildSubtitleTracks(
+      subtitleTracks,
+      this.subtitleTrackMap
+    );
   }
   async _remux(audioTrackIndex) {
     const cached = this.remuxCache.get(audioTrackIndex);
@@ -1409,6 +1555,61 @@ async function captureVideoThumbnail(videoEl, atSeconds = 5) {
     }
   });
 }
+async function captureFrameAt(videoEl, timeSeconds, width = 160, height = 90) {
+  return new Promise((resolve) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      resolve(null);
+      return;
+    }
+    let settled = false;
+    const cleanup = () => {
+      videoEl.removeEventListener("seeked", onSeeked);
+      videoEl.removeEventListener("error", onError);
+      videoEl.removeEventListener("loadedmetadata", onLoadedMetadata);
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const draw = () => {
+      try {
+        ctx.drawImage(videoEl, 0, 0, width, height);
+        finish(canvas.toDataURL("image/jpeg", 0.6));
+      } catch {
+        finish(null);
+      }
+    };
+    const seekTo = () => {
+      const duration = videoEl.duration || 0;
+      const target = duration > 0 ? Math.max(0, Math.min(timeSeconds, duration)) : Math.max(0, timeSeconds);
+      if (Math.abs(videoEl.currentTime - target) < 0.05) {
+        draw();
+        return;
+      }
+      try {
+        videoEl.currentTime = target;
+      } catch {
+        finish(null);
+      }
+    };
+    const onSeeked = () => draw();
+    const onError = () => finish(null);
+    const onLoadedMetadata = () => seekTo();
+    videoEl.addEventListener("seeked", onSeeked);
+    videoEl.addEventListener("error", onError);
+    if (videoEl.readyState >= 1) {
+      seekTo();
+    } else {
+      videoEl.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    }
+  });
+}
 
 // src/utils/keyboard-shortcuts.ts
 var DEFAULT_SHORTCUTS = [
@@ -1537,4 +1738,4 @@ function resetFFmpeg() {
   loading = null;
 }
 
-export { ASSRenderer, CancellationError, DEFAULT_SHORTCUTS, DEFAULT_TRACKERS, DISCLAIMER_KEY, FLAG_MAGNET_LINK, HLSPlayer, MKVPlayer, ProgressEstimator, SimplePlayer, SubtitleConverter, UniversalSubtitleManager, VIDEO_EXTENSIONS, acceptDisclaimer, applyOffsetToVtt, captureVideoThumbnail, configureLightBird, createOffsetVttUrl, createVideoPlayer, destroyWebTorrentClient, exportPlaylist, extractNativeMetadata, formatShortcutKey, getFFmpeg, getVideoFiles, getWebTorrentClient, hasAcceptedDisclaimer, initFeatureFlags, isHlsUrl, isInteractiveElement, isMagnetUri, isVideoFile, loadShortcuts, matchesShortcut, parseChaptersFromFFmpegLog, parseChaptersFromVtt, parseM3U8, parseMediaError, resetFFmpeg, saveShortcuts, validateFile };
+export { ASSRenderer, CancellationError, DEFAULT_SHORTCUTS, DEFAULT_TRACKERS, DISCLAIMER_KEY, FLAG_MAGNET_LINK, HLSPlayer, MKVPlayer, ProgressEstimator, SimplePlayer, SubtitleConverter, UniversalSubtitleManager, VIDEO_EXTENSIONS, acceptDisclaimer, applyOffsetToVtt, captureFrameAt, captureVideoThumbnail, configureLightBird, createOffsetVttUrl, createVideoPlayer, destroyWebTorrentClient, exportPlaylist, extractNativeMetadata, formatShortcutKey, getFFmpeg, getLanguageName, getVideoFiles, getWebTorrentClient, hasAcceptedDisclaimer, initFeatureFlags, isHlsUrl, isInteractiveElement, isMagnetUri, isVideoFile, loadShortcuts, matchesShortcut, parseChaptersFromFFmpegLog, parseChaptersFromVtt, parseM3U8, parseMediaError, resetFFmpeg, saveShortcuts, validateFile };

package/dist/react/index.cjs

@@ -1143,6 +1143,317 @@ function useMagnet() {
   return { torrentStatus, addMagnet, destroyMagnet };
 }
 
+// src/utils/video-thumbnail.ts
+async function captureFrameAt(videoEl, timeSeconds, width = 160, height = 90) {
+  return new Promise((resolve) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      resolve(null);
+      return;
+    }
+    let settled = false;
+    const cleanup = () => {
+      videoEl.removeEventListener("seeked", onSeeked);
+      videoEl.removeEventListener("error", onError);
+      videoEl.removeEventListener("loadedmetadata", onLoadedMetadata);
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const draw = () => {
+      try {
+        ctx.drawImage(videoEl, 0, 0, width, height);
+        finish(canvas.toDataURL("image/jpeg", 0.6));
+      } catch {
+        finish(null);
+      }
+    };
+    const seekTo = () => {
+      const duration = videoEl.duration || 0;
+      const target = duration > 0 ? Math.max(0, Math.min(timeSeconds, duration)) : Math.max(0, timeSeconds);
+      if (Math.abs(videoEl.currentTime - target) < 0.05) {
+        draw();
+        return;
+      }
+      try {
+        videoEl.currentTime = target;
+      } catch {
+        finish(null);
+      }
+    };
+    const onSeeked = () => draw();
+    const onError = () => finish(null);
+    const onLoadedMetadata = () => seekTo();
+    videoEl.addEventListener("seeked", onSeeked);
+    videoEl.addEventListener("error", onError);
+    if (videoEl.readyState >= 1) {
+      seekTo();
+    } else {
+      videoEl.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
+    }
+  });
+}
+
+// src/react/use-seek-preview.ts
+function useSeekPreview(videoRef, options = {}) {
+  const { debounceMs = 120, width = 160, height = 90 } = options;
+  const [thumbnail, setThumbnail] = react.useState(null);
+  const [time, setTime] = react.useState(null);
+  const offscreenRef = react.useRef(null);
+  const loadedSrcRef = react.useRef("");
+  const cacheRef = react.useRef(/* @__PURE__ */ new Map());
+  const timerRef = react.useRef(null);
+  const requestSeqRef = react.useRef(0);
+  const syncOffscreenSource = react.useCallback(() => {
+    const main = videoRef.current;
+    const src = main?.currentSrc || main?.src || "";
+    if (!src) return null;
+    if (!offscreenRef.current) {
+      const v = document.createElement("video");
+      v.muted = true;
+      v.preload = "metadata";
+      v.crossOrigin = "anonymous";
+      v.setAttribute("playsinline", "");
+      offscreenRef.current = v;
+    }
+    const offscreen = offscreenRef.current;
+    if (loadedSrcRef.current !== src) {
+      loadedSrcRef.current = src;
+      cacheRef.current.clear();
+      offscreen.src = src;
+    }
+    return offscreen;
+  }, [videoRef]);
+  const clearPreview = react.useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    requestSeqRef.current += 1;
+    setThumbnail(null);
+    setTime(null);
+  }, []);
+  const requestPreview = react.useCallback(
+    (timeSeconds) => {
+      const main = videoRef.current;
+      if (!main) return;
+      const duration = main.duration;
+      const hasDuration = !!duration && !Number.isNaN(duration);
+      const clamped = hasDuration ? Math.max(0, Math.min(timeSeconds, duration)) : Math.max(0, timeSeconds);
+      setTime(clamped);
+      if (!hasDuration) return;
+      const seq = ++requestSeqRef.current;
+      const bucket = Math.round(clamped);
+      const cached = cacheRef.current.get(bucket);
+      if (cached) {
+        setThumbnail(cached);
+        return;
+      }
+      if (timerRef.current) clearTimeout(timerRef.current);
+      timerRef.current = setTimeout(() => {
+        timerRef.current = null;
+        const offscreen = syncOffscreenSource();
+        if (!offscreen) return;
+        captureFrameAt(offscreen, bucket, width, height).then((dataUrl) => {
+          if (seq !== requestSeqRef.current) return;
+          if (dataUrl) {
+            cacheRef.current.set(bucket, dataUrl);
+            setThumbnail(dataUrl);
+          }
+        });
+      }, debounceMs);
+    },
+    [videoRef, syncOffscreenSource, debounceMs, width, height]
+  );
+  react.useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      const offscreen = offscreenRef.current;
+      if (offscreen) offscreen.removeAttribute("src");
+    };
+  }, []);
+  return { thumbnail, time, requestPreview, clearPreview };
+}
+function useABLoop(videoRef) {
+  const [pointA, setA] = react.useState(null);
+  const [pointB, setB] = react.useState(null);
+  const setPointA = react.useCallback(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    const t = el.currentTime;
+    setA(t);
+    setB((b) => b !== null && b <= t ? null : b);
+  }, [videoRef]);
+  const setPointB = react.useCallback(() => {
+    const el = videoRef.current;
+    if (!el || pointA === null) return;
+    const t = el.currentTime;
+    if (t <= pointA) return;
+    setB(t);
+  }, [videoRef, pointA]);
+  const clear = react.useCallback(() => {
+    setA(null);
+    setB(null);
+  }, []);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el || pointA === null || pointB === null) return;
+    const onTimeUpdate = () => {
+      if (el.currentTime >= pointB || el.currentTime < pointA) {
+        el.currentTime = pointA;
+      }
+    };
+    el.addEventListener("timeupdate", onTimeUpdate);
+    return () => el.removeEventListener("timeupdate", onTimeUpdate);
+  }, [videoRef, pointA, pointB]);
+  react.useEffect(() => {
+    const el = videoRef.current;
+    if (!el) return;
+    const onReset = () => clear();
+    el.addEventListener("loadstart", onReset);
+    el.addEventListener("emptied", onReset);
+    return () => {
+      el.removeEventListener("loadstart", onReset);
+      el.removeEventListener("emptied", onReset);
+    };
+  }, [videoRef, clear]);
+  return {
+    pointA,
+    pointB,
+    isLooping: pointA !== null && pointB !== null,
+    setPointA,
+    setPointB,
+    clear
+  };
+}
+var SWIPE_THRESHOLD = 10;
+var DOUBLE_TAP_DISTANCE = 40;
+function useTouchGestures(targetRef, handlers, options = {}) {
+  const { enabled = true, seekSeconds = 10, doubleTapMs = 300, feedbackMs = 700 } = options;
+  const [feedback, setFeedback] = react.useState(null);
+  const handlersRef = react.useRef(handlers);
+  react.useEffect(() => {
+    handlersRef.current = handlers;
+  });
+  const startRef = react.useRef(null);
+  const phaseRef = react.useRef("idle");
+  const swipeBaseRef = react.useRef(0);
+  const lastTapRef = react.useRef(null);
+  const feedbackTimerRef = react.useRef(null);
+  const showFeedback = react.useCallback(
+    (fb) => {
+      setFeedback(fb);
+      if (feedbackTimerRef.current) clearTimeout(feedbackTimerRef.current);
+      feedbackTimerRef.current = setTimeout(() => setFeedback(null), feedbackMs);
+    },
+    [feedbackMs]
+  );
+  react.useEffect(() => {
+    const el = targetRef.current;
+    if (!el || !enabled) return;
+    const onTouchStart = (e) => {
+      if (e.touches.length !== 1) {
+        startRef.current = null;
+        phaseRef.current = "ignore";
+        return;
+      }
+      const t = e.touches[0];
+      const rect = el.getBoundingClientRect();
+      const relX = t.clientX - rect.left;
+      startRef.current = {
+        x: t.clientX,
+        y: t.clientY,
+        zone: relX < rect.width / 2 ? "left" : "right",
+        height: rect.height || 1
+      };
+      phaseRef.current = "pending";
+    };
+    const onTouchMove = (e) => {
+      const start = startRef.current;
+      if (!start || phaseRef.current === "ignore" || phaseRef.current === "idle") return;
+      const t = e.touches[0];
+      if (!t) return;
+      const dx = t.clientX - start.x;
+      const dy = t.clientY - start.y;
+      if (phaseRef.current === "pending") {
+        if (Math.hypot(dx, dy) < SWIPE_THRESHOLD) return;
+        if (Math.abs(dy) > Math.abs(dx)) {
+          phaseRef.current = "swipe";
+          const h = handlersRef.current;
+          swipeBaseRef.current = start.zone === "left" ? h.getBrightness?.() ?? 1 : h.getVolume?.() ?? 1;
+        } else {
+          phaseRef.current = "ignore";
+          return;
+        }
+      }
+      if (phaseRef.current === "swipe") {
+        if (e.cancelable) e.preventDefault();
+        const fraction = -dy / start.height;
+        const next = Math.max(0, Math.min(1, swipeBaseRef.current + fraction));
+        const h = handlersRef.current;
+        if (start.zone === "left") {
+          h.setBrightness?.(next);
+          showFeedback({ type: "brightness", value: next });
+        } else {
+          h.setVolume?.(next);
+          showFeedback({ type: "volume", value: next });
+        }
+      }
+    };
+    const onTouchEnd = (e) => {
+      const start = startRef.current;
+      const phase = phaseRef.current;
+      startRef.current = null;
+      phaseRef.current = "idle";
+      if (!start || phase === "ignore") return;
+      if (phase === "swipe") {
+        lastTapRef.current = null;
+        return;
+      }
+      const point = e.changedTouches[0];
+      const px = point ? point.clientX : start.x;
+      const py = point ? point.clientY : start.y;
+      const now = Date.now();
+      const last = lastTapRef.current;
+      if (last && last.zone === start.zone && now - last.time < doubleTapMs && Math.hypot(px - last.x, py - last.y) < DOUBLE_TAP_DISTANCE) {
+        lastTapRef.current = null;
+        if (e.cancelable) e.preventDefault();
+        const h = handlersRef.current;
+        if (start.zone === "left") {
+          h.seekBy?.(-seekSeconds);
+          showFeedback({ type: "seek", direction: "backward", seconds: seekSeconds });
+        } else {
+          h.seekBy?.(seekSeconds);
+          showFeedback({ type: "seek", direction: "forward", seconds: seekSeconds });
+        }
+      } else {
+        lastTapRef.current = { x: px, y: py, time: now, zone: start.zone };
+      }
+    };
+    el.addEventListener("touchstart", onTouchStart, { passive: true });
+    el.addEventListener("touchmove", onTouchMove, { passive: false });
+    el.addEventListener("touchend", onTouchEnd, { passive: false });
+    return () => {
+      el.removeEventListener("touchstart", onTouchStart);
+      el.removeEventListener("touchmove", onTouchMove);
+      el.removeEventListener("touchend", onTouchEnd);
+    };
+  }, [targetRef, enabled, seekSeconds, doubleTapMs, showFeedback]);
+  react.useEffect(() => {
+    return () => {
+      if (feedbackTimerRef.current) clearTimeout(feedbackTimerRef.current);
+    };
+  }, []);
+  return { feedback };
+}
+
+exports.useABLoop = useABLoop;
 exports.useChapters = useChapters;
 exports.useFullscreen = useFullscreen;
 exports.useKeyboardShortcuts = useKeyboardShortcuts;
@@ -1151,7 +1462,9 @@ exports.useMediaSession = useMediaSession;
 exports.usePictureInPicture = usePictureInPicture;
 exports.usePlaylist = usePlaylist;
 exports.useProgressPersistence = useProgressPersistence;
+exports.useSeekPreview = useSeekPreview;
 exports.useSubtitles = useSubtitles;
+exports.useTouchGestures = useTouchGestures;
 exports.useVideoFilters = useVideoFilters;
 exports.useVideoInfo = useVideoInfo;
 exports.useVideoPlayback = useVideoPlayback;