@scarlett-player/hls 1.1.1 → 1.4.0

package/dist/index.js

@@ -1,15 +1,20 @@
 import {
-  formatLevel,
-  getInitialBandwidthEstimate,
-  mapLevels,
-  setupHlsEventHandlers,
-  setupVideoEventHandlers
-} from "./chunk-L73PRXS4.js";
-
-// src/index.ts
-import { ErrorCode } from "@scarlett-player/core";
+  __export,
+  createHLSPluginWith
+} from "./chunk-IFUZZQQE.js";
 
 // src/hls-loader.ts
+var hls_loader_exports = {};
+__export(hls_loader_exports, {
+  createHlsInstance: () => createHlsInstance,
+  getHlsConstructor: () => getHlsConstructor,
+  isHLSSupported: () => isHLSSupported,
+  isHlsJsSupported: () => isHlsJsSupported,
+  loadHlsJs: () => loadHlsJs,
+  resetLoader: () => resetLoader,
+  shouldPreferNativeHLS: () => shouldPreferNativeHLS,
+  supportsNativeHLS: () => supportsNativeHLS
+});
 var hlsConstructor = null;
 var loadingPromise = null;
 function supportsNativeHLS() {
@@ -17,6 +22,13 @@ function supportsNativeHLS() {
   const video = document.createElement("video");
   return video.canPlayType("application/vnd.apple.mpegurl") !== "";
 }
+function shouldPreferNativeHLS() {
+  if (!supportsNativeHLS()) return false;
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent;
+  const isSafari = /Safari/.test(ua) && !/Chrome/.test(ua) && !/CriOS/.test(ua);
+  return isSafari;
+}
 function isHlsJsSupported() {
   if (hlsConstructor) {
     return hlsConstructor.isSupported();
@@ -60,692 +72,23 @@ function createHlsInstance(config) {
 function getHlsConstructor() {
   return hlsConstructor;
 }
+function resetLoader() {
+  hlsConstructor = null;
+  loadingPromise = null;
+}
 
 // src/index.ts
-var DEFAULT_CONFIG = {
-  debug: false,
-  autoStartLoad: true,
-  startPosition: -1,
-  lowLatencyMode: false,
-  maxBufferLength: 30,
-  maxMaxBufferLength: 600,
-  backBufferLength: 30,
-  enableWorker: true,
-  capLevelToPlayerSize: true,
-  // Error recovery settings
-  maxNetworkRetries: 3,
-  maxMediaRetries: 2,
-  retryDelayMs: 1e3,
-  retryBackoffFactor: 2,
-  // Load watchdog: never leave the viewer on an endless spinner
-  loadTimeoutMs: 3e4,
-  // Self-healing: reconnect automatically after fatal errors mid-playback
-  autoReconnect: true,
-  reconnectBaseDelayMs: 2e3,
-  reconnectMaxDelayMs: 3e4,
-  reconnectWindowMs: 3e5
-};
-var MANIFEST_PHASE_ERRORS = [
-  "manifestLoadError",
-  "manifestLoadTimeOut",
-  "manifestParsingError"
-];
 function createHLSPlugin(config) {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-  let api = null;
-  let hls = null;
-  let video = null;
-  let isNative = false;
-  let currentSrc = null;
-  let cleanupHlsEvents = null;
-  let cleanupVideoEvents = null;
-  let isAutoQuality = true;
-  let networkRetryCount = 0;
-  let mediaRetryCount = 0;
-  let retryTimeout = null;
-  let errorCount = 0;
-  let errorWindowStart = 0;
-  const MAX_ERRORS_IN_WINDOW = 10;
-  const ERROR_WINDOW_MS = 5e3;
-  let hasPlayedContent = false;
-  let reconnectTimer = null;
-  let reconnectAttempts = 0;
-  let reconnectWindowStart = 0;
-  let reconnectResumePosition = 0;
-  let onlineListener = null;
-  const getOrCreateVideo = () => {
-    if (video) return video;
-    const existing = api?.container.querySelector("video");
-    if (existing) {
-      video = existing;
-      return video;
-    }
-    video = document.createElement("video");
-    video.style.cssText = "position:absolute;top:0;left:0;width:100%;height:100%;display:block;object-fit:contain;background:#000";
-    video.preload = "metadata";
-    video.controls = false;
-    video.playsInline = true;
-    const poster = api?.getState("poster");
-    if (poster) {
-      video.poster = poster;
-    }
-    api?.container.appendChild(video);
-    return video;
-  };
-  const cleanup = () => {
-    cleanupHlsEvents?.();
-    cleanupHlsEvents = null;
-    cleanupVideoEvents?.();
-    cleanupVideoEvents = null;
-    if (retryTimeout) {
-      clearTimeout(retryTimeout);
-      retryTimeout = null;
-    }
-    if (hls) {
-      hls.destroy();
-      hls = null;
-    }
-    currentSrc = null;
-    isNative = false;
-    isAutoQuality = true;
-    networkRetryCount = 0;
-    mediaRetryCount = 0;
-    errorCount = 0;
-    errorWindowStart = 0;
-  };
-  const buildHlsConfig = () => ({
-    debug: mergedConfig.debug,
-    autoStartLoad: mergedConfig.autoStartLoad,
-    startPosition: mergedConfig.startPosition,
-    startLevel: -1,
-    // Auto quality selection (ABR)
-    abrEwmaDefaultEstimate: getInitialBandwidthEstimate(mergedConfig.initialBandwidthEstimate),
-    lowLatencyMode: mergedConfig.lowLatencyMode,
-    maxBufferLength: mergedConfig.maxBufferLength,
-    maxMaxBufferLength: mergedConfig.maxMaxBufferLength,
-    backBufferLength: mergedConfig.backBufferLength,
-    enableWorker: mergedConfig.enableWorker,
-    capLevelToPlayerSize: mergedConfig.capLevelToPlayerSize,
-    // Minimize hls.js internal retries - we handle retries ourselves
-    fragLoadingMaxRetry: 1,
-    manifestLoadingMaxRetry: 1,
-    levelLoadingMaxRetry: 1,
-    fragLoadingRetryDelay: 500,
-    manifestLoadingRetryDelay: 500,
-    levelLoadingRetryDelay: 500
-  });
-  const getRetryDelay = (retryCount) => {
-    const baseDelay = mergedConfig.retryDelayMs ?? 1e3;
-    const backoffFactor = mergedConfig.retryBackoffFactor ?? 2;
-    const delay = baseDelay * Math.pow(backoffFactor, retryCount);
-    const jitter = delay * (0.7 + Math.random() * 0.3);
-    return jitter;
-  };
-  const mapFatalErrorCode = (error) => {
-    switch (error.type) {
-      case "network":
-        return ErrorCode.MEDIA_NETWORK_ERROR;
-      case "media":
-      case "mux":
-        return ErrorCode.MEDIA_DECODE_ERROR;
-      default:
-        return ErrorCode.PLAYBACK_FAILED;
-    }
-  };
-  const emitFatalError = (error, retriesExhausted) => {
-    const message = retriesExhausted ? `HLS error: ${error.details} (max retries exceeded)` : `HLS error: ${error.details}`;
-    api?.logger.error(message, { type: error.type, details: error.details });
-    api?.setState("playbackState", "error");
-    api?.setState("buffering", false);
-    api?.emit("error", {
-      code: mapFatalErrorCode(error),
-      message,
-      fatal: true,
-      timestamp: Date.now()
-    });
-    maybeScheduleReconnect(error);
-  };
-  const handleHlsError = (error) => {
-    const Hls = getHlsConstructor();
-    if (!Hls || !hls) return false;
-    const now = Date.now();
-    if (now - errorWindowStart > ERROR_WINDOW_MS) {
-      errorCount = 1;
-      errorWindowStart = now;
-    } else {
-      errorCount++;
-    }
-    if (errorCount >= MAX_ERRORS_IN_WINDOW) {
-      api?.logger.error(`Too many errors (${errorCount} in ${ERROR_WINDOW_MS}ms), giving up`);
-      emitFatalError(error, true);
-      cleanupHlsEvents?.();
-      cleanupHlsEvents = null;
-      hls.destroy();
-      hls = null;
-      return true;
-    }
-    if (error.fatal) {
-      api?.logger.error("Fatal HLS error", { type: error.type, details: error.details });
-      switch (error.type) {
-        case "network": {
-          const maxRetries = mergedConfig.maxNetworkRetries ?? 3;
-          if (networkRetryCount >= maxRetries) {
-            api?.logger.error(`Network error recovery failed after ${networkRetryCount} attempts`);
-            emitFatalError(error, true);
-            return true;
-          }
-          networkRetryCount++;
-          const delay = getRetryDelay(networkRetryCount - 1);
-          api?.logger.info(`Attempting network error recovery (attempt ${networkRetryCount}/${maxRetries}) in ${delay}ms`);
-          api?.emit("error:network", { error: new Error(error.details) });
-          if (retryTimeout) {
-            clearTimeout(retryTimeout);
-          }
-          const isManifestPhase = MANIFEST_PHASE_ERRORS.includes(error.details);
-          retryTimeout = setTimeout(() => {
-            if (!hls) return;
-            if (isManifestPhase && currentSrc) {
-              hls.loadSource(currentSrc);
-            } else {
-              hls.startLoad();
-            }
-          }, delay);
-          break;
-        }
-        case "media": {
-          const maxRetries = mergedConfig.maxMediaRetries ?? 2;
-          if (mediaRetryCount >= maxRetries) {
-            api?.logger.error(`Media error recovery failed after ${mediaRetryCount} attempts`);
-            emitFatalError(error, true);
-            return true;
-          }
-          mediaRetryCount++;
-          const delay = getRetryDelay(mediaRetryCount - 1);
-          api?.logger.info(`Attempting media error recovery (attempt ${mediaRetryCount}/${maxRetries}) in ${delay}ms`);
-          api?.emit("error:media", { error: new Error(error.details) });
-          if (retryTimeout) {
-            clearTimeout(retryTimeout);
-          }
-          retryTimeout = setTimeout(() => {
-            if (hls) {
-              hls.recoverMediaError();
-            }
-          }, delay);
-          break;
-        }
-        default:
-          emitFatalError(error, false);
-          return true;
-      }
-    }
-    return false;
-  };
-  const loadNative = async (src) => {
-    const videoEl = getOrCreateVideo();
-    isNative = true;
-    if (api) {
-      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
-    }
-    return new Promise((resolve, reject) => {
-      let watchdog = null;
-      const settle = () => {
-        videoEl.removeEventListener("loadedmetadata", onLoaded);
-        videoEl.removeEventListener("error", onError);
-        if (watchdog !== null) {
-          clearTimeout(watchdog);
-          watchdog = null;
-        }
-      };
-      const onLoaded = () => {
-        settle();
-        hasPlayedContent = true;
-        const onFatalVideoError = () => {
-          const media_error = videoEl.error;
-          const hls_error = {
-            type: media_error?.code === MediaError.MEDIA_ERR_NETWORK ? "network" : "media",
-            details: media_error?.message || "Native HLS playback error",
-            fatal: true
-          };
-          emitFatalError(hls_error, false);
-        };
-        videoEl.addEventListener("error", onFatalVideoError);
-        const removeFatalListener = () => videoEl.removeEventListener("error", onFatalVideoError);
-        const previous_cleanup = cleanupVideoEvents;
-        cleanupVideoEvents = () => {
-          removeFatalListener();
-          previous_cleanup?.();
-        };
-        api?.setState("source", { src, type: "application/x-mpegURL" });
-        api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
-        resolve();
-      };
-      const onError = () => {
-        settle();
-        const error = videoEl.error;
-        reject(new Error(error?.message || "Failed to load HLS source"));
-      };
-      const timeout_ms = mergedConfig.loadTimeoutMs ?? 3e4;
-      if (timeout_ms > 0) {
-        watchdog = setTimeout(() => {
-          settle();
-          reject(new Error("Video took too long to load (network timeout)"));
-        }, timeout_ms);
-      }
-      videoEl.addEventListener("loadedmetadata", onLoaded);
-      videoEl.addEventListener("error", onError);
-      videoEl.src = src;
-      videoEl.load();
-    });
-  };
-  const loadWithHlsJs = async (src) => {
-    await loadHlsJs();
-    const videoEl = getOrCreateVideo();
-    isNative = false;
-    hls = createHlsInstance(buildHlsConfig());
-    if (api) {
-      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
-    }
-    return new Promise((resolve, reject) => {
-      if (!hls || !api) {
-        reject(new Error("HLS not initialized"));
-        return;
-      }
-      let resolved = false;
-      let watchdog = null;
-      const clearWatchdog = () => {
-        if (watchdog !== null) {
-          clearTimeout(watchdog);
-          watchdog = null;
-        }
-      };
-      cleanupHlsEvents = setupHlsEventHandlers(hls, api, {
-        onManifestParsed: () => {
-          if (!resolved) {
-            resolved = true;
-            clearWatchdog();
-            hasPlayedContent = true;
-            api?.setState("source", { src, type: "application/x-mpegURL" });
-            api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
-            resolve();
-          }
-        },
-        onLevelSwitched: () => {
-        },
-        onError: (error) => {
-          const terminal = handleHlsError(error);
-          if (terminal && !resolved) {
-            resolved = true;
-            clearWatchdog();
-            reject(new Error(error.details));
-          }
-        },
-        onFragLoaded: () => {
-          if (networkRetryCount > 0 || mediaRetryCount > 0) {
-            api?.logger.debug("Playback recovered, resetting retry budgets");
-            networkRetryCount = 0;
-            mediaRetryCount = 0;
-          }
-        },
-        getIsAutoQuality: () => isAutoQuality
-      });
-      const timeout_ms = mergedConfig.loadTimeoutMs ?? 3e4;
-      if (timeout_ms > 0) {
-        watchdog = setTimeout(() => {
-          if (resolved) return;
-          resolved = true;
-          api?.logger.error(`HLS load timed out after ${timeout_ms}ms`, { src });
-          if (retryTimeout) {
-            clearTimeout(retryTimeout);
-            retryTimeout = null;
-          }
-          cleanupHlsEvents?.();
-          cleanupHlsEvents = null;
-          hls?.destroy();
-          hls = null;
-          reject(new Error("Video took too long to load (network timeout)"));
-        }, timeout_ms);
-      }
-      hls.attachMedia(videoEl);
-      hls.loadSource(src);
-    });
-  };
-  const cancelReconnect = () => {
-    if (reconnectTimer) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    reconnectAttempts = 0;
-    reconnectWindowStart = 0;
-    reconnectResumePosition = 0;
-  };
-  const scheduleReconnectAttempt = () => {
-    if (reconnectTimer) return;
-    const window_ms = mergedConfig.reconnectWindowMs ?? 3e5;
-    if (Date.now() - reconnectWindowStart > window_ms) {
-      api?.logger.warn(`Auto-reconnect window exhausted after ${reconnectAttempts} attempts`);
-      return;
-    }
-    const base_delay = mergedConfig.reconnectBaseDelayMs ?? 2e3;
-    const max_delay = mergedConfig.reconnectMaxDelayMs ?? 3e4;
-    const backoff = Math.min(base_delay * Math.pow(2, reconnectAttempts), max_delay);
-    const delay = Math.round(backoff * (0.7 + Math.random() * 0.3));
-    api?.logger.info(`Scheduling auto-reconnect attempt ${reconnectAttempts + 1} in ${delay}ms`);
-    api?.emit("error:reconnecting", { attempt: reconnectAttempts + 1, delayMs: delay });
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      void attemptReconnect();
-    }, delay);
-  };
-  const maybeScheduleReconnect = (error) => {
-    if (mergedConfig.autoReconnect === false) return;
-    if (!hasPlayedContent || !currentSrc) return;
-    if (error.type !== "network" && error.type !== "media") return;
-    if (reconnectWindowStart === 0) {
-      reconnectWindowStart = Date.now();
-      reconnectResumePosition = video?.currentTime ?? 0;
-    }
-    scheduleReconnectAttempt();
-  };
-  const attemptReconnect = async () => {
-    if (!api || !currentSrc) return;
-    reconnectAttempts++;
-    const saved_src = currentSrc;
-    const was_live = api.getState("live");
-    const was_native = isNative;
-    const resume_position = reconnectResumePosition;
-    api.logger.info(`Auto-reconnect attempt ${reconnectAttempts}`, { src: saved_src });
-    try {
-      cleanupHlsEvents?.();
-      cleanupHlsEvents = null;
-      cleanupVideoEvents?.();
-      cleanupVideoEvents = null;
-      if (retryTimeout) {
-        clearTimeout(retryTimeout);
-        retryTimeout = null;
-      }
-      hls?.destroy();
-      hls = null;
-      networkRetryCount = 0;
-      mediaRetryCount = 0;
-      errorCount = 0;
-      errorWindowStart = 0;
-      currentSrc = saved_src;
-      api.setState("playbackState", "loading");
-      if (was_native && supportsNativeHLS()) {
-        await loadNative(saved_src);
-      } else {
-        await loadWithHlsJs(saved_src);
-      }
-      if (!was_live && video && resume_position > 0) {
-        video.currentTime = resume_position;
-      }
-      api.setState("playbackState", "ready");
-      api.setState("buffering", false);
-      api.emit("error:recovered", void 0);
-      api.logger.info("Auto-reconnect succeeded");
-      cancelReconnect();
-      try {
-        await video?.play();
-      } catch {
-      }
-    } catch {
-      api?.logger.warn(`Auto-reconnect attempt ${reconnectAttempts} failed`);
-      scheduleReconnectAttempt();
-    }
-  };
-  const plugin = {
-    id: "hls-provider",
-    name: "HLS Provider",
-    version: "1.0.0",
-    type: "provider",
-    description: "HLS playback provider using hls.js",
-    canPlay(src) {
-      if (!isHLSSupported()) return false;
-      const url = src.toLowerCase();
-      const urlWithoutQuery = url.split("?")[0].split("#")[0];
-      if (urlWithoutQuery.endsWith(".m3u8")) return true;
-      if (url.includes("application/x-mpegurl")) return true;
-      if (url.includes("application/vnd.apple.mpegurl")) return true;
-      return false;
+  return createHLSPluginWith(
+    hls_loader_exports,
+    {
+      name: "HLS Provider",
+      description: "HLS playback provider using hls.js",
+      logSuffix: "",
+      engineLabel: "hls.js"
     },
-    async init(pluginApi) {
-      api = pluginApi;
-      api.logger.info("HLS plugin initialized");
-      const unsubPlay = api.on("playback:play", async () => {
-        if (!video) return;
-        try {
-          await video.play();
-        } catch (e) {
-          api?.logger.error("Play failed", e);
-        }
-      });
-      const unsubPause = api.on("playback:pause", () => {
-        video?.pause();
-      });
-      const unsubSeek = api.on("playback:seeking", ({ time }) => {
-        if (!video) return;
-        const clampedTime = Math.max(0, Math.min(time, video.duration || 0));
-        video.currentTime = clampedTime;
-      });
-      const unsubVolume = api.on("volume:change", ({ volume }) => {
-        if (video) video.volume = volume;
-      });
-      const unsubMute = api.on("volume:mute", ({ muted }) => {
-        if (video) video.muted = muted;
-      });
-      const unsubRate = api.on("playback:ratechange", ({ rate }) => {
-        if (video) video.playbackRate = rate;
-      });
-      const unsubQuality = api.on("quality:select", ({ quality, auto }) => {
-        if (!hls || isNative) {
-          api?.logger.warn("Quality selection not available");
-          return;
-        }
-        if (auto || quality === "auto") {
-          isAutoQuality = true;
-          hls.currentLevel = -1;
-          api?.logger.debug("Quality: auto selection enabled");
-          api?.setState("currentQuality", {
-            id: "auto",
-            label: "Auto",
-            width: 0,
-            height: 0,
-            bitrate: 0,
-            active: true
-          });
-        } else {
-          isAutoQuality = false;
-          const levelIndex = parseInt(quality.replace("level-", ""), 10);
-          if (!isNaN(levelIndex) && levelIndex >= 0 && levelIndex < hls.levels.length) {
-            hls.nextLevel = levelIndex;
-            api?.logger.debug(`Quality: queued switch to level ${levelIndex}`);
-            const targetLevel = hls.levels[levelIndex];
-            if (targetLevel) {
-              const label = formatLevel(targetLevel);
-              api?.setState("currentQuality", {
-                id: `level-${levelIndex}`,
-                label: `${label}...`,
-                // Ellipsis indicates switching in progress
-                width: targetLevel.width,
-                height: targetLevel.height,
-                bitrate: targetLevel.bitrate,
-                active: false
-                // Not yet active
-              });
-            }
-          }
-        }
-      });
-      if (typeof window !== "undefined") {
-        onlineListener = () => {
-          if (reconnectTimer) {
-            api?.logger.info("Browser back online, reconnecting immediately");
-            clearTimeout(reconnectTimer);
-            reconnectTimer = null;
-            void attemptReconnect();
-          }
-        };
-        window.addEventListener("online", onlineListener);
-      }
-      api.onDestroy(() => {
-        unsubPlay();
-        unsubPause();
-        unsubSeek();
-        unsubVolume();
-        unsubMute();
-        unsubRate();
-        unsubQuality();
-      });
-    },
-    async destroy() {
-      api?.logger.info("HLS plugin destroying");
-      cancelReconnect();
-      if (onlineListener && typeof window !== "undefined") {
-        window.removeEventListener("online", onlineListener);
-        onlineListener = null;
-      }
-      cleanup();
-      if (video?.parentNode) {
-        video.parentNode.removeChild(video);
-      }
-      video = null;
-      api = null;
-    },
-    async loadSource(src) {
-      if (!api) throw new Error("Plugin not initialized");
-      api.logger.info("Loading HLS source", { src });
-      cancelReconnect();
-      hasPlayedContent = false;
-      cleanup();
-      currentSrc = src;
-      api.setState("playbackState", "loading");
-      api.setState("buffering", true);
-      if (api.getState("airplayActive") && supportsNativeHLS()) {
-        api.logger.info("Using native HLS (AirPlay active)");
-        await loadNative(src);
-      } else if (isHlsJsSupported()) {
-        api.logger.info("Using hls.js for HLS playback");
-        await loadWithHlsJs(src);
-      } else if (supportsNativeHLS()) {
-        api.logger.info("Using native HLS playback (hls.js not supported)");
-        await loadNative(src);
-      } else {
-        throw new Error("HLS playback not supported in this browser");
-      }
-      if (video) {
-        const muted = api.getState("muted");
-        const volume = api.getState("volume");
-        if (muted !== void 0) video.muted = muted;
-        if (volume !== void 0) video.volume = volume;
-      }
-      api.setState("playbackState", "ready");
-      api.setState("buffering", false);
-    },
-    getCurrentLevel() {
-      if (isNative || !hls) return -1;
-      return hls.currentLevel;
-    },
-    setLevel(index) {
-      if (isNative || !hls) {
-        api?.logger.warn("Quality selection not available in native HLS mode");
-        return;
-      }
-      hls.currentLevel = index;
-    },
-    getLevels() {
-      if (isNative || !hls) return [];
-      return mapLevels(hls.levels, hls.currentLevel);
-    },
-    getHlsInstance() {
-      return hls;
-    },
-    isNativeHLS() {
-      return isNative;
-    },
-    getLiveInfo() {
-      if (isNative || !hls) return null;
-      const live = api?.getState("live") || false;
-      if (!live) return null;
-      return {
-        isLive: true,
-        latency: hls.latency || 0,
-        targetLatency: hls.targetLatency || 3,
-        drift: hls.drift || 0
-      };
-    },
-    /**
-     * Switch from hls.js to native HLS playback.
-     * Used for AirPlay compatibility in Safari.
-     * Preserves current playback position.
-     */
-    async switchToNative() {
-      if (isNative) {
-        api?.logger.debug("Already using native HLS");
-        return;
-      }
-      if (!supportsNativeHLS()) {
-        api?.logger.warn("Native HLS not supported in this browser");
-        return;
-      }
-      if (!currentSrc) {
-        api?.logger.warn("No source loaded");
-        return;
-      }
-      api?.logger.info("Switching to native HLS for AirPlay");
-      const wasPlaying = api?.getState("playing") || false;
-      const currentTime = video?.currentTime || 0;
-      const savedSrc = currentSrc;
-      cleanup();
-      await loadNative(savedSrc);
-      if (video && currentTime > 0) {
-        video.currentTime = currentTime;
-      }
-      if (wasPlaying && video) {
-        try {
-          await video.play();
-        } catch (e) {
-          api?.logger.debug("Could not auto-resume after switch");
-        }
-      }
-      api?.logger.info("Switched to native HLS");
-    },
-    /**
-     * Switch from native HLS back to hls.js.
-     * Restores quality control after AirPlay session ends.
-     */
-    async switchToHlsJs() {
-      if (!isNative) {
-        api?.logger.debug("Already using hls.js");
-        return;
-      }
-      if (!isHlsJsSupported()) {
-        api?.logger.warn("hls.js not supported in this browser");
-        return;
-      }
-      if (!currentSrc) {
-        api?.logger.warn("No source loaded");
-        return;
-      }
-      api?.logger.info("Switching back to hls.js");
-      const wasPlaying = api?.getState("playing") || false;
-      const currentTime = video?.currentTime || 0;
-      const savedSrc = currentSrc;
-      cleanup();
-      await loadWithHlsJs(savedSrc);
-      if (video && currentTime > 0) {
-        video.currentTime = currentTime;
-      }
-      if (wasPlaying && video) {
-        try {
-          await video.play();
-        } catch (e) {
-          api?.logger.debug("Could not auto-resume after switch");
-        }
-      }
-      api?.logger.info("Switched to hls.js");
-    }
-  };
-  return plugin;
+    config
+  );
 }
 var index_default = createHLSPlugin;
 export {