avbridge 1.0.0

package/dist/chunk-J5MCMN3S.js

@@ -0,0 +1,27 @@
+// src/strategies/fallback/variant-routing.ts
+var LEGACY_CONTAINERS = /* @__PURE__ */ new Set(["avi", "asf", "flv"]);
+var LEGACY_VIDEO_CODECS = /* @__PURE__ */ new Set([
+  "wmv3",
+  "vc1",
+  "mpeg4",
+  // MPEG-4 Part 2 / DivX / Xvid
+  "rv40",
+  "mpeg2",
+  "mpeg1",
+  "theora"
+]);
+var LEGACY_AUDIO_CODECS = /* @__PURE__ */ new Set(["wmav2", "wmapro", "ac3", "eac3"]);
+function pickLibavVariant(ctx) {
+  if (LEGACY_CONTAINERS.has(ctx.container)) return "avbridge";
+  for (const v of ctx.videoTracks) {
+    if (LEGACY_VIDEO_CODECS.has(v.codec)) return "avbridge";
+  }
+  for (const a of ctx.audioTracks) {
+    if (LEGACY_AUDIO_CODECS.has(a.codec)) return "avbridge";
+  }
+  return "webcodecs";
+}
+
+export { pickLibavVariant };
+//# sourceMappingURL=chunk-J5MCMN3S.js.map
+//# sourceMappingURL=chunk-J5MCMN3S.js.map

package/dist/chunk-J5MCMN3S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategies/fallback/variant-routing.ts"],"names":[],"mappings":";AAmBA,IAAM,oCAAoB,IAAI,GAAA,CAAI,CAAC,KAAA,EAAO,KAAA,EAAO,KAAK,CAAC,CAAA;AAEvD,IAAM,mBAAA,uBAA0B,GAAA,CAAgB;AAAA,EAC9C,MAAA;AAAA,EACA,KAAA;AAAA,EACA,OAAA;AAAA;AAAA,EACA,MAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA;AACF,CAAC,CAAA;AAED,IAAM,mBAAA,uBAA0B,GAAA,CAAgB,CAAC,SAAS,QAAA,EAAU,KAAA,EAAO,MAAM,CAAC,CAAA;AAE3E,SAAS,iBAAiB,GAAA,EAAiC;AAChE,EAAA,IAAI,iBAAA,CAAkB,GAAA,CAAI,GAAA,CAAI,SAAS,GAAG,OAAO,UAAA;AACjD,EAAA,KAAA,MAAW,CAAA,IAAK,IAAI,WAAA,EAAa;AAC/B,IAAA,IAAI,mBAAA,CAAoB,GAAA,CAAI,CAAA,CAAE,KAAK,GAAG,OAAO,UAAA;AAAA,EAC/C;AACA,EAAA,KAAA,MAAW,CAAA,IAAK,IAAI,WAAA,EAAa;AAC/B,IAAA,IAAI,mBAAA,CAAoB,GAAA,CAAI,CAAA,CAAE,KAAK,GAAG,OAAO,UAAA;AAAA,EAC/C;AACA,EAAA,OAAO,WAAA;AACT","file":"chunk-J5MCMN3S.js","sourcesContent":["import type { MediaContext, AudioCodec, VideoCodec } from \"../../types.js\";\nimport type { LibavVariant } from \"./libav-loader.js\";\n\n/**\n * Decide which libav.js variant to load for a given media context.\n *\n * - **webcodecs** (~5 MB, npm) — modern formats only, designed for the\n *   WebCodecs bridge. Used when the codec is browser-supported and we just\n *   need libav.js for demuxing or as a parser source.\n *\n * - **avbridge** (custom build, vendor/libav/) — has the AVI/ASF/FLV demuxers\n *   and the legacy decoders (WMV3, MPEG-4 Part 2, VC-1, MS-MPEG4 v1/2/3,\n *   AC-3, WMA*). Required for any of those formats; the npm variants ship\n *   none of them.\n *\n * Rule: pick \"avbridge\" if either the container or any codec is one only the\n * custom build can handle. Otherwise pick \"webcodecs\".\n */\n\nconst LEGACY_CONTAINERS = new Set([\"avi\", \"asf\", \"flv\"]);\n\nconst LEGACY_VIDEO_CODECS = new Set<VideoCodec>([\n  \"wmv3\",\n  \"vc1\",\n  \"mpeg4\", // MPEG-4 Part 2 / DivX / Xvid\n  \"rv40\",\n  \"mpeg2\",\n  \"mpeg1\",\n  \"theora\",\n]);\n\nconst LEGACY_AUDIO_CODECS = new Set<AudioCodec>([\"wmav2\", \"wmapro\", \"ac3\", \"eac3\"]);\n\nexport function pickLibavVariant(ctx: MediaContext): LibavVariant {\n  if (LEGACY_CONTAINERS.has(ctx.container)) return \"avbridge\";\n  for (const v of ctx.videoTracks) {\n    if (LEGACY_VIDEO_CODECS.has(v.codec)) return \"avbridge\";\n  }\n  for (const a of ctx.audioTracks) {\n    if (LEGACY_AUDIO_CODECS.has(a.codec)) return \"avbridge\";\n  }\n  return \"webcodecs\";\n}\n"]}

package/dist/chunk-L4NPOJ36.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+// src/util/libav-http-reader.ts
+var MIN_READ = 256 * 1024;
+var MAX_READ = 1 * 1024 * 1024;
+async function prepareLibavInput(libav, filename, source) {
+  if (source.kind === "url") {
+    const handle = await attachLibavHttpReader(libav, filename, source.url);
+    return {
+      filename,
+      transport: "http-range",
+      size: handle.size,
+      detach: () => handle.detach()
+    };
+  }
+  await libav.mkreadaheadfile(filename, source.blob);
+  return {
+    filename,
+    transport: "blob",
+    size: source.byteLength,
+    detach: async () => {
+      try {
+        await libav.unlinkreadaheadfile(filename);
+      } catch {
+      }
+    }
+  };
+}
+async function attachLibavHttpReader(libav, filename, url, options = {}) {
+  const fetchFn = options.fetchFn ?? fetch;
+  let probeRes;
+  try {
+    probeRes = await fetchFn(url, {
+      ...options.requestInit,
+      headers: {
+        ...options.requestInit?.headers ?? {},
+        Range: "bytes=0-0"
+      }
+    });
+  } catch (err) {
+    throw new Error(
+      `libav HTTP reader: failed to reach ${url}: ${err.message}`
+    );
+  }
+  if (probeRes.status !== 206) {
+    throw new Error(
+      `libav HTTP reader: ${url} does not support HTTP Range requests (server returned ${probeRes.status} for a Range probe; need 206 Partial Content). Remote AVI/ASF/FLV playback requires a server that honors byte-range requests.`
+    );
+  }
+  const contentRange = probeRes.headers.get("content-range") ?? "";
+  const sizeMatch = contentRange.match(/\/(\d+)$/);
+  if (!sizeMatch) {
+    throw new Error(
+      `libav HTTP reader: ${url} returned 206 but no parseable Content-Range header (got: "${contentRange}")`
+    );
+  }
+  const size = parseInt(sizeMatch[1], 10);
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new Error(
+      `libav HTTP reader: ${url} reported invalid file size ${size}`
+    );
+  }
+  try {
+    await probeRes.arrayBuffer();
+  } catch {
+  }
+  await libav.mkblockreaderdev(filename, size);
+  let detached = false;
+  let cached = null;
+  let inflight = null;
+  function clampReadLength(requested) {
+    const doubled = requested * 2;
+    if (doubled < MIN_READ) return MIN_READ;
+    if (doubled > MAX_READ) return MAX_READ;
+    return doubled;
+  }
+  function cacheCovers(pos, length) {
+    if (!cached) return false;
+    return pos >= cached.pos && pos + length <= cached.pos + cached.bytes.byteLength;
+  }
+  function sliceFromCache(pos, length) {
+    if (!cached) throw new Error("sliceFromCache called with no cache");
+    const offset = pos - cached.pos;
+    return cached.bytes.subarray(offset, offset + length);
+  }
+  async function fetchRange(pos, length) {
+    const end = Math.min(pos + length - 1, size - 1);
+    const res = await fetchFn(url, {
+      ...options.requestInit,
+      headers: {
+        ...options.requestInit?.headers ?? {},
+        Range: `bytes=${pos}-${end}`
+      }
+    });
+    if (res.status !== 206 && res.status !== 200) {
+      throw new Error(
+        `libav HTTP reader: Range request bytes=${pos}-${end} returned ${res.status}`
+      );
+    }
+    const buf = new Uint8Array(await res.arrayBuffer());
+    cached = { pos, bytes: buf };
+    return buf;
+  }
+  async function handleRead(name, pos, length) {
+    if (inflight) {
+      try {
+        await inflight;
+      } catch {
+      }
+    }
+    if (detached) return;
+    if (cacheCovers(pos, length)) {
+      const data = sliceFromCache(pos, length);
+      try {
+        await libav.ff_block_reader_dev_send(name, pos, data);
+      } catch {
+      }
+      return;
+    }
+    const fetchLen = clampReadLength(length);
+    const fetched = (async () => {
+      try {
+        const buf = await fetchRange(pos, fetchLen);
+        if (detached) return;
+        const reply = buf.subarray(0, Math.min(length, buf.byteLength));
+        try {
+          await libav.ff_block_reader_dev_send(name, pos, reply);
+        } catch {
+        }
+      } catch (err) {
+        if (detached) return;
+        try {
+          await libav.ff_block_reader_dev_send(name, pos, null, {
+            error: err
+          });
+        } catch {
+        }
+      }
+    })();
+    inflight = fetched;
+    try {
+      await fetched;
+    } finally {
+      if (inflight === fetched) inflight = null;
+    }
+  }
+  const previousCallback = libav.onblockread;
+  libav.onblockread = (name, pos, length) => {
+    if (detached || name !== filename) {
+      previousCallback?.(name, pos, length);
+      return;
+    }
+    void handleRead(name, pos, length);
+  };
+  return {
+    size,
+    transport: "http-range",
+    async detach() {
+      if (detached) return;
+      detached = true;
+      libav.onblockread = previousCallback;
+      if (inflight) {
+        try {
+          await inflight;
+        } catch {
+        }
+      }
+      cached = null;
+      try {
+        await libav.unlinkreadaheadfile(filename);
+      } catch {
+      }
+    }
+  };
+}
+
+exports.attachLibavHttpReader = attachLibavHttpReader;
+exports.prepareLibavInput = prepareLibavInput;
+//# sourceMappingURL=chunk-L4NPOJ36.cjs.map
+//# sourceMappingURL=chunk-L4NPOJ36.cjs.map

