@lightbird/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1357 @@
+'use strict';
+
+var assCompiler = require('ass-compiler');
+var ffmpeg = require('@ffmpeg/ffmpeg');
+var util = require('@ffmpeg/util');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/config.ts
+var config = {};
+function configureLightBird(options) {
+  config = { ...config, ...options };
+}
+function getConfig() {
+  return config;
+}
+
+// src/players/simple-player.ts
+var SimplePlayer = class {
+  constructor(file, externalSubtitles = []) {
+    this.videoElement = null;
+    this.currentSubtitleTrackIndex = -1;
+    this.file = {
+      name: file.name,
+      file,
+      url: URL.createObjectURL(file),
+      externalSubtitles: []
+    };
+    this.processExternalSubtitles(externalSubtitles);
+  }
+  async processExternalSubtitles(subtitleFiles) {
+    const subtitles = [];
+    for (let i = 0; i < subtitleFiles.length; i++) {
+      const file = subtitleFiles[i];
+      const url = URL.createObjectURL(file);
+      const langMatch = file.name.match(/\.([a-z]{2,3})\.(?:srt|vtt)$/i);
+      const lang = langMatch ? langMatch[1] : "unknown";
+      subtitles.push({
+        id: String(i),
+        name: `${lang.toUpperCase()} (${file.name})`,
+        lang,
+        type: "external",
+        url
+      });
+    }
+    this.file.externalSubtitles = subtitles;
+  }
+  async initialize(videoElement) {
+    this.videoElement = videoElement;
+    videoElement.src = this.file.url;
+    if (this.file.externalSubtitles) {
+      for (const subtitle of this.file.externalSubtitles) {
+        if (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);
+          videoElement.appendChild(track);
+        }
+      }
+    }
+    return this.file;
+  }
+  getAudioTracks() {
+    return [];
+  }
+  getSubtitles() {
+    return this.file.externalSubtitles || [];
+  }
+  switchAudioTrack(trackId) {
+    return Promise.resolve();
+  }
+  switchSubtitle(trackId) {
+    if (!this.videoElement) return Promise.resolve();
+    const tracks = this.videoElement.textTracks;
+    for (let i = 0; i < tracks.length; i++) {
+      tracks[i].mode = "disabled";
+    }
+    if (trackId === "-1") {
+      this.currentSubtitleTrackIndex = -1;
+      return Promise.resolve();
+    }
+    const trackElements = this.videoElement.querySelectorAll("track");
+    for (let i = 0; i < trackElements.length; i++) {
+      const trackElement = trackElements[i];
+      if (trackElement.getAttribute("data-id") === trackId) {
+        const textTrack = tracks[i];
+        if (textTrack) {
+          if (trackElement.readyState === 2) {
+            textTrack.mode = "hidden";
+            this.currentSubtitleTrackIndex = i;
+          } else {
+            const onLoad = () => {
+              textTrack.mode = "hidden";
+              this.currentSubtitleTrackIndex = i;
+              trackElement.removeEventListener("load", onLoad);
+            };
+            trackElement.addEventListener("load", onLoad);
+            textTrack.mode = "hidden";
+          }
+        }
+        break;
+      }
+    }
+    return Promise.resolve();
+  }
+  destroy() {
+    if (this.file.url.startsWith("blob:")) {
+      URL.revokeObjectURL(this.file.url);
+    }
+    if (this.file.externalSubtitles) {
+      for (const subtitle of this.file.externalSubtitles) {
+        if (subtitle.url?.startsWith("blob:")) {
+          URL.revokeObjectURL(subtitle.url);
+        }
+      }
+    }
+  }
+  static isCompatible(file) {
+    const fileName = file.name.toLowerCase();
+    const supportedExtensions = [".mp4", ".webm", ".ogv", ".avi", ".mov", ".wmv", ".flv"];
+    return supportedExtensions.some((ext) => fileName.endsWith(ext)) || file.type.startsWith("video/");
+  }
+};
+
+// 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/parsers/chapter-parser.ts
+function parseChaptersFromFFmpegLog(log, totalDuration) {
+  try {
+    const chapters = [];
+    const chapterRegex = /Chapter #\d+:\d+:\s+start\s+([\d.]+),\s+end\s+([\d.]+)/gi;
+    const titleRegex = /\btitle\s*:\s*(.+)/i;
+    let match;
+    const rawChapters = [];
+    while ((match = chapterRegex.exec(log)) !== null) {
+      const start = parseFloat(match[1]);
+      const end = parseFloat(match[2]);
+      const afterMatch = log.slice(match.index + match[0].length, match.index + match[0].length + 200);
+      rawChapters.push({ start, end, titleLine: afterMatch });
+    }
+    if (rawChapters.length === 0) return [];
+    for (let i = 0; i < rawChapters.length; i++) {
+      const { start, end, titleLine } = rawChapters[i];
+      const titleMatch = titleRegex.exec(titleLine);
+      const title = titleMatch ? titleMatch[1].trim() : `Chapter ${i + 1}`;
+      const isLast = i === rawChapters.length - 1;
+      const endTime = isLast ? totalDuration : end;
+      chapters.push({
+        index: i,
+        title,
+        startTime: start,
+        endTime
+      });
+    }
+    return chapters;
+  } catch {
+    return [];
+  }
+}
+function parseChaptersFromVtt(vttText) {
+  try {
+    if (!vttText || vttText.trim() === "") return [];
+    const chapters = [];
+    const blocks = vttText.split(/\n\s*\n/);
+    for (const block of blocks) {
+      const lines = block.trim().split("\n").map((l) => l.trim());
+      if (lines.length < 2) continue;
+      if (lines[0].startsWith("WEBVTT")) continue;
+      const tsIndex = lines.findIndex((l) => l.includes("-->"));
+      if (tsIndex === -1) continue;
+      const titleLine = tsIndex > 0 ? lines[tsIndex - 1] : "";
+      const title = titleLine || `Chapter ${chapters.length + 1}`;
+      const tsLine = lines[tsIndex];
+      const tsMatch = tsLine.match(
+        /^([\d:.,]+)\s*-->\s*([\d:.,]+)/
+      );
+      if (!tsMatch) continue;
+      const startTime = parseVttTimestamp(tsMatch[1]);
+      const endTime = parseVttTimestamp(tsMatch[2]);
+      if (isNaN(startTime) || isNaN(endTime)) continue;
+      chapters.push({
+        index: chapters.length,
+        title,
+        startTime,
+        endTime
+      });
+    }
+    return chapters;
+  } catch {
+    return [];
+  }
+}
+function parseVttTimestamp(ts) {
+  const normalized = ts.replace(",", ".");
+  const parts = normalized.split(":").map(Number);
+  if (parts.length === 3) {
+    return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  } else if (parts.length === 2) {
+    return parts[0] * 60 + parts[1];
+  } else if (parts.length === 1) {
+    return parts[0];
+  }
+  return NaN;
+}
+
+// src/players/mkv-player.ts
+async function canPlayNatively(objectUrl, timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    const video = document.createElement("video");
+    const cleanup = (result) => {
+      clearTimeout(timer);
+      video.removeAttribute("src");
+      video.load();
+      resolve(result);
+    };
+    const timer = setTimeout(() => cleanup(false), timeoutMs);
+    video.oncanplay = () => cleanup(true);
+    video.onerror = () => cleanup(false);
+    video.preload = "metadata";
+    video.src = objectUrl;
+    video.load();
+  });
+}
+var CancellationError = class extends Error {
+  constructor() {
+    super("MKVPlayer: operation cancelled");
+    this.name = "CancellationError";
+  }
+};
+function parseStreamInfo(logs) {
+  const videoTracks = [];
+  const audioTracks = [];
+  const subtitleTracks = [];
+  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 });
+    }
+  }
+  return { videoTracks, audioTracks, subtitleTracks };
+}
+var _MKVPlayer = class _MKVPlayer {
+  constructor(file, onProgress) {
+    this.videoElement = null;
+    this.objectUrl = null;
+    this._cancelled = false;
+    // Maps subtitle track ID → ffmpeg subtitle stream index
+    this.subtitleTrackMap = /* @__PURE__ */ new Map();
+    // Maps subtitle track ID → blob URL for cleanup
+    this.subtitleBlobUrls = /* @__PURE__ */ new Map();
+    // Parsed chapter data
+    this.chapters = [];
+    // Maps audioTrackIndex → blob URL of the remuxed video
+    this.remuxCache = /* @__PURE__ */ new Map();
+    // Worker management
+    this.worker = null;
+    this.pendingOperations = /* @__PURE__ */ new Map();
+    /**
+     * Resolves when track metadata (audio + subtitle) is fully populated.
+     * On the FFmpeg path this resolves after initialize() itself. On the native
+     * path the probe runs in the background so initialize() returns first —
+     * callers that need the real track list should await this promise.
+     */
+    this.tracksReady = Promise.resolve();
+    this.file = file;
+    this.onProgress = onProgress;
+    this.playerFile = {
+      name: file.name,
+      file,
+      audioTracks: [],
+      subtitleTracks: [],
+      activeAudioTrack: "0",
+      activeSubtitleTrack: "-1"
+    };
+  }
+  getWorker() {
+    if (!this.worker) {
+      let w;
+      if (_MKVPlayer._workerFactory) {
+        w = _MKVPlayer._workerFactory();
+      } else {
+        w = new Worker(new URL("../workers/ffmpeg-worker.ts", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+      }
+      w.onmessage = (event) => {
+        this._handleWorkerMessage(event.data);
+      };
+      w.onerror = (error) => {
+        console.error("FFmpeg worker error:", error);
+        for (const { reject } of this.pendingOperations.values()) {
+          reject(error);
+        }
+        this.pendingOperations.clear();
+        if (this.worker === w) {
+          this.worker = null;
+        }
+        w.terminate();
+      };
+      this.worker = w;
+    }
+    return this.worker;
+  }
+  _handleWorkerMessage(msg) {
+    const { id, type } = msg;
+    if (type === "PROGRESS") {
+      this.onProgress?.(msg.progress);
+      return;
+    }
+    const pending = this.pendingOperations.get(id);
+    if (!pending) return;
+    this.pendingOperations.delete(id);
+    if (type === "ERROR") {
+      pending.reject(new Error(msg.error));
+    } else {
+      pending.resolve(msg);
+    }
+  }
+  sendToWorker(message) {
+    return new Promise((resolve, reject) => {
+      this.pendingOperations.set(message.id, {
+        resolve,
+        reject
+      });
+      this.getWorker().postMessage(message);
+    });
+  }
+  async initialize(videoElement) {
+    this.videoElement = videoElement;
+    this._cancelled = false;
+    try {
+      const probeUrl = URL.createObjectURL(this.file);
+      const nativeOk = await _MKVPlayer._canPlayNatively(probeUrl);
+      if (this._cancelled) {
+        URL.revokeObjectURL(probeUrl);
+        throw new CancellationError();
+      }
+      if (nativeOk) {
+        this.objectUrl = probeUrl;
+        this.playerFile.videoUrl = probeUrl;
+        this.playerFile.audioTracks = [{ id: "0", name: "Default Audio", lang: "unknown" }];
+        videoElement.src = probeUrl;
+        this.onProgress?.(1);
+        this.tracksReady = this._probeForTracks().catch(() => {
+          this.playerFile.audioTracks = [{ id: "0", name: "Default Audio", lang: "unknown" }];
+        });
+        return this.playerFile;
+      }
+      URL.revokeObjectURL(probeUrl);
+      const opId = crypto.randomUUID();
+      const result = await this.sendToWorker({
+        id: opId,
+        type: "REMUX",
+        payload: {
+          file: this.file,
+          fileName: this.file.name,
+          audioTrackIndex: 0
+        }
+      });
+      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"
+        };
+      });
+      const blob = new Blob([result.data], { type: "video/mp4" });
+      const url = URL.createObjectURL(blob);
+      this.remuxCache.set(0, url);
+      this.objectUrl = url;
+      this.playerFile.videoUrl = url;
+      videoElement.src = url;
+      this.onProgress?.(1);
+    } catch (error) {
+      if (error instanceof CancellationError) {
+        throw error;
+      }
+      console.error("MKVPlayer: Worker failed, falling back to native playback", error);
+      const url = URL.createObjectURL(this.file);
+      if (this.objectUrl) URL.revokeObjectURL(this.objectUrl);
+      this.objectUrl = url;
+      this.playerFile.videoUrl = url;
+      this.playerFile.audioTracks = [{ id: "0", name: "Default Audio", lang: "unknown" }];
+      videoElement.src = url;
+    }
+    return this.playerFile;
+  }
+  async _probeForTracks() {
+    const probeOpId = crypto.randomUUID();
+    const probeResult = await this.sendToWorker({
+      id: probeOpId,
+      type: "PROBE",
+      payload: { file: this.file, fileName: this.file.name }
+    });
+    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"
+      };
+    });
+  }
+  async _remux(audioTrackIndex) {
+    const cached = this.remuxCache.get(audioTrackIndex);
+    if (cached) return cached;
+    const opId = crypto.randomUUID();
+    const result = await this.sendToWorker({
+      id: opId,
+      type: "REMUX",
+      payload: {
+        file: this.file,
+        fileName: this.file.name,
+        audioTrackIndex
+      }
+    });
+    const blob = new Blob([result.data], { type: "video/mp4" });
+    const url = URL.createObjectURL(blob);
+    this.remuxCache.set(audioTrackIndex, url);
+    this.objectUrl = url;
+    return url;
+  }
+  async _extractSubtitle(trackIndex) {
+    const opId = crypto.randomUUID();
+    const result = await this.sendToWorker({
+      id: opId,
+      type: "EXTRACT_SUBTITLE",
+      payload: {
+        file: this.file,
+        fileName: this.file.name,
+        trackIndex
+      }
+    });
+    return result.srtText;
+  }
+  getAudioTracks() {
+    return this.playerFile.audioTracks;
+  }
+  getSubtitles() {
+    return this.playerFile.subtitleTracks;
+  }
+  getChapters() {
+    return this.chapters;
+  }
+  async switchAudioTrack(trackId) {
+    if (!this.videoElement) return;
+    const trackIndex = parseInt(trackId, 10);
+    if (isNaN(trackIndex)) return;
+    this.playerFile.activeAudioTrack = trackId;
+    const currentTime = this.videoElement.currentTime;
+    const wasPlaying = !this.videoElement.paused;
+    const url = await this._remux(trackIndex);
+    this.playerFile.videoUrl = url;
+    this.videoElement.src = url;
+    this.videoElement.addEventListener(
+      "loadedmetadata",
+      () => {
+        this.videoElement.currentTime = currentTime;
+        if (wasPlaying) {
+          this.videoElement.play().catch(console.error);
+        }
+      },
+      { once: true }
+    );
+  }
+  async switchSubtitle(trackId) {
+    this.playerFile.activeSubtitleTrack = trackId;
+    if (trackId === "-1" || !this.videoElement) return;
+    const trackIndex = this.subtitleTrackMap.get(trackId);
+    if (trackIndex === void 0) return;
+    try {
+      const existing = this.videoElement.querySelector(
+        `track[data-mkv-id="${trackId}"]`
+      );
+      if (existing) {
+        existing.track.mode = "hidden";
+        return;
+      }
+      const srtContent = await this._extractSubtitle(trackIndex);
+      const vttContent = await SubtitleConverter.convertSrtToVtt(srtContent);
+      const blob = new Blob([vttContent], { type: "text/vtt" });
+      const url = URL.createObjectURL(blob);
+      this.subtitleBlobUrls.set(trackId, url);
+      const track = document.createElement("track");
+      track.kind = "subtitles";
+      track.src = url;
+      track.setAttribute("data-id", trackId);
+      track.setAttribute("data-mkv-id", trackId);
+      this.videoElement.appendChild(track);
+      track.track.mode = "hidden";
+    } catch (error) {
+      console.error("MKVPlayer: Failed to extract subtitle", error);
+    }
+  }
+  getActiveAudioTrack() {
+    return this.playerFile.activeAudioTrack;
+  }
+  getActiveSubtitleTrack() {
+    return this.playerFile.activeSubtitleTrack;
+  }
+  cancel() {
+    this._cancelled = true;
+    if (!this.worker) return;
+    this.worker.terminate();
+    this.worker = null;
+    for (const { reject } of this.pendingOperations.values()) {
+      reject(new CancellationError());
+    }
+    this.pendingOperations.clear();
+  }
+  destroy() {
+    for (const { reject } of this.pendingOperations.values()) {
+      reject(new Error("MKVPlayer destroyed"));
+    }
+    this.pendingOperations.clear();
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    for (const url of this.remuxCache.values()) {
+      URL.revokeObjectURL(url);
+    }
+    this.remuxCache.clear();
+    if (this.objectUrl) {
+      URL.revokeObjectURL(this.objectUrl);
+      this.objectUrl = null;
+    }
+    for (const url of this.subtitleBlobUrls.values()) {
+      URL.revokeObjectURL(url);
+    }
+    this.subtitleBlobUrls.clear();
+  }
+  static isCompatible(file) {
+    return file.name.toLowerCase().endsWith(".mkv");
+  }
+};
+/**
+ * Overrideable in tests to avoid real browser playback probes.
+ * @internal
+ */
+_MKVPlayer._canPlayNatively = canPlayNatively;
+/**
+ * Overrideable factory for creating the FFmpeg worker. Tests override this
+ * to avoid `import.meta.url` (not available in CJS Jest).
+ * @internal
+ */
+_MKVPlayer._workerFactory = null;
+var MKVPlayer = _MKVPlayer;
+
+// src/video-processor.ts
+var SimplePlayerAdapter = class {
+  constructor(file, externalSubtitles = []) {
+    this.player = new SimplePlayer(file, externalSubtitles);
+  }
+  async initialize(videoElement) {
+    return await this.player.initialize(videoElement);
+  }
+  getAudioTracks() {
+    return this.player.getAudioTracks();
+  }
+  getSubtitles() {
+    return this.player.getSubtitles();
+  }
+  async switchAudioTrack(trackId) {
+    return await this.player.switchAudioTrack(trackId);
+  }
+  async switchSubtitle(trackId) {
+    return await this.player.switchSubtitle(trackId);
+  }
+  destroy() {
+    this.player.destroy();
+  }
+};
+var MKVPlayerAdapter = class {
+  constructor(file, onProgress) {
+    this.player = new MKVPlayer(file, onProgress);
+  }
+  async initialize(videoElement) {
+    return await this.player.initialize(videoElement);
+  }
+  getAudioTracks() {
+    return this.player.getAudioTracks();
+  }
+  getSubtitles() {
+    return this.player.getSubtitles();
+  }
+  getChapters() {
+    return this.player.getChapters();
+  }
+  async switchAudioTrack(trackId) {
+    return await this.player.switchAudioTrack(trackId);
+  }
+  async switchSubtitle(trackId) {
+    return await this.player.switchSubtitle(trackId);
+  }
+  destroy() {
+    this.player.destroy();
+  }
+  cancel() {
+    this.player.cancel();
+  }
+  get tracksReady() {
+    return this.player.tracksReady;
+  }
+};
+function createVideoPlayer(file, externalSubtitles = [], onProgress) {
+  if (MKVPlayer.isCompatible(file)) {
+    return new MKVPlayerAdapter(file, onProgress);
+  } else if (SimplePlayer.isCompatible(file)) {
+    return new SimplePlayerAdapter(file, externalSubtitles);
+  } else {
+    return new SimplePlayerAdapter(file, externalSubtitles);
+  }
+}
+
+// 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}`;
+    }
+  );
+}
+async function createOffsetVttUrl(originalUrl, offsetSeconds) {
+  const response = await fetch(originalUrl);
+  const text = await response.text();
+  const shifted = applyOffsetToVtt(text, offsetSeconds);
+  const blob = new Blob([shifted], { type: "text/vtt" });
+  return URL.createObjectURL(blob);
+}
+
+// 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;
+  }
+};
+function assColorToCss(color, alphaHex) {
+  const hex = color.replace("&H", "").padStart(8, "0");
+  const a = parseInt(hex.slice(0, 2), 16);
+  const b = parseInt(hex.slice(2, 4), 16);
+  const g = parseInt(hex.slice(4, 6), 16);
+  const r = parseInt(hex.slice(6, 8), 16);
+  const alpha = 1 - a / 255;
+  return `rgba(${r},${g},${b},${alpha.toFixed(3)})`;
+}
+function alignmentToPosition(alignment, canvasWidth, canvasHeight, marginL, marginR, marginV) {
+  const col = (alignment - 1) % 3;
+  const row = Math.floor((alignment - 1) / 3);
+  let x;
+  const textAlign = col === 0 ? "left" : col === 1 ? "center" : "right";
+  if (col === 0) x = marginL;
+  else if (col === 1) x = canvasWidth / 2;
+  else x = canvasWidth - marginR;
+  let y;
+  const textBaseline = row === 0 ? "bottom" : row === 1 ? "middle" : "top";
+  if (row === 0) y = canvasHeight - marginV;
+  else if (row === 1) y = canvasHeight / 2;
+  else y = marginV;
+  return { x, y, textAlign, textBaseline };
+}
+var ASSRenderer = class {
+  constructor(canvas) {
+    this.compiled = null;
+    this.animFrame = null;
+    this.canvas = canvas;
+    this.ctx = canvas.getContext("2d");
+  }
+  load(assText) {
+    try {
+      this.compiled = assCompiler.compile(assText, {});
+    } catch (err) {
+      console.error("ASSRenderer: failed to compile ASS file", err);
+      this.compiled = null;
+    }
+  }
+  start(videoEl) {
+    this.stop();
+    const loop = () => {
+      this.syncCanvasSize(videoEl);
+      this.renderAt(videoEl.currentTime);
+      this.animFrame = requestAnimationFrame(loop);
+    };
+    this.animFrame = requestAnimationFrame(loop);
+  }
+  stop() {
+    if (this.animFrame !== null) {
+      cancelAnimationFrame(this.animFrame);
+      this.animFrame = null;
+    }
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+  renderAt(currentTimeSec) {
+    if (!this.compiled) return;
+    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    const active = this.compiled.dialogues.filter(
+      (d) => d.start <= currentTimeSec && d.end >= currentTimeSec
+    );
+    for (const dialogue of active) {
+      this.drawDialogue(dialogue);
+    }
+  }
+  syncCanvasSize(videoEl) {
+    const rect = videoEl.getBoundingClientRect();
+    if (this.canvas.width !== rect.width || this.canvas.height !== rect.height) {
+      this.canvas.width = rect.width;
+      this.canvas.height = rect.height;
+    }
+  }
+  drawDialogue(dialogue) {
+    if (!this.compiled) return;
+    const styleName = dialogue.style;
+    const styleObj = this.compiled.styles[styleName] ?? this.compiled.styles["Default"];
+    if (!styleObj) return;
+    const style = styleObj.style;
+    const tag = styleObj.tag;
+    const scaleX = this.compiled.width > 0 ? this.canvas.width / this.compiled.width : 1;
+    const scaleY = this.compiled.height > 0 ? this.canvas.height / this.compiled.height : 1;
+    const scale = Math.min(scaleX, scaleY);
+    const fontSize = Math.round(style.Fontsize * scale);
+    const fontWeight = style.Bold === -1 ? "bold" : "normal";
+    const fontStyle = style.Italic === -1 ? "italic" : "normal";
+    this.ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px "${style.Fontname}", sans-serif`;
+    const primaryColor = assColorToCss(style.PrimaryColour, tag.a1 ?? "00");
+    const outlineColor = assColorToCss(style.OutlineColour, tag.a3 ?? "00");
+    const outlineWidth = style.Outline * scale;
+    const text = dialogue.slices.flatMap((slice) => slice.fragments.map((f) => f.text)).join("");
+    if (!text.trim()) return;
+    let x;
+    let y;
+    let textAlign;
+    let textBaseline;
+    if (dialogue.pos) {
+      x = dialogue.pos.x * scaleX;
+      y = dialogue.pos.y * scaleY;
+      textAlign = "left";
+      textBaseline = "top";
+    } else {
+      const marginL = style.MarginL * scaleX;
+      const marginR = style.MarginR * scaleX;
+      const marginV = style.MarginV * scaleY;
+      ({ x, y, textAlign, textBaseline } = alignmentToPosition(
+        dialogue.alignment,
+        this.canvas.width,
+        this.canvas.height,
+        marginL,
+        marginR,
+        marginV
+      ));
+    }
+    this.ctx.textAlign = textAlign;
+    this.ctx.textBaseline = textBaseline;
+    const lines = text.split(/\\[Nn]|\n/);
+    const lineHeight = fontSize * 1.2;
+    const totalHeight = lines.length * lineHeight;
+    let startY = y;
+    if (textBaseline === "bottom") {
+      startY = y - (lines.length - 1) * lineHeight;
+    } else if (textBaseline === "middle") {
+      startY = y - totalHeight / 2 + lineHeight / 2;
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const lineY = startY + i * lineHeight;
+      if (outlineWidth > 0) {
+        this.ctx.strokeStyle = outlineColor;
+        this.ctx.lineWidth = outlineWidth * 2;
+        this.ctx.lineJoin = "round";
+        this.ctx.strokeText(lines[i], x, lineY);
+      }
+      this.ctx.fillStyle = primaryColor;
+      this.ctx.fillText(lines[i], x, lineY);
+    }
+  }
+};
+
+// src/parsers/m3u-parser.ts
+function exportPlaylist(items) {
+  const lines = ["#EXTM3U"];
+  for (const item of items) {
+    lines.push(`#EXTINF:-1,${item.name}`);
+    lines.push(item.type === "stream" ? item.url : item.name);
+  }
+  const blob = new Blob([lines.join("\n")], {
+    type: "application/vnd.apple.mpegurl"
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = "lightbird-playlist.m3u8";
+  a.click();
+  URL.revokeObjectURL(url);
+}
+function parseM3U8(text) {
+  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  const items = [];
+  let nextName = null;
+  for (const line of lines) {
+    if (line.startsWith("#EXTINF:")) {
+      nextName = line.split(",").slice(1).join(",").trim() || null;
+    } else if (!line.startsWith("#")) {
+      const isStream = line.startsWith("http");
+      items.push({
+        name: nextName ?? line,
+        url: isStream ? line : "",
+        type: isStream ? "stream" : "video"
+      });
+      nextName = null;
+    }
+  }
+  return items;
+}
+
+// src/utils/media-error.ts
+var MEDIA_ERR_ABORTED = 1;
+var MEDIA_ERR_NETWORK = 2;
+var MEDIA_ERR_DECODE = 3;
+var MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+function parseMediaError(error) {
+  if (!error) {
+    return { type: "unknown", message: "An unknown error occurred.", recoverable: true, retryable: true };
+  }
+  switch (error.code) {
+    case MEDIA_ERR_ABORTED:
+      return { type: "aborted", message: "Playback was aborted.", recoverable: true, retryable: false };
+    case MEDIA_ERR_NETWORK:
+      return { type: "network", message: "A network error interrupted loading. Check your connection.", recoverable: true, retryable: true };
+    case MEDIA_ERR_DECODE:
+      return { type: "decode", message: "The video could not be decoded. It may be corrupted.", recoverable: false, retryable: false };
+    case MEDIA_ERR_SRC_NOT_SUPPORTED:
+      return { type: "unsupported", message: "This format is not supported by your browser.", recoverable: false, retryable: false };
+    default:
+      return { type: "unknown", message: error.message || "An unexpected error occurred.", recoverable: true, retryable: true };
+  }
+}
+function validateFile(file) {
+  const MAX_SIZE_BYTES = 10 * 1024 * 1024 * 1024;
+  const SUPPORTED = ["mp4", "webm", "mkv", "mov", "avi", "wmv", "flv", "m4v", "ogv"];
+  if (file.size > MAX_SIZE_BYTES) {
+    return {
+      valid: false,
+      reason: `File is too large (${(file.size / 1e9).toFixed(1)} GB). Maximum is 10 GB.`
+    };
+  }
+  const ext = file.name.split(".").pop()?.toLowerCase();
+  if (!ext || !SUPPORTED.includes(ext)) {
+    return { valid: false, reason: `"${ext}" is not a supported video format.` };
+  }
+  return { valid: true };
+}
+
+// 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/utils/video-thumbnail.ts
+async function captureVideoThumbnail(videoEl, atSeconds = 5) {
+  return new Promise((resolve) => {
+    const savedTime = videoEl.currentTime;
+    const canvas = document.createElement("canvas");
+    canvas.width = 320;
+    canvas.height = 180;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      resolve(null);
+      return;
+    }
+    const cleanup = () => {
+      videoEl.removeEventListener("seeked", onSeeked);
+      videoEl.removeEventListener("error", onError);
+    };
+    const onSeeked = () => {
+      try {
+        ctx.drawImage(videoEl, 0, 0, 320, 180);
+        resolve(canvas.toDataURL("image/jpeg", 0.7));
+      } catch {
+        resolve(null);
+      } finally {
+        videoEl.currentTime = savedTime;
+        cleanup();
+      }
+    };
+    const onError = () => {
+      cleanup();
+      resolve(null);
+    };
+    videoEl.addEventListener("seeked", onSeeked, { once: true });
+    videoEl.addEventListener("error", onError, { once: true });
+    try {
+      videoEl.currentTime = Math.min(atSeconds, videoEl.duration || 0);
+    } catch {
+      cleanup();
+      resolve(null);
+    }
+  });
+}
+
+// src/utils/keyboard-shortcuts.ts
+var DEFAULT_SHORTCUTS = [
+  { action: "play-pause", label: "Play / Pause", defaultKey: " ", key: " " },
+  { action: "seek-forward-5", label: "Seek Forward 5s", defaultKey: "ArrowRight", key: "ArrowRight" },
+  { action: "seek-backward-5", label: "Seek Backward 5s", defaultKey: "ArrowLeft", key: "ArrowLeft" },
+  { action: "seek-forward-30", label: "Seek Forward 30s", defaultKey: "ArrowRight", key: "ArrowRight", modifiers: { shift: true } },
+  { action: "seek-backward-30", label: "Seek Backward 30s", defaultKey: "ArrowLeft", key: "ArrowLeft", modifiers: { shift: true } },
+  { action: "volume-up", label: "Volume Up", defaultKey: "ArrowUp", key: "ArrowUp" },
+  { action: "volume-down", label: "Volume Down", defaultKey: "ArrowDown", key: "ArrowDown" },
+  { action: "mute", label: "Toggle Mute", defaultKey: "m", key: "m" },
+  { action: "fullscreen", label: "Toggle Fullscreen", defaultKey: "f", key: "f" },
+  { action: "next-item", label: "Next in Playlist", defaultKey: "n", key: "n" },
+  { action: "prev-item", label: "Previous in Playlist", defaultKey: "p", key: "p" },
+  { action: "screenshot", label: "Screenshot", defaultKey: "s", key: "s", modifiers: { ctrl: true } },
+  { action: "show-shortcuts", label: "Show Shortcuts Help", defaultKey: "?", key: "?" },
+  { action: "next-chapter", label: "Next Chapter", defaultKey: "]", key: "]" },
+  { action: "prev-chapter", label: "Previous Chapter", defaultKey: "[", key: "[" }
+];
+var STORAGE_KEY = "lightbird-shortcuts";
+function loadShortcuts() {
+  try {
+    const saved = localStorage.getItem(STORAGE_KEY);
+    if (!saved) return DEFAULT_SHORTCUTS;
+    const overrides = JSON.parse(saved);
+    return DEFAULT_SHORTCUTS.map((s) => ({
+      ...s,
+      key: overrides[s.action] ?? s.defaultKey
+    }));
+  } catch {
+    return DEFAULT_SHORTCUTS;
+  }
+}
+function saveShortcuts(bindings) {
+  const overrides = {};
+  for (const b of bindings) {
+    if (b.key !== b.defaultKey) overrides[b.action] = b.key;
+  }
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(overrides));
+}
+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;
+}
+function formatShortcutKey(binding) {
+  const mods = [];
+  if (binding.modifiers?.ctrl) mods.push("Ctrl");
+  if (binding.modifiers?.shift) mods.push("Shift");
+  if (binding.modifiers?.alt) mods.push("Alt");
+  const key = binding.key === " " ? "Space" : binding.key;
+  return [...mods, key].join(" + ");
+}
+
+// src/utils/progress-estimator.ts
+var ProgressEstimator = class {
+  constructor(fileSizeBytes) {
+    this.startTime = null;
+    // set lazily on first real progress
+    this.lastProgress = 0;
+    this.fileSizeBytes = fileSizeBytes;
+  }
+  update(progress) {
+    if (!Number.isFinite(progress)) return;
+    progress = Math.min(1, Math.max(0, progress));
+    if (progress > 0 && this.startTime === null) {
+      this.startTime = Date.now();
+    }
+    this.lastProgress = progress;
+  }
+  getEstimate() {
+    if (this.startTime === null || this.lastProgress <= 0) {
+      return { speedMBps: 0, etaSeconds: null };
+    }
+    const elapsedMs = Date.now() - this.startTime;
+    if (elapsedMs < 500) {
+      return { speedMBps: 0, etaSeconds: null };
+    }
+    const elapsedSeconds = elapsedMs / 1e3;
+    const bytesProcessed = this.fileSizeBytes * this.lastProgress;
+    const speedMBps = bytesProcessed / elapsedSeconds / (1024 * 1024);
+    const bytesRemaining = this.fileSizeBytes * (1 - this.lastProgress);
+    const etaSeconds = speedMBps > 0 ? bytesRemaining / (speedMBps * 1024 * 1024) : null;
+    return {
+      speedMBps: Math.round(speedMBps * 10) / 10,
+      // 1 decimal place
+      etaSeconds: etaSeconds !== null ? Math.round(etaSeconds) : null
+    };
+  }
+  // No reset() method — create a new instance per file load instead.
+};
+var instance = null;
+var loading = null;
+var defaultCDN = "https://unpkg.com/@ffmpeg/core@0.12.10/dist/umd";
+async function getFFmpeg() {
+  if (instance) return instance;
+  if (loading) return loading;
+  loading = (async () => {
+    const ffmpeg$1 = new ffmpeg.FFmpeg();
+    const baseURL = getConfig().ffmpegCDN || defaultCDN;
+    await ffmpeg$1.load({
+      coreURL: await util.toBlobURL(`${baseURL}/ffmpeg-core.js`, "text/javascript"),
+      wasmURL: await util.toBlobURL(`${baseURL}/ffmpeg-core.wasm`, "application/wasm")
+    });
+    instance = ffmpeg$1;
+    return ffmpeg$1;
+  })();
+  return loading;
+}
+function resetFFmpeg() {
+  instance = null;
+  loading = null;
+}
+
+exports.ASSRenderer = ASSRenderer;
+exports.CancellationError = CancellationError;
+exports.DEFAULT_SHORTCUTS = DEFAULT_SHORTCUTS;
+exports.MKVPlayer = MKVPlayer;
+exports.ProgressEstimator = ProgressEstimator;
+exports.SimplePlayer = SimplePlayer;
+exports.SubtitleConverter = SubtitleConverter;
+exports.UniversalSubtitleManager = UniversalSubtitleManager;
+exports.applyOffsetToVtt = applyOffsetToVtt;
+exports.captureVideoThumbnail = captureVideoThumbnail;
+exports.configureLightBird = configureLightBird;
+exports.createOffsetVttUrl = createOffsetVttUrl;
+exports.createVideoPlayer = createVideoPlayer;
+exports.exportPlaylist = exportPlaylist;
+exports.extractNativeMetadata = extractNativeMetadata;
+exports.formatShortcutKey = formatShortcutKey;
+exports.getFFmpeg = getFFmpeg;
+exports.isInteractiveElement = isInteractiveElement;
+exports.loadShortcuts = loadShortcuts;
+exports.matchesShortcut = matchesShortcut;
+exports.parseChaptersFromFFmpegLog = parseChaptersFromFFmpegLog;
+exports.parseChaptersFromVtt = parseChaptersFromVtt;
+exports.parseM3U8 = parseM3U8;
+exports.parseMediaError = parseMediaError;
+exports.resetFFmpeg = resetFFmpeg;
+exports.saveShortcuts = saveShortcuts;
+exports.validateFile = validateFile;