@scarlett-player/hls 0.1.0

package/dist/index.js

@@ -0,0 +1,767 @@
+// src/hls-loader.ts
+var hlsConstructor = null;
+var loadingPromise = null;
+function supportsNativeHLS() {
+  if (typeof document === "undefined") return false;
+  const video = document.createElement("video");
+  return video.canPlayType("application/vnd.apple.mpegurl") !== "";
+}
+function isHlsJsSupported() {
+  if (hlsConstructor) {
+    return hlsConstructor.isSupported();
+  }
+  if (typeof window === "undefined") return false;
+  return !!(window.MediaSource || window.WebKitMediaSource);
+}
+function isHLSSupported() {
+  return supportsNativeHLS() || isHlsJsSupported();
+}
+async function loadHlsJs() {
+  if (hlsConstructor) {
+    return hlsConstructor;
+  }
+  if (loadingPromise) {
+    return loadingPromise;
+  }
+  loadingPromise = (async () => {
+    try {
+      const hlsModule = await import("hls.js");
+      hlsConstructor = hlsModule.default;
+      if (!hlsConstructor.isSupported()) {
+        throw new Error("hls.js is not supported in this browser");
+      }
+      return hlsConstructor;
+    } catch (error) {
+      loadingPromise = null;
+      throw new Error(
+        `Failed to load hls.js: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  })();
+  return loadingPromise;
+}
+function createHlsInstance(config) {
+  if (!hlsConstructor) {
+    throw new Error("hls.js is not loaded. Call loadHlsJs() first.");
+  }
+  return new hlsConstructor(config);
+}
+function getHlsConstructor() {
+  return hlsConstructor;
+}
+
+// src/quality.ts
+function formatLevel(level) {
+  if (level.name) {
+    return level.name;
+  }
+  if (level.height) {
+    const standardLabels = {
+      2160: "4K",
+      1440: "1440p",
+      1080: "1080p",
+      720: "720p",
+      480: "480p",
+      360: "360p",
+      240: "240p",
+      144: "144p"
+    };
+    const closest = Object.keys(standardLabels).map(Number).sort((a, b) => Math.abs(a - level.height) - Math.abs(b - level.height))[0];
+    if (Math.abs(closest - level.height) <= 20) {
+      return standardLabels[closest];
+    }
+    return `${level.height}p`;
+  }
+  if (level.bitrate) {
+    return formatBitrate(level.bitrate);
+  }
+  return "Unknown";
+}
+function formatBitrate(bitrate) {
+  if (bitrate >= 1e6) {
+    return `${(bitrate / 1e6).toFixed(1)} Mbps`;
+  }
+  if (bitrate >= 1e3) {
+    return `${Math.round(bitrate / 1e3)} Kbps`;
+  }
+  return `${bitrate} bps`;
+}
+function mapLevels(levels, currentLevel) {
+  return levels.map((level, index) => ({
+    index,
+    width: level.width || 0,
+    height: level.height || 0,
+    bitrate: level.bitrate || 0,
+    label: formatLevel(level),
+    codec: level.codecSet
+  }));
+}
+
+// src/event-map.ts
+var HLS_ERROR_TYPES = {
+  NETWORK_ERROR: "networkError",
+  MEDIA_ERROR: "mediaError",
+  KEY_SYSTEM_ERROR: "keySystemError",
+  MUX_ERROR: "muxError",
+  OTHER_ERROR: "otherError"
+};
+function mapErrorType(hlsType) {
+  switch (hlsType) {
+    case HLS_ERROR_TYPES.NETWORK_ERROR:
+      return "network";
+    case HLS_ERROR_TYPES.MEDIA_ERROR:
+      return "media";
+    case HLS_ERROR_TYPES.MUX_ERROR:
+      return "mux";
+    default:
+      return "other";
+  }
+}
+function parseHlsError(data) {
+  return {
+    type: mapErrorType(data.type),
+    details: data.details || "Unknown error",
+    fatal: data.fatal || false,
+    url: data.url,
+    reason: data.reason,
+    response: data.response
+  };
+}
+function setupHlsEventHandlers(hls, api, callbacks) {
+  const handlers = [];
+  const addHandler = (event, handler) => {
+    hls.on(event, handler);
+    handlers.push({ event, handler });
+  };
+  addHandler("hlsManifestParsed", (_event, data) => {
+    api.logger.debug("HLS manifest parsed", { levels: data.levels.length });
+    const levels = data.levels.map((level, index) => ({
+      id: `level-${index}`,
+      label: formatLevel(level),
+      width: level.width,
+      height: level.height,
+      bitrate: level.bitrate,
+      active: index === hls.currentLevel
+    }));
+    api.setState("qualities", levels);
+    api.emit("quality:levels", {
+      levels: levels.map((l) => ({ id: l.id, label: l.label }))
+    });
+    callbacks.onManifestParsed?.(data.levels);
+  });
+  addHandler("hlsLevelSwitched", (_event, data) => {
+    const level = hls.levels[data.level];
+    const isAuto = callbacks.getIsAutoQuality?.() ?? hls.autoLevelEnabled;
+    api.logger.debug("HLS level switched", { level: data.level, height: level?.height, auto: isAuto });
+    if (level) {
+      const label = isAuto ? `Auto (${formatLevel(level)})` : formatLevel(level);
+      api.setState("currentQuality", {
+        id: isAuto ? "auto" : `level-${data.level}`,
+        label,
+        width: level.width,
+        height: level.height,
+        bitrate: level.bitrate,
+        active: true
+      });
+    }
+    api.emit("quality:change", {
+      quality: level ? formatLevel(level) : "auto",
+      auto: isAuto
+    });
+    callbacks.onLevelSwitched?.(data.level);
+  });
+  addHandler("hlsFragBuffered", () => {
+    api.setState("buffering", false);
+    callbacks.onBufferUpdate?.();
+  });
+  addHandler("hlsFragLoading", () => {
+    api.setState("buffering", true);
+  });
+  addHandler("hlsLevelLoaded", (_event, data) => {
+    if (data.details?.live !== void 0) {
+      api.setState("live", data.details.live);
+      callbacks.onLiveUpdate?.();
+    }
+  });
+  addHandler("hlsError", (_event, data) => {
+    const error = parseHlsError(data);
+    api.logger.warn("HLS error", { error });
+    callbacks.onError?.(error);
+  });
+  return () => {
+    for (const { event, handler } of handlers) {
+      hls.off(event, handler);
+    }
+    handlers.length = 0;
+  };
+}
+function setupVideoEventHandlers(video, api) {
+  const handlers = [];
+  const addHandler = (event, handler) => {
+    video.addEventListener(event, handler);
+    handlers.push({ event, handler });
+  };
+  addHandler("playing", () => {
+    api.setState("playing", true);
+    api.setState("paused", false);
+    api.setState("playbackState", "playing");
+  });
+  addHandler("pause", () => {
+    api.setState("playing", false);
+    api.setState("paused", true);
+    api.setState("playbackState", "paused");
+  });
+  addHandler("ended", () => {
+    api.setState("playing", false);
+    api.setState("ended", true);
+    api.setState("playbackState", "ended");
+    api.emit("playback:ended", void 0);
+  });
+  addHandler("timeupdate", () => {
+    api.setState("currentTime", video.currentTime);
+    api.emit("playback:timeupdate", { currentTime: video.currentTime });
+  });
+  addHandler("durationchange", () => {
+    api.setState("duration", video.duration || 0);
+    api.emit("media:loadedmetadata", { duration: video.duration || 0 });
+  });
+  addHandler("waiting", () => {
+    api.setState("waiting", true);
+    api.setState("buffering", true);
+    api.emit("media:waiting", void 0);
+  });
+  addHandler("canplay", () => {
+    api.setState("waiting", false);
+    api.setState("playbackState", "ready");
+    api.emit("media:canplay", void 0);
+  });
+  addHandler("canplaythrough", () => {
+    api.setState("buffering", false);
+    api.emit("media:canplaythrough", void 0);
+  });
+  addHandler("progress", () => {
+    if (video.buffered.length > 0) {
+      const bufferedEnd = video.buffered.end(video.buffered.length - 1);
+      const bufferedAmount = video.duration > 0 ? bufferedEnd / video.duration : 0;
+      api.setState("bufferedAmount", bufferedAmount);
+      api.setState("buffered", video.buffered);
+      api.emit("media:progress", { buffered: bufferedAmount });
+    }
+  });
+  addHandler("seeking", () => {
+    api.setState("seeking", true);
+  });
+  addHandler("seeked", () => {
+    api.setState("seeking", false);
+    api.emit("playback:seeked", { time: video.currentTime });
+  });
+  addHandler("volumechange", () => {
+    api.setState("volume", video.volume);
+    api.setState("muted", video.muted);
+    api.emit("volume:change", { volume: video.volume, muted: video.muted });
+  });
+  addHandler("ratechange", () => {
+    api.setState("playbackRate", video.playbackRate);
+    api.emit("playback:ratechange", { rate: video.playbackRate });
+  });
+  addHandler("loadedmetadata", () => {
+    api.setState("duration", video.duration);
+    api.setState("mediaType", video.videoWidth > 0 ? "video" : "audio");
+  });
+  addHandler("error", () => {
+    const error = video.error;
+    if (error) {
+      api.logger.error("Video element error", { code: error.code, message: error.message });
+      api.emit("media:error", { error: new Error(error.message || "Video playback error") });
+    }
+  });
+  addHandler("enterpictureinpicture", () => {
+    api.setState("pip", true);
+    api.logger.debug("PiP: entered (standard)");
+  });
+  addHandler("leavepictureinpicture", () => {
+    api.setState("pip", false);
+    api.logger.debug("PiP: exited (standard)");
+    if (!video.paused || api.getState("playing")) {
+      video.play().catch(() => {
+      });
+    }
+  });
+  const webkitVideo = video;
+  if ("webkitPresentationMode" in video) {
+    addHandler("webkitpresentationmodechanged", () => {
+      const mode = webkitVideo.webkitPresentationMode;
+      const isInPip = mode === "picture-in-picture";
+      api.setState("pip", isInPip);
+      api.logger.debug(`PiP: mode changed to ${mode} (webkit)`);
+      if (mode === "inline" && video.paused) {
+        video.play().catch(() => {
+        });
+      }
+    });
+  }
+  return () => {
+    for (const { event, handler } of handlers) {
+      video.removeEventListener(event, handler);
+    }
+    handlers.length = 0;
+  };
+}
+
+// src/index.ts
+var DEFAULT_CONFIG = {
+  debug: false,
+  autoStartLoad: true,
+  startPosition: -1,
+  lowLatencyMode: false,
+  maxBufferLength: 30,
+  maxMaxBufferLength: 600,
+  backBufferLength: 30,
+  enableWorker: true,
+  // Error recovery settings
+  maxNetworkRetries: 3,
+  maxMediaRetries: 2,
+  retryDelayMs: 1e3,
+  retryBackoffFactor: 2
+};
+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;
+  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 = "width:100%;height:100%;display:block;object-fit:contain;background:#000";
+    video.preload = "metadata";
+    video.controls = false;
+    video.playsInline = true;
+    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)
+    lowLatencyMode: mergedConfig.lowLatencyMode,
+    maxBufferLength: mergedConfig.maxBufferLength,
+    maxMaxBufferLength: mergedConfig.maxMaxBufferLength,
+    backBufferLength: mergedConfig.backBufferLength,
+    enableWorker: mergedConfig.enableWorker,
+    // 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;
+    return baseDelay * Math.pow(backoffFactor, retryCount);
+  };
+  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: "MEDIA_ERROR",
+      message,
+      fatal: true,
+      timestamp: Date.now()
+    });
+  };
+  const handleHlsError = (error) => {
+    const Hls = getHlsConstructor();
+    if (!Hls || !hls) return;
+    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;
+    }
+    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;
+          }
+          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);
+          }
+          retryTimeout = setTimeout(() => {
+            if (hls) {
+              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;
+          }
+          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);
+          break;
+      }
+    }
+  };
+  const loadNative = async (src) => {
+    const videoEl = getOrCreateVideo();
+    isNative = true;
+    if (api) {
+      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
+    }
+    return new Promise((resolve, reject) => {
+      const onLoaded = () => {
+        videoEl.removeEventListener("loadedmetadata", onLoaded);
+        videoEl.removeEventListener("error", onError);
+        api?.setState("source", { src, type: "application/x-mpegURL" });
+        api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+        resolve();
+      };
+      const onError = () => {
+        videoEl.removeEventListener("loadedmetadata", onLoaded);
+        videoEl.removeEventListener("error", onError);
+        const error = videoEl.error;
+        reject(new Error(error?.message || "Failed to load HLS source"));
+      };
+      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;
+      cleanupHlsEvents = setupHlsEventHandlers(hls, api, {
+        onManifestParsed: () => {
+          if (!resolved) {
+            resolved = true;
+            api?.setState("source", { src, type: "application/x-mpegURL" });
+            api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+            resolve();
+          }
+        },
+        onLevelSwitched: () => {
+        },
+        onError: (error) => {
+          handleHlsError(error);
+          if (error.fatal && !resolved && error.type !== "network" && error.type !== "media") {
+            resolved = true;
+            reject(new Error(error.details));
+          }
+        },
+        getIsAutoQuality: () => isAutoQuality
+      });
+      hls.attachMedia(videoEl);
+      hls.loadSource(src);
+    });
+  };
+  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;
+    },
+    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.currentLevel = levelIndex;
+            api?.logger.debug(`Quality: set to level ${levelIndex}`);
+          }
+        }
+      });
+      api.onDestroy(() => {
+        unsubPlay();
+        unsubPause();
+        unsubSeek();
+        unsubVolume();
+        unsubMute();
+        unsubRate();
+        unsubQuality();
+      });
+    },
+    async destroy() {
+      api?.logger.info("HLS plugin destroying");
+      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 });
+      cleanup();
+      currentSrc = src;
+      api.setState("playbackState", "loading");
+      api.setState("buffering", true);
+      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");
+      }
+      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;
+}
+var index_default = createHLSPlugin;
+export {
+  createHLSPlugin,
+  index_default as default
+};