package/dist/chunk-L4NPOJ36.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/util/libav-http-reader.ts"],"names":[],"mappings":"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","file":"chunk-L4NPOJ36.cjs","sourcesContent":["/**\n * libav.js HTTP block reader.\n *\n * Wraps `libav.mkblockreaderdev` + `libav.onblockread` +\n * `libav.ff_block_reader_dev_send` so that libav can demux a remote file\n * via HTTP Range requests instead of needing the entire file in memory.\n *\n * Used by the AVI/ASF/FLV probe path and the libav-backed playback /\n * conversion strategies whenever the source is a URL.\n *\n * Design notes:\n *\n * - **Range support detection** is done by issuing a `Range: bytes=0-0`\n *   probe request. We do NOT trust `Accept-Ranges` headers — some servers\n *   support ranges but don't advertise them, others advertise but don't.\n *   The probe request is the canonical signal: a `206 Partial Content`\n *   response means we can stream; anything else fails fast with a clear\n *   error. We never silently fall back to a full download.\n *\n * - **Sequential reads.** libav can issue overlapping `onblockread`\n *   callbacks. The reader serializes them through a single async queue\n *   so a) `ff_block_reader_dev_send` calls are well-ordered and b) we\n *   never have two in-flight fetches for unrelated reads. Throughput\n *   for v1 is \"good enough\"; correctness > parallelism.\n *\n * - **In-flight dedup.** If libav asks for `(pos=1000, len=4096)` twice\n *   in a row before the first request resolves, the second call awaits\n *   the first instead of issuing a duplicate fetch. This handles the\n *   \"demuxer re-reads the same header\" pattern cheaply.\n *\n * - **Read-ahead clamp.** libav's requested length is doubled, then\n *   clamped to `[256 KB, 1 MB]`. Small reads get amortized; pathological\n *   large requests don't OOM us.\n *\n * - **Last-block cache.** Only the most-recent fetched block is kept.\n *   Re-fetches via Range are cheap; an LRU cache is post-1.0.\n *\n * - **Safe detach.** `detach()` clears `libav.onblockread`, sets a\n *   destroyed flag, and ignores any in-flight fetch resolutions so we\n *   never write into a torn-down demuxer.\n */\n\nconst MIN_READ = 256 * 1024;\nconst MAX_READ = 1 * 1024 * 1024;\n\ninterface LibavLike {\n  mkblockreaderdev(name: string, size: number): Promise<void>;\n  unlinkreadaheadfile(name: string): Promise<void>;\n  ff_block_reader_dev_send(\n    name: string,\n    pos: number,\n    data: Uint8Array | null,\n    opts?: { errorCode?: number; error?: unknown },\n  ): Promise<void>;\n  onblockread?: (filename: string, pos: number, length: number) => void;\n}\n\nexport interface LibavHttpReaderHandle {\n  /** Total file size (bytes) reported by the server. */\n  readonly size: number;\n  /** Always `\"http-range\"` for now. Reserved for future transports. */\n  readonly transport: \"http-range\";\n  /** Stop serving reads, clear the libav callback, and ignore late fetches. */\n  detach(): Promise<void>;\n}\n\nexport interface AttachLibavHttpReaderOptions {\n  /** Optional `RequestInit` extras (mode, credentials, headers, etc.). */\n  requestInit?: RequestInit;\n  /** Override fetch (for testing). Defaults to globalThis.fetch. */\n  fetchFn?: typeof fetch;\n}\n\n/**\n * Result of preparing a libav-readable file from a normalized source.\n * Either an in-memory Blob (created via `mkreadaheadfile`) or a streaming\n * HTTP reader (created via `attachLibavHttpReader`). Callers should\n * `await detach()` when done so resources are cleaned up symmetrically.\n */\nexport interface LibavInputHandle {\n  /** The virtual filename libav sees — pass to `ff_init_demuxer_file`. */\n  readonly filename: string;\n  /** \"blob\" for in-memory, \"http-range\" for streaming URL. */\n  readonly transport: \"blob\" | \"http-range\";\n  /** Total file size in bytes if known, otherwise undefined. */\n  readonly size: number | undefined;\n  /** Tear down the virtual file (and any HTTP reader state). */\n  detach(): Promise<void>;\n}\n\ninterface LibavLikeWithBlob extends LibavLike {\n  mkreadaheadfile(name: string, blob: Blob): Promise<void>;\n}\n\n/**\n * Convenience for the libav-backed strategies. Given a normalized source,\n * either creates an in-memory readahead file (for Blob inputs) or attaches\n * the HTTP block reader (for URL inputs). Returns a handle the caller\n * should detach when done.\n */\nexport async function prepareLibavInput(\n  libav: LibavLikeWithBlob,\n  filename: string,\n  source: import(\"./source.js\").NormalizedSource,\n): Promise<LibavInputHandle> {\n  if (source.kind === \"url\") {\n    const handle = await attachLibavHttpReader(libav, filename, source.url);\n    return {\n      filename,\n      transport: \"http-range\",\n      size: handle.size,\n      detach: () => handle.detach(),\n    };\n  }\n  await libav.mkreadaheadfile(filename, source.blob);\n  return {\n    filename,\n    transport: \"blob\",\n    size: source.byteLength,\n    detach: async () => {\n      try { await libav.unlinkreadaheadfile(filename); } catch { /* ignore */ }\n    },\n  };\n}\n\n/**\n * Attach an HTTP block reader to a libav.js instance. After this resolves,\n * libav can `ff_init_demuxer_file(filename)` and the demuxer will pull\n * bytes via Range requests instead of needing a Blob.\n *\n * Fails fast (before any libav setup) if the server doesn't support\n * Range requests.\n */\nexport async function attachLibavHttpReader(\n  libav: LibavLike,\n  filename: string,\n  url: string,\n  options: AttachLibavHttpReaderOptions = {},\n): Promise<LibavHttpReaderHandle> {\n  const fetchFn = options.fetchFn ?? fetch;\n\n  // 1. Probe the server with a single-byte Range request.\n  let probeRes: Response;\n  try {\n    probeRes = await fetchFn(url, {\n      ...options.requestInit,\n      headers: {\n        ...(options.requestInit?.headers ?? {}),\n        Range: \"bytes=0-0\",\n      },\n    });\n  } catch (err) {\n    throw new Error(\n      `libav HTTP reader: failed to reach ${url}: ${(err as Error).message}`,\n    );\n  }\n  if (probeRes.status !== 206) {\n    // 200 means the server ignored Range and would have sent the whole\n    // file. We refuse to silently slurp gigabytes.\n    throw new Error(\n      `libav HTTP reader: ${url} does not support HTTP Range requests ` +\n      `(server returned ${probeRes.status} for a Range probe; need 206 Partial Content). ` +\n      `Remote AVI/ASF/FLV playback requires a server that honors byte-range requests.`,\n    );\n  }\n\n  // 2. Parse total file size from Content-Range: \"bytes 0-0/12345678\"\n  const contentRange = probeRes.headers.get(\"content-range\") ?? \"\";\n  const sizeMatch = contentRange.match(/\\/(\\d+)$/);\n  if (!sizeMatch) {\n    throw new Error(\n      `libav HTTP reader: ${url} returned 206 but no parseable Content-Range header (got: \"${contentRange}\")`,\n    );\n  }\n  const size = parseInt(sizeMatch[1], 10);\n  if (!Number.isFinite(size) || size <= 0) {\n    throw new Error(\n      `libav HTTP reader: ${url} reported invalid file size ${size}`,\n    );\n  }\n\n  // Drain the probe body so the connection can be reused.\n  try { await probeRes.arrayBuffer(); } catch { /* ignore */ }\n\n  // 3. Create the virtual file libav will read from.\n  await libav.mkblockreaderdev(filename, size);\n\n  // ── State ───────────────────────────────────────────────────────────────\n\n  let detached = false;\n  // Most-recently fetched block. Cached so re-reads of the same region\n  // (e.g. demuxer re-walks the header) don't issue another HTTP request.\n  let cached: { pos: number; bytes: Uint8Array } | null = null;\n  // The currently in-flight fetch, if any. Used both for serialization\n  // (we await this before starting another) and for in-flight dedup.\n  let inflight: Promise<void> | null = null;\n\n  function clampReadLength(requested: number): number {\n    const doubled = requested * 2;\n    if (doubled < MIN_READ) return MIN_READ;\n    if (doubled > MAX_READ) return MAX_READ;\n    return doubled;\n  }\n\n  /** True if the cached block fully covers `[pos, pos+length)`. */\n  function cacheCovers(pos: number, length: number): boolean {\n    if (!cached) return false;\n    return pos >= cached.pos && pos + length <= cached.pos + cached.bytes.byteLength;\n  }\n\n  /** Slice the requested window out of the cached block. */\n  function sliceFromCache(pos: number, length: number): Uint8Array {\n    if (!cached) throw new Error(\"sliceFromCache called with no cache\");\n    const offset = pos - cached.pos;\n    return cached.bytes.subarray(offset, offset + length);\n  }\n\n  /** Fetch one Range and update the cache. */\n  async function fetchRange(pos: number, length: number): Promise<Uint8Array> {\n    const end = Math.min(pos + length - 1, size - 1);\n    const res = await fetchFn(url, {\n      ...options.requestInit,\n      headers: {\n        ...(options.requestInit?.headers ?? {}),\n        Range: `bytes=${pos}-${end}`,\n      },\n    });\n    if (res.status !== 206 && res.status !== 200) {\n      throw new Error(\n        `libav HTTP reader: Range request bytes=${pos}-${end} returned ${res.status}`,\n      );\n    }\n    const buf = new Uint8Array(await res.arrayBuffer());\n    cached = { pos, bytes: buf };\n    return buf;\n  }\n\n  /**\n   * Handle a single libav read request. Serializes against any in-flight\n   * read by chaining off `inflight`. Honors `detached` at every async\n   * boundary so a torn-down reader never writes back into libav.\n   */\n  async function handleRead(name: string, pos: number, length: number): Promise<void> {\n    // Wait for any preceding read to finish so we don't interleave.\n    if (inflight) {\n      try { await inflight; } catch { /* ignore — that read's own caller handled it */ }\n    }\n    if (detached) return;\n\n    // Cache hit — reply directly without a network round-trip.\n    if (cacheCovers(pos, length)) {\n      const data = sliceFromCache(pos, length);\n      try { await libav.ff_block_reader_dev_send(name, pos, data); } catch { /* ignore — libav may have torn down */ }\n      return;\n    }\n\n    // Cache miss — fetch via Range. Read-ahead amortizes small reads.\n    const fetchLen = clampReadLength(length);\n    const fetched = (async () => {\n      try {\n        const buf = await fetchRange(pos, fetchLen);\n        if (detached) return;\n        // Slice exactly what libav asked for and send it back.\n        const reply = buf.subarray(0, Math.min(length, buf.byteLength));\n        try { await libav.ff_block_reader_dev_send(name, pos, reply); } catch { /* ignore */ }\n      } catch (err) {\n        if (detached) return;\n        // Signal EOF + error code to libav so the demuxer surfaces it.\n        try {\n          await libav.ff_block_reader_dev_send(name, pos, null, {\n            error: err,\n          });\n        } catch { /* ignore */ }\n      }\n    })();\n    inflight = fetched;\n    try { await fetched; } finally { if (inflight === fetched) inflight = null; }\n  }\n\n  // 4. Wire the callback. The signature accepts `(name, pos, length)` and\n  // we hand it to handleRead which does all the work asynchronously.\n  // Note: libav.js dispatches this synchronously from a worker message,\n  // so we kick off handleRead but don't await — the queue inside handleRead\n  // serializes things.\n  const previousCallback = libav.onblockread;\n  libav.onblockread = (name: string, pos: number, length: number) => {\n    if (detached || name !== filename) {\n      // Forward to any previous callback (e.g. another reader on the same\n      // libav instance). This is rare in practice but cheap to support.\n      previousCallback?.(name, pos, length);\n      return;\n    }\n    void handleRead(name, pos, length);\n  };\n\n  return {\n    size,\n    transport: \"http-range\",\n    async detach() {\n      if (detached) return;\n      detached = true;\n      // Restore the previous callback (if any) so we don't break unrelated\n      // readers on the same libav instance.\n      libav.onblockread = previousCallback;\n      // Wait for the last in-flight read to settle so we don't tear down\n      // the virtual file while libav is still expecting a response.\n      if (inflight) {\n        try { await inflight; } catch { /* ignore */ }\n      }\n      // Drop the cache and unlink the virtual file.\n      cached = null;\n      try { await libav.unlinkreadaheadfile(filename); } catch { /* ignore */ }\n    },\n  };\n}\n"]}

package/dist/chunk-NZU7W256.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// src/strategies/fallback/variant-routing.ts
+var LEGACY_CONTAINERS = /* @__PURE__ */ new Set(["avi", "asf", "flv"]);
+var LEGACY_VIDEO_CODECS = /* @__PURE__ */ new Set([
+  "wmv3",
+  "vc1",
+  "mpeg4",
+  // MPEG-4 Part 2 / DivX / Xvid
+  "rv40",
+  "mpeg2",
+  "mpeg1",
+  "theora"
+]);
+var LEGACY_AUDIO_CODECS = /* @__PURE__ */ new Set(["wmav2", "wmapro", "ac3", "eac3"]);
+function pickLibavVariant(ctx) {
+  if (LEGACY_CONTAINERS.has(ctx.container)) return "avbridge";
+  for (const v of ctx.videoTracks) {
+    if (LEGACY_VIDEO_CODECS.has(v.codec)) return "avbridge";
+  }
+  for (const a of ctx.audioTracks) {
+    if (LEGACY_AUDIO_CODECS.has(a.codec)) return "avbridge";
+  }
+  return "webcodecs";
+}
+
+exports.pickLibavVariant = pickLibavVariant;
+//# sourceMappingURL=chunk-NZU7W256.cjs.map
+//# sourceMappingURL=chunk-NZU7W256.cjs.map

package/dist/chunk-NZU7W256.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategies/fallback/variant-routing.ts"],"names":[],"mappings":";;;AAmBA,IAAM,oCAAoB,IAAI,GAAA,CAAI,CAAC,KAAA,EAAO,KAAA,EAAO,KAAK,CAAC,CAAA;AAEvD,IAAM,mBAAA,uBAA0B,GAAA,CAAgB;AAAA,EAC9C,MAAA;AAAA,EACA,KAAA;AAAA,EACA,OAAA;AAAA;AAAA,EACA,MAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA;AACF,CAAC,CAAA;AAED,IAAM,mBAAA,uBAA0B,GAAA,CAAgB,CAAC,SAAS,QAAA,EAAU,KAAA,EAAO,MAAM,CAAC,CAAA;AAE3E,SAAS,iBAAiB,GAAA,EAAiC;AAChE,EAAA,IAAI,iBAAA,CAAkB,GAAA,CAAI,GAAA,CAAI,SAAS,GAAG,OAAO,UAAA;AACjD,EAAA,KAAA,MAAW,CAAA,IAAK,IAAI,WAAA,EAAa;AAC/B,IAAA,IAAI,mBAAA,CAAoB,GAAA,CAAI,CAAA,CAAE,KAAK,GAAG,OAAO,UAAA;AAAA,EAC/C;AACA,EAAA,KAAA,MAAW,CAAA,IAAK,IAAI,WAAA,EAAa;AAC/B,IAAA,IAAI,mBAAA,CAAoB,GAAA,CAAI,CAAA,CAAE,KAAK,GAAG,OAAO,UAAA;AAAA,EAC/C;AACA,EAAA,OAAO,WAAA;AACT","file":"chunk-NZU7W256.cjs","sourcesContent":["import type { MediaContext, AudioCodec, VideoCodec } from \"../../types.js\";\nimport type { LibavVariant } from \"./libav-loader.js\";\n\n/**\n * Decide which libav.js variant to load for a given media context.\n *\n * - **webcodecs** (~5 MB, npm) — modern formats only, designed for the\n *   WebCodecs bridge. Used when the codec is browser-supported and we just\n *   need libav.js for demuxing or as a parser source.\n *\n * - **avbridge** (custom build, vendor/libav/) — has the AVI/ASF/FLV demuxers\n *   and the legacy decoders (WMV3, MPEG-4 Part 2, VC-1, MS-MPEG4 v1/2/3,\n *   AC-3, WMA*). Required for any of those formats; the npm variants ship\n *   none of them.\n *\n * Rule: pick \"avbridge\" if either the container or any codec is one only the\n * custom build can handle. Otherwise pick \"webcodecs\".\n */\n\nconst LEGACY_CONTAINERS = new Set([\"avi\", \"asf\", \"flv\"]);\n\nconst LEGACY_VIDEO_CODECS = new Set<VideoCodec>([\n  \"wmv3\",\n  \"vc1\",\n  \"mpeg4\", // MPEG-4 Part 2 / DivX / Xvid\n  \"rv40\",\n  \"mpeg2\",\n  \"mpeg1\",\n  \"theora\",\n]);\n\nconst LEGACY_AUDIO_CODECS = new Set<AudioCodec>([\"wmav2\", \"wmapro\", \"ac3\", \"eac3\"]);\n\nexport function pickLibavVariant(ctx: MediaContext): LibavVariant {\n  if (LEGACY_CONTAINERS.has(ctx.container)) return \"avbridge\";\n  for (const v of ctx.videoTracks) {\n    if (LEGACY_VIDEO_CODECS.has(v.codec)) return \"avbridge\";\n  }\n  for (const a of ctx.audioTracks) {\n    if (LEGACY_AUDIO_CODECS.has(a.codec)) return \"avbridge\";\n  }\n  return \"webcodecs\";\n}\n"]}

package/dist/chunk-PQTZS7OA.js

@@ -0,0 +1,147 @@
+// src/util/source.ts
+var SNIFF_BYTES_NEEDED = 380;
+var URL_SNIFF_RANGE_BYTES = 32 * 1024;
+function isInMemorySource(source) {
+  return source.kind === "blob";
+}
+async function normalizeSource(source) {
+  if (source instanceof File) {
+    return {
+      kind: "blob",
+      blob: source,
+      name: source.name,
+      byteLength: source.size,
+      original: source
+    };
+  }
+  if (source instanceof Blob) {
+    return { kind: "blob", blob: source, byteLength: source.size, original: source };
+  }
+  if (source instanceof ArrayBuffer) {
+    const blob = new Blob([source]);
+    return { kind: "blob", blob, byteLength: blob.size, original: source };
+  }
+  if (source instanceof Uint8Array) {
+    const blob = new Blob([source]);
+    return { kind: "blob", blob, byteLength: blob.size, original: source };
+  }
+  if (typeof source === "string" || source instanceof URL) {
+    const url = source instanceof URL ? source.toString() : source;
+    return await fetchUrlForSniff(url, source);
+  }
+  throw new TypeError("unsupported source type");
+}
+async function fetchUrlForSniff(url, originalSource) {
+  const name = url.split("/").pop()?.split("?")[0] ?? void 0;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { Range: `bytes=0-${URL_SNIFF_RANGE_BYTES - 1}` }
+    });
+  } catch (err) {
+    throw new Error(`failed to fetch source ${url}: ${err.message}`);
+  }
+  if (!res.ok && res.status !== 206) {
+    throw new Error(`failed to fetch source ${url}: ${res.status} ${res.statusText}`);
+  }
+  let byteLength;
+  const contentRange = res.headers.get("content-range");
+  if (contentRange) {
+    const m = contentRange.match(/\/(\d+)$/);
+    if (m) byteLength = parseInt(m[1], 10);
+  }
+  if (byteLength === void 0) {
+    const cl = res.headers.get("content-length");
+    if (cl) {
+      const n = parseInt(cl, 10);
+      if (Number.isFinite(n)) {
+        if (res.status === 200) byteLength = n;
+        else if (res.status === 206 && !contentRange) byteLength = n;
+      }
+    }
+  }
+  const reader = res.body?.getReader();
+  if (!reader) {
+    const buf = new Uint8Array(await res.arrayBuffer());
+    const sniffBytes2 = buf.slice(0, URL_SNIFF_RANGE_BYTES);
+    return { kind: "url", url, sniffBytes: sniffBytes2, name, byteLength, original: originalSource };
+  }
+  const chunks = [];
+  let collected = 0;
+  while (collected < URL_SNIFF_RANGE_BYTES) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    collected += value.byteLength;
+  }
+  await reader.cancel().catch(() => {
+  });
+  const total = Math.min(collected, URL_SNIFF_RANGE_BYTES);
+  const sniffBytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    if (offset >= total) break;
+    const room = total - offset;
+    sniffBytes.set(chunk.subarray(0, Math.min(chunk.byteLength, room)), offset);
+    offset += chunk.byteLength;
+  }
+  return { kind: "url", url, sniffBytes, name, byteLength, original: originalSource };
+}
+function sniffContainerFromBytes(head) {
+  if (head.length >= 376 && head[0] === 71 && head[188] === 71) {
+    return "mpegts";
+  }
+  if (head.length >= 380 && head[4] === 71 && head[192] === 71) {
+    return "mpegts";
+  }
+  if (head[0] === 82 && head[1] === 73 && head[2] === 70 && head[3] === 70 && head[8] === 65 && head[9] === 86 && head[10] === 73) return "avi";
+  if (head[0] === 82 && head[1] === 73 && head[2] === 70 && head[3] === 70 && head[8] === 87 && head[9] === 65 && head[10] === 86 && head[11] === 69) return "wav";
+  if (head[0] === 26 && head[1] === 69 && head[2] === 223 && head[3] === 163) {
+    return "mkv";
+  }
+  if (head[4] === 102 && head[5] === 116 && head[6] === 121 && head[7] === 112) {
+    const brand = String.fromCharCode(head[8], head[9], head[10], head[11]);
+    if (brand.startsWith("qt")) return "mov";
+    return "mp4";
+  }
+  if (head[0] === 48 && head[1] === 38 && head[2] === 178 && head[3] === 117 && head[4] === 142 && head[5] === 102 && head[6] === 207 && head[7] === 17) return "asf";
+  if (head[0] === 70 && head[1] === 76 && head[2] === 86) return "flv";
+  if (head[0] === 79 && head[1] === 103 && head[2] === 103 && head[3] === 83) return "ogg";
+  if (head[0] === 102 && head[1] === 76 && head[2] === 97 && head[3] === 67) return "flac";
+  if (head[0] === 73 && head[1] === 68 && head[2] === 51) return "mp3";
+  if (head[0] === 255 && (head[1] & 224) === 224) {
+    if ((head[1] & 246) === 240) return "adts";
+    return "mp3";
+  }
+  return "unknown";
+}
+async function sniffNormalizedSource(source) {
+  if (source.kind === "url") {
+    return sniffContainerFromBytes(source.sniffBytes);
+  }
+  const buf = await readBlobBytes(source.blob, SNIFF_BYTES_NEEDED);
+  return sniffContainerFromBytes(new Uint8Array(buf));
+}
+async function sniffContainer(blob) {
+  const buf = await readBlobBytes(blob, SNIFF_BYTES_NEEDED);
+  return sniffContainerFromBytes(new Uint8Array(buf));
+}
+async function readBlobBytes(blob, limit) {
+  const slice = blob.slice(0, limit);
+  if (typeof slice.arrayBuffer === "function") {
+    try {
+      return await slice.arrayBuffer();
+    } catch {
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error ?? new Error("FileReader failed"));
+    reader.readAsArrayBuffer(slice);
+  });
+}
+
+export { isInMemorySource, normalizeSource, sniffContainer, sniffContainerFromBytes, sniffNormalizedSource };
+//# sourceMappingURL=chunk-PQTZS7OA.js.map
+//# sourceMappingURL=chunk-PQTZS7OA.js.map

package/dist/chunk-PQTZS7OA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/util/source.ts"],"names":["sniffBytes"],"mappings":";AAOA,IAAM,kBAAA,GAAqB,GAAA;AAQ3B,IAAM,wBAAwB,EAAA,GAAK,IAAA;AAgC5B,SAAS,iBAAiB,MAAA,EAAiF;AAChH,EAAA,OAAO,OAAO,IAAA,KAAS,MAAA;AACzB;AAYA,eAAsB,gBAAgB,MAAA,EAA+C;AACnF,EAAA,IAAI,kBAAkB,IAAA,EAAM;AAC1B,IAAA,OAAO;AAAA,MACL,IAAA,EAAM,MAAA;AAAA,MACN,IAAA,EAAM,MAAA;AAAA,MACN,MAAM,MAAA,CAAO,IAAA;AAAA,MACb,YAAY,MAAA,CAAO,IAAA;AAAA,MACnB,QAAA,EAAU;AAAA,KACZ;AAAA,EACF;AACA,EAAA,IAAI,kBAAkB,IAAA,EAAM;AAC1B,IAAA,OAAO,EAAE,MAAM,MAAA,EAAQ,IAAA,EAAM,QAAQ,UAAA,EAAY,MAAA,CAAO,IAAA,EAAM,QAAA,EAAU,MAAA,EAAO;AAAA,EACjF;AACA,EAAA,IAAI,kBAAkB,WAAA,EAAa;AACjC,IAAA,MAAM,IAAA,GAAO,IAAI,IAAA,CAAK,CAAC,MAAM,CAAC,CAAA;AAC9B,IAAA,OAAO,EAAE,MAAM,MAAA,EAAQ,IAAA,EAAM,YAAY,IAAA,CAAK,IAAA,EAAM,UAAU,MAAA,EAAO;AAAA,EACvE;AACA,EAAA,IAAI,kBAAkB,UAAA,EAAY;AAChC,IAAA,MAAM,IAAA,GAAO,IAAI,IAAA,CAAK,CAAC,MAAkB,CAAC,CAAA;AAC1C,IAAA,OAAO,EAAE,MAAM,MAAA,EAAQ,IAAA,EAAM,YAAY,IAAA,CAAK,IAAA,EAAM,UAAU,MAAA,EAAO;AAAA,EACvE;AACA,EAAA,IAAI,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,YAAkB,GAAA,EAAK;AACvD,IAAA,MAAM,GAAA,GAAM,MAAA,YAAkB,GAAA,GAAM,MAAA,CAAO,UAAS,GAAI,MAAA;AACxD,IAAA,OAAO,MAAM,gBAAA,CAAiB,GAAA,EAAK,MAAM,CAAA;AAAA,EAC3C;AACA,EAAA,MAAM,IAAI,UAAU,yBAAyB,CAAA;AAC/C;AAQA,eAAe,gBAAA,CAAiB,KAAa,cAAA,EAAuD;AAClG,EAAA,MAAM,IAAA,GAAO,GAAA,CAAI,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,EAAI,EAAG,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,IAAK,MAAA;AAGpD,EAAA,IAAI,GAAA;AACJ,EAAA,IAAI;AACF,IAAA,GAAA,GAAM,MAAM,MAAM,GAAA,EAAK;AAAA,MACrB,SAAS,EAAE,KAAA,EAAO,CAAA,QAAA,EAAW,qBAAA,GAAwB,CAAC,CAAA,CAAA;AAAG,KAC1D,CAAA;AAAA,EACH,SAAS,GAAA,EAAK;AACZ,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,uBAAA,EAA0B,GAAG,CAAA,EAAA,EAAM,GAAA,CAAc,OAAO,CAAA,CAAE,CAAA;AAAA,EAC5E;AACA,EAAA,IAAI,CAAC,GAAA,CAAI,EAAA,IAAM,GAAA,CAAI,WAAW,GAAA,EAAK;AACjC,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,uBAAA,EAA0B,GAAG,CAAA,EAAA,EAAK,IAAI,MAAM,CAAA,CAAA,EAAI,GAAA,CAAI,UAAU,CAAA,CAAE,CAAA;AAAA,EAClF;AAGA,EAAA,IAAI,UAAA;AACJ,EAAA,MAAM,YAAA,GAAe,GAAA,CAAI,OAAA,CAAQ,GAAA,CAAI,eAAe,CAAA;AACpD,EAAA,IAAI,YAAA,EAAc;AAEhB,IAAA,MAAM,CAAA,GAAI,YAAA,CAAa,KAAA,CAAM,UAAU,CAAA;AACvC,IAAA,IAAI,GAAG,UAAA,GAAa,QAAA,CAAS,CAAA,CAAE,CAAC,GAAG,EAAE,CAAA;AAAA,EACvC;AACA,EAAA,IAAI,eAAe,MAAA,EAAW;AAC5B,IAAA,MAAM,EAAA,GAAK,GAAA,CAAI,OAAA,CAAQ,GAAA,CAAI,gBAAgB,CAAA;AAC3C,IAAA,IAAI,EAAA,EAAI;AACN,MAAA,MAAM,CAAA,GAAI,QAAA,CAAS,EAAA,EAAI,EAAE,CAAA;AACzB,MAAA,IAAI,MAAA,CAAO,QAAA,CAAS,CAAC,CAAA,EAAG;AAKtB,QAAA,IAAI,GAAA,CAAI,MAAA,KAAW,GAAA,EAAK,UAAA,GAAa,CAAA;AAAA,aAAA,IAC5B,GAAA,CAAI,MAAA,KAAW,GAAA,IAAO,CAAC,cAAc,UAAA,GAAa,CAAA;AAAA,MAC7D;AAAA,IACF;AAAA,EACF;AAKA,EAAA,MAAM,MAAA,GAAS,GAAA,CAAI,IAAA,EAAM,SAAA,EAAU;AACnC,EAAA,IAAI,CAAC,MAAA,EAAQ;AAIX,IAAA,MAAM,MAAM,IAAI,UAAA,CAAW,MAAM,GAAA,CAAI,aAAa,CAAA;AAClD,IAAA,MAAMA,WAAAA,GAAa,GAAA,CAAI,KAAA,CAAM,CAAA,EAAG,qBAAqB,CAAA;AACrD,IAAA,OAAO,EAAE,MAAM,KAAA,EAAO,GAAA,EAAK,YAAAA,WAAAA,EAAY,IAAA,EAAM,UAAA,EAAY,QAAA,EAAU,cAAA,EAAe;AAAA,EACpF;AAEA,EAAA,MAAM,SAAuB,EAAC;AAC9B,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,OAAO,YAAY,qBAAA,EAAuB;AACxC,IAAA,MAAM,EAAE,IAAA,EAAM,KAAA,EAAM,GAAI,MAAM,OAAO,IAAA,EAAK;AAC1C,IAAA,IAAI,IAAA,EAAM;AACV,IAAA,MAAA,CAAO,KAAK,KAAK,CAAA;AACjB,IAAA,SAAA,IAAa,KAAA,CAAM,UAAA;AAAA,EACrB;AAEA,EAAA,MAAM,MAAA,CAAO,MAAA,EAAO,CAAE,KAAA,CAAM,MAAM;AAAA,EAAe,CAAC,CAAA;AAGlD,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,GAAA,CAAI,SAAA,EAAW,qBAAqB,CAAA;AACvD,EAAA,MAAM,UAAA,GAAa,IAAI,UAAA,CAAW,KAAK,CAAA;AACvC,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,IAAI,UAAU,KAAA,EAAO;AACrB,IAAA,MAAM,OAAO,KAAA,GAAQ,MAAA;AACrB,IAAA,UAAA,CAAW,GAAA,CAAI,KAAA,CAAM,QAAA,CAAS,CAAA,EAAG,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,UAAA,EAAY,IAAI,CAAC,CAAA,EAAG,MAAM,CAAA;AAC1E,IAAA,MAAA,IAAU,KAAA,CAAM,UAAA;AAAA,EAClB;AAEA,EAAA,OAAO,EAAE,MAAM,KAAA,EAAO,GAAA,EAAK,YAAY,IAAA,EAAM,UAAA,EAAY,UAAU,cAAA,EAAe;AACpF;AASO,SAAS,wBAAwB,IAAA,EAAiC;AAIvE,EAAA,IAAI,IAAA,CAAK,MAAA,IAAU,GAAA,IAAO,IAAA,CAAK,CAAC,MAAM,EAAA,IAAQ,IAAA,CAAK,GAAG,CAAA,KAAM,EAAA,EAAM;AAChE,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,IAAI,IAAA,CAAK,MAAA,IAAU,GAAA,IAAO,IAAA,CAAK,CAAC,MAAM,EAAA,IAAQ,IAAA,CAAK,GAAG,CAAA,KAAM,EAAA,EAAM;AAChE,IAAA,OAAO,QAAA;AAAA,EACT;AAEA,EAAA,IACE,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IACxE,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,EAAE,CAAA,KAAM,EAAA,EACrD,OAAO,KAAA;AAET,EAAA,IACE,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,KAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IACxE,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,EAAA,IAAQ,IAAA,CAAK,EAAE,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,EAAE,CAAA,KAAM,IAC1E,OAAO,KAAA;AAET,EAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,KAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,GAAA,EAAM;AAChF,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,KAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,GAAA,EAAM;AAEhF,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,YAAA,CAAa,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,EAAE,CAAA,EAAG,IAAA,CAAK,EAAE,CAAC,CAAA;AACtE,IAAA,IAAI,KAAA,CAAM,UAAA,CAAW,IAAI,CAAA,EAAG,OAAO,KAAA;AACnC,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,IACE,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,KAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IACxE,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,IACxE,OAAO,KAAA;AAET,EAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,EAAM,OAAO,KAAA;AAErE,EAAA,IAAI,KAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,IAAM,OAAO,KAAA;AAEzF,EAAA,IAAI,KAAK,CAAC,CAAA,KAAM,GAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,MAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,IAAM,OAAO,MAAA;AAEzF,EAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,IAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,EAAA,EAAM,OAAO,KAAA;AAErE,EAAA,IAAI,IAAA,CAAK,CAAC,CAAA,KAAM,GAAA,IAAA,CAAS,KAAK,CAAC,CAAA,GAAI,SAAU,GAAA,EAAM;AAEjD,IAAA,IAAA,CAAK,IAAA,CAAK,CAAC,CAAA,GAAI,GAAA,MAAU,KAAM,OAAO,MAAA;AACtC,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA;AACT;AAOA,eAAsB,sBAAsB,MAAA,EAAkD;AAC5F,EAAA,IAAI,MAAA,CAAO,SAAS,KAAA,EAAO;AACzB,IAAA,OAAO,uBAAA,CAAwB,OAAO,UAAU,CAAA;AAAA,EAClD;AACA,EAAA,MAAM,GAAA,GAAM,MAAM,aAAA,CAAc,MAAA,CAAO,MAAM,kBAAkB,CAAA;AAC/D,EAAA,OAAO,uBAAA,CAAwB,IAAI,UAAA,CAAW,GAAG,CAAC,CAAA;AACpD;AAMA,eAAsB,eAAe,IAAA,EAAoC;AACvE,EAAA,MAAM,GAAA,GAAM,MAAM,aAAA,CAAc,IAAA,EAAM,kBAAkB,CAAA;AACxD,EAAA,OAAO,uBAAA,CAAwB,IAAI,UAAA,CAAW,GAAG,CAAC,CAAA;AACpD;AAMA,eAAe,aAAA,CAAc,MAAY,KAAA,EAAqC;AAC5E,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,KAAK,CAAA;AACjC,EAAA,IAAI,OAAQ,KAAA,CAA8D,WAAA,KAAgB,UAAA,EAAY;AACpG,IAAA,IAAI;AACF,MAAA,OAAO,MAAO,MAA6D,WAAA,EAAY;AAAA,IACzF,CAAA,CAAA,MAAQ;AAAA,IAER;AAAA,EACF;AACA,EAAA,OAAO,IAAI,OAAA,CAAQ,CAAC,OAAA,EAAS,MAAA,KAAW;AACtC,IAAA,MAAM,MAAA,GAAS,IAAI,UAAA,EAAW;AAC9B,IAAA,MAAA,CAAO,MAAA,GAAS,MAAM,OAAA,CAAQ,MAAA,CAAO,MAAqB,CAAA;AAC1D,IAAA,MAAA,CAAO,OAAA,GAAU,MAAM,MAAA,CAAO,MAAA,CAAO,SAAS,IAAI,KAAA,CAAM,mBAAmB,CAAC,CAAA;AAC5E,IAAA,MAAA,CAAO,kBAAkB,KAAK,CAAA;AAAA,EAChC,CAAC,CAAA;AACH","file":"chunk-PQTZS7OA.js","sourcesContent":["import type { ContainerKind, MediaInput } from \"../types.js\";\n\n/**\n * Bytes needed by the sniffer to identify every container we recognize.\n * MPEG-TS needs the most: a sync byte at offset 0 *and* offset 188 (one TS\n * packet apart). Allow a little extra for the M2TS variant (offset 4/192).\n */\nconst SNIFF_BYTES_NEEDED = 380;\n\n/**\n * Bytes to fetch from a URL during the initial sniff. We grab a slightly\n * larger range than `SNIFF_BYTES_NEEDED` so the cache has some headroom for\n * the demuxer's first read after sniffing, in case it wants to look at\n * a few extra bytes (e.g. mp4 ftyp + first moov box).\n */\nconst URL_SNIFF_RANGE_BYTES = 32 * 1024;\n\n/**\n * `NormalizedSource` is a discriminated union: every consumer (probe,\n * strategies) decides what to do based on `kind`. URL sources are NOT\n * fetched eagerly; we only do a Range request for the first ~32 KB so the\n * sniffer has bytes to look at. The strategies are then handed the URL\n * directly so they can stream the rest via Range requests.\n *\n * For File / Blob / ArrayBuffer / Uint8Array sources, the bytes are\n * already in memory, so we wrap them as a `blob` variant.\n */\nexport type NormalizedSource =\n  | {\n      kind: \"blob\";\n      blob: Blob;\n      name?: string;\n      byteLength: number;\n      original: MediaInput;\n    }\n  | {\n      kind: \"url\";\n      url: string;\n      /** Bytes pulled via Range request for the sniffer. NOT the full file. */\n      sniffBytes: Uint8Array;\n      name?: string;\n      /** Total file size from Content-Length / Content-Range. May be undefined. */\n      byteLength: number | undefined;\n      original: MediaInput;\n    };\n\n/** True if this source carries the entire file's bytes (vs. streaming). */\nexport function isInMemorySource(source: NormalizedSource): source is Extract<NormalizedSource, { kind: \"blob\" }> {\n  return source.kind === \"blob\";\n}\n\n\n/**\n * Normalize a `MediaInput` for the probe + strategy layers. **Does not**\n * download URL sources in full — only fetches the first ~32 KB via a\n * Range request, which is enough for the sniffer to identify the\n * container. The strategies are then expected to stream the rest via\n * mediabunny's `UrlSource` (Range requests, prefetch, parallelism, cache).\n *\n * For non-URL inputs, the bytes are already in memory and we just wrap them.\n */\nexport async function normalizeSource(source: MediaInput): Promise<NormalizedSource> {\n  if (source instanceof File) {\n    return {\n      kind: \"blob\",\n      blob: source,\n      name: source.name,\n      byteLength: source.size,\n      original: source,\n    };\n  }\n  if (source instanceof Blob) {\n    return { kind: \"blob\", blob: source, byteLength: source.size, original: source };\n  }\n  if (source instanceof ArrayBuffer) {\n    const blob = new Blob([source]);\n    return { kind: \"blob\", blob, byteLength: blob.size, original: source };\n  }\n  if (source instanceof Uint8Array) {\n    const blob = new Blob([source as BlobPart]);\n    return { kind: \"blob\", blob, byteLength: blob.size, original: source };\n  }\n  if (typeof source === \"string\" || source instanceof URL) {\n    const url = source instanceof URL ? source.toString() : source;\n    return await fetchUrlForSniff(url, source);\n  }\n  throw new TypeError(\"unsupported source type\");\n}\n\n/**\n * Fetch the first ~32 KB of a URL via a Range request. Falls back to a\n * full GET if the server doesn't support range requests, but in that case\n * we only read the first 32 KB and abort the rest of the response so we\n * don't accidentally buffer a large file.\n */\nasync function fetchUrlForSniff(url: string, originalSource: MediaInput): Promise<NormalizedSource> {\n  const name = url.split(\"/\").pop()?.split(\"?\")[0] ?? undefined;\n\n  // First attempt: Range request for the sniff window.\n  let res: Response;\n  try {\n    res = await fetch(url, {\n      headers: { Range: `bytes=0-${URL_SNIFF_RANGE_BYTES - 1}` },\n    });\n  } catch (err) {\n    throw new Error(`failed to fetch source ${url}: ${(err as Error).message}`);\n  }\n  if (!res.ok && res.status !== 206) {\n    throw new Error(`failed to fetch source ${url}: ${res.status} ${res.statusText}`);\n  }\n\n  // Determine the total file size from Content-Range (preferred) or Content-Length.\n  let byteLength: number | undefined;\n  const contentRange = res.headers.get(\"content-range\");\n  if (contentRange) {\n    // \"bytes 0-32767/12345678\" — parse the part after the slash\n    const m = contentRange.match(/\\/(\\d+)$/);\n    if (m) byteLength = parseInt(m[1], 10);\n  }\n  if (byteLength === undefined) {\n    const cl = res.headers.get(\"content-length\");\n    if (cl) {\n      const n = parseInt(cl, 10);\n      if (Number.isFinite(n)) {\n        // If the server returned 200 (full body), Content-Length is the\n        // FILE size. If 206 (partial), it's the chunk size — only use it\n        // as a total if no Content-Range was present (server doesn't do\n        // ranges) AND the full response is smaller than our sniff window.\n        if (res.status === 200) byteLength = n;\n        else if (res.status === 206 && !contentRange) byteLength = n;\n      }\n    }\n  }\n\n  // Read the sniff bytes. If the server ignored the Range header and is\n  // streaming the full file, only read the first window and let the rest\n  // be GC'd. We use a reader so we can stop early.\n  const reader = res.body?.getReader();\n  if (!reader) {\n    // No streamed body (some test environments). Fall back to .arrayBuffer()\n    // and slice — this might pull more than we wanted, but only for the\n    // initial sniff, not the full file.\n    const buf = new Uint8Array(await res.arrayBuffer());\n    const sniffBytes = buf.slice(0, URL_SNIFF_RANGE_BYTES);\n    return { kind: \"url\", url, sniffBytes, name, byteLength, original: originalSource };\n  }\n\n  const chunks: Uint8Array[] = [];\n  let collected = 0;\n  while (collected < URL_SNIFF_RANGE_BYTES) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n    collected += value.byteLength;\n  }\n  // Cancel the response so we don't keep downloading.\n  await reader.cancel().catch(() => { /* ignore */ });\n\n  // Concatenate up to URL_SNIFF_RANGE_BYTES.\n  const total = Math.min(collected, URL_SNIFF_RANGE_BYTES);\n  const sniffBytes = new Uint8Array(total);\n  let offset = 0;\n  for (const chunk of chunks) {\n    if (offset >= total) break;\n    const room = total - offset;\n    sniffBytes.set(chunk.subarray(0, Math.min(chunk.byteLength, room)), offset);\n    offset += chunk.byteLength;\n  }\n\n  return { kind: \"url\", url, sniffBytes, name, byteLength, original: originalSource };\n}\n\n/**\n * Identify the container family from a small byte buffer. Used by the\n * probe layer for both file (Blob → first 380 bytes) and URL (Range\n * request → first 32 KB) inputs.\n *\n * Sniffing intentionally does not trust file extensions.\n */\nexport function sniffContainerFromBytes(head: Uint8Array): ContainerKind {\n  // MPEG-TS: sync byte 0x47 every 188 bytes. Verify at least two sync\n  // bytes in the right places to avoid false positives. Some captures\n  // start with a few junk bytes — also try offsets 4 and 192 (M2TS).\n  if (head.length >= 376 && head[0] === 0x47 && head[188] === 0x47) {\n    return \"mpegts\";\n  }\n  if (head.length >= 380 && head[4] === 0x47 && head[192] === 0x47) {\n    return \"mpegts\"; // M2TS — 4-byte timestamp prefix per packet\n  }\n  // RIFF....AVI  →  AVI\n  if (\n    head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46 &&\n    head[8] === 0x41 && head[9] === 0x56 && head[10] === 0x49\n  ) return \"avi\";\n  // RIFF....WAVE → WAV\n  if (\n    head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46 &&\n    head[8] === 0x57 && head[9] === 0x41 && head[10] === 0x56 && head[11] === 0x45\n  ) return \"wav\";\n  // EBML start: 1A 45 DF A3 → MKV/WebM. Distinguish later via DocType.\n  if (head[0] === 0x1a && head[1] === 0x45 && head[2] === 0xdf && head[3] === 0xa3) {\n    return \"mkv\";\n  }\n  // ftyp at offset 4 → MP4 family\n  if (head[4] === 0x66 && head[5] === 0x74 && head[6] === 0x79 && head[7] === 0x70) {\n    // brand at bytes 8..11\n    const brand = String.fromCharCode(head[8], head[9], head[10], head[11]);\n    if (brand.startsWith(\"qt\")) return \"mov\";\n    return \"mp4\";\n  }\n  // ASF / WMV: 30 26 B2 75 8E 66 CF 11\n  if (\n    head[0] === 0x30 && head[1] === 0x26 && head[2] === 0xb2 && head[3] === 0x75 &&\n    head[4] === 0x8e && head[5] === 0x66 && head[6] === 0xcf && head[7] === 0x11\n  ) return \"asf\";\n  // FLV: 46 4C 56\n  if (head[0] === 0x46 && head[1] === 0x4c && head[2] === 0x56) return \"flv\";\n  // OggS: 4F 67 67 53\n  if (head[0] === 0x4f && head[1] === 0x67 && head[2] === 0x67 && head[3] === 0x53) return \"ogg\";\n  // FLAC: 66 4C 61 43\n  if (head[0] === 0x66 && head[1] === 0x4c && head[2] === 0x61 && head[3] === 0x43) return \"flac\";\n  // ID3v2: 49 44 33  → MP3 (with id3)\n  if (head[0] === 0x49 && head[1] === 0x44 && head[2] === 0x33) return \"mp3\";\n  // MPEG audio frame sync: FF Fx\n  if (head[0] === 0xff && (head[1] & 0xe0) === 0xe0) {\n    // ADTS: FF F1 / FF F9\n    if ((head[1] & 0xf6) === 0xf0) return \"adts\";\n    return \"mp3\";\n  }\n  return \"unknown\";\n}\n\n/**\n * Convenience: sniff a `NormalizedSource` regardless of kind. For URL\n * sources, uses the pre-fetched `sniffBytes`. For blob sources, reads the\n * first 380 bytes.\n */\nexport async function sniffNormalizedSource(source: NormalizedSource): Promise<ContainerKind> {\n  if (source.kind === \"url\") {\n    return sniffContainerFromBytes(source.sniffBytes);\n  }\n  const buf = await readBlobBytes(source.blob, SNIFF_BYTES_NEEDED);\n  return sniffContainerFromBytes(new Uint8Array(buf));\n}\n\n/**\n * Backwards-compatible wrapper for code that still passes a Blob directly.\n * Prefer `sniffNormalizedSource` going forward.\n */\nexport async function sniffContainer(blob: Blob): Promise<ContainerKind> {\n  const buf = await readBlobBytes(blob, SNIFF_BYTES_NEEDED);\n  return sniffContainerFromBytes(new Uint8Array(buf));\n}\n\n/**\n * Read up to `limit` bytes from a Blob. Tries `Blob.arrayBuffer()` first\n * (modern browsers), then falls back to `FileReader` (works under jsdom).\n */\nasync function readBlobBytes(blob: Blob, limit: number): Promise<ArrayBuffer> {\n  const slice = blob.slice(0, limit);\n  if (typeof (slice as Blob & { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer === \"function\") {\n    try {\n      return await (slice as Blob & { arrayBuffer: () => Promise<ArrayBuffer> }).arrayBuffer();\n    } catch {\n      /* fall through to FileReader */\n    }\n  }\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => resolve(reader.result as ArrayBuffer);\n    reader.onerror = () => reject(reader.error ?? new Error(\"FileReader failed\"));\n    reader.readAsArrayBuffer(slice);\n  });\n}\n"]}

package/dist/chunk-WD2ZNQA7.js

@@ -0,0 +1,177 @@
+// src/util/libav-http-reader.ts
+var MIN_READ = 256 * 1024;
+var MAX_READ = 1 * 1024 * 1024;
+async function prepareLibavInput(libav, filename, source) {
+  if (source.kind === "url") {
+    const handle = await attachLibavHttpReader(libav, filename, source.url);
+    return {
+      filename,
+      transport: "http-range",
+      size: handle.size,
+      detach: () => handle.detach()
+    };
+  }
+  await libav.mkreadaheadfile(filename, source.blob);
+  return {
+    filename,
+    transport: "blob",
+    size: source.byteLength,
+    detach: async () => {
+      try {
+        await libav.unlinkreadaheadfile(filename);
+      } catch {
+      }
+    }
+  };
+}
+async function attachLibavHttpReader(libav, filename, url, options = {}) {
+  const fetchFn = options.fetchFn ?? fetch;
+  let probeRes;
+  try {
+    probeRes = await fetchFn(url, {
+      ...options.requestInit,
+      headers: {
+        ...options.requestInit?.headers ?? {},
+        Range: "bytes=0-0"
+      }
+    });
+  } catch (err) {
+    throw new Error(
+      `libav HTTP reader: failed to reach ${url}: ${err.message}`
+    );
+  }
+  if (probeRes.status !== 206) {
+    throw new Error(
+      `libav HTTP reader: ${url} does not support HTTP Range requests (server returned ${probeRes.status} for a Range probe; need 206 Partial Content). Remote AVI/ASF/FLV playback requires a server that honors byte-range requests.`
+    );
+  }
+  const contentRange = probeRes.headers.get("content-range") ?? "";
+  const sizeMatch = contentRange.match(/\/(\d+)$/);
+  if (!sizeMatch) {
+    throw new Error(
+      `libav HTTP reader: ${url} returned 206 but no parseable Content-Range header (got: "${contentRange}")`
+    );
+  }
+  const size = parseInt(sizeMatch[1], 10);
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new Error(
+      `libav HTTP reader: ${url} reported invalid file size ${size}`
+    );
+  }
+  try {
+    await probeRes.arrayBuffer();
+  } catch {
+  }
+  await libav.mkblockreaderdev(filename, size);
+  let detached = false;
+  let cached = null;
+  let inflight = null;
+  function clampReadLength(requested) {
+    const doubled = requested * 2;
+    if (doubled < MIN_READ) return MIN_READ;
+    if (doubled > MAX_READ) return MAX_READ;
+    return doubled;
+  }
+  function cacheCovers(pos, length) {
+    if (!cached) return false;
+    return pos >= cached.pos && pos + length <= cached.pos + cached.bytes.byteLength;
+  }
+  function sliceFromCache(pos, length) {
+    if (!cached) throw new Error("sliceFromCache called with no cache");
+    const offset = pos - cached.pos;
+    return cached.bytes.subarray(offset, offset + length);
+  }
+  async function fetchRange(pos, length) {
+    const end = Math.min(pos + length - 1, size - 1);
+    const res = await fetchFn(url, {
+      ...options.requestInit,
+      headers: {
+        ...options.requestInit?.headers ?? {},
+        Range: `bytes=${pos}-${end}`
+      }
+    });
+    if (res.status !== 206 && res.status !== 200) {
+      throw new Error(
+        `libav HTTP reader: Range request bytes=${pos}-${end} returned ${res.status}`
+      );
+    }
+    const buf = new Uint8Array(await res.arrayBuffer());
+    cached = { pos, bytes: buf };
+    return buf;
+  }
+  async function handleRead(name, pos, length) {
+    if (inflight) {
+      try {
+        await inflight;
+      } catch {
+      }
+    }
+    if (detached) return;
+    if (cacheCovers(pos, length)) {
+      const data = sliceFromCache(pos, length);
+      try {
+        await libav.ff_block_reader_dev_send(name, pos, data);
+      } catch {
+      }
+      return;
+    }
+    const fetchLen = clampReadLength(length);
+    const fetched = (async () => {
+      try {
+        const buf = await fetchRange(pos, fetchLen);
+        if (detached) return;
+        const reply = buf.subarray(0, Math.min(length, buf.byteLength));
+        try {
+          await libav.ff_block_reader_dev_send(name, pos, reply);
+        } catch {
+        }
+      } catch (err) {
+        if (detached) return;
+        try {
+          await libav.ff_block_reader_dev_send(name, pos, null, {
+            error: err
+          });
+        } catch {
+        }
+      }
+    })();
+    inflight = fetched;
+    try {
+      await fetched;
+    } finally {
+      if (inflight === fetched) inflight = null;
+    }
+  }
+  const previousCallback = libav.onblockread;
+  libav.onblockread = (name, pos, length) => {
+    if (detached || name !== filename) {
+      previousCallback?.(name, pos, length);
+      return;
+    }
+    void handleRead(name, pos, length);
+  };
+  return {
+    size,
+    transport: "http-range",
+    async detach() {
+      if (detached) return;
+      detached = true;
+      libav.onblockread = previousCallback;
+      if (inflight) {
+        try {
+          await inflight;
+        } catch {
+        }
+      }
+      cached = null;
+      try {
+        await libav.unlinkreadaheadfile(filename);
+      } catch {
+      }
+    }
+  };
+}
+
+export { attachLibavHttpReader, prepareLibavInput };
+//# sourceMappingURL=chunk-WD2ZNQA7.js.map
+//# sourceMappingURL=chunk-WD2ZNQA7.js.map