@remotion/media-parser 4.0.265 → 4.0.267

package/dist/esm/index.mjs

@@ -1,237 +1,3 @@
-// src/errors.ts
-class IsAGifError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.fileName = "IsAGifError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAGifError);
-    }
-  }
-}
-
-class IsAnImageError extends Error {
-  imageType;
-  dimensions;
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    dimensions,
-    imageType,
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnImageError";
-    this.imageType = imageType;
-    this.dimensions = dimensions;
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnImageError);
-    }
-  }
-}
-
-class IsAPdfError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAPdfError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAPdfError);
-    }
-  }
-}
-
-class IsAnUnsupportedFileTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedFileTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
-    }
-  }
-}
-
-class IsAnUnsupportedAudioTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  audioType;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName,
-    audioType
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedAudioTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    this.audioType = audioType;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
-    }
-  }
-}
-
-class MediaParserAbortError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MediaParserAbortError";
-    this.cause = undefined;
-  }
-}
-var hasBeenAborted = (error) => {
-  return error instanceof MediaParserAbortError;
-};
-
-// src/readers/from-fetch.ts
-function parseContentRange(input) {
-  const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
-  if (!matches)
-    return null;
-  const [, unit, , start, end, size] = matches;
-  const range = {
-    unit,
-    start: start != null ? Number(start) : null,
-    end: end != null ? Number(end) : null,
-    size: size === "*" ? null : Number(size)
-  };
-  if (range.start === null && range.end === null && range.size === null) {
-    return null;
-  }
-  return range;
-}
-var validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange, statusCode) => {
-  if (statusCode === 206) {
-    return { supportsContentRange: true };
-  }
-  if (typeof actualRange === "number" && parsedContentRange?.start !== actualRange) {
-    if (actualRange === 0) {
-      return { supportsContentRange: false };
-    }
-    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
-  }
-  if (actualRange !== null && typeof actualRange !== "number" && (parsedContentRange?.start !== actualRange[0] || parsedContentRange?.end !== actualRange[1])) {
-    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
-  }
-  return { supportsContentRange: true };
-};
-var fetchReader = {
-  read: async ({ src, range, controller }) => {
-    if (typeof src !== "string") {
-      throw new Error("src must be a string when using `fetchReader`");
-    }
-    const resolvedUrl = typeof window !== "undefined" && typeof window.location !== "undefined" ? new URL(src, window.location.origin).toString() : src;
-    if (!resolvedUrl.startsWith("https://") && !resolvedUrl.startsWith("blob:") && !resolvedUrl.startsWith("http://")) {
-      return Promise.reject(new Error(resolvedUrl + " is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass `reader: nodeReader` to parseMedia()."));
-    }
-    const ownController = new AbortController;
-    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
-    const actualRange = range === null ? 0 : range;
-    const res = await fetch(resolvedUrl, {
-      headers: typeof actualRange === "number" ? {
-        Range: `bytes=${actualRange}-`
-      } : {
-        Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
-      },
-      signal: ownController.signal,
-      cache
-    });
-    const contentRange = res.headers.get("content-range");
-    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
-    const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
-    controller._internals.signal.addEventListener("abort", () => {
-      ownController.abort(new MediaParserAbortError("Aborted by user"));
-    }, { once: true });
-    if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
-      throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
-    }
-    if (!res.body) {
-      throw new Error("No body");
-    }
-    const length = res.headers.get("content-length");
-    const contentLength = length === null ? null : parseInt(length, 10);
-    const contentDisposition = res.headers.get("content-disposition");
-    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
-    const fallbackName = src.split("/").pop();
-    const reader = res.body.getReader();
-    if (controller) {
-      controller._internals.signal.addEventListener("abort", () => {
-        reader.cancel().catch(() => {
-        });
-      }, { once: true });
-    }
-    return {
-      reader: {
-        reader,
-        abort: () => {
-          ownController.abort();
-        }
-      },
-      contentLength,
-      contentType: res.headers.get("content-type"),
-      name: name ?? fallbackName,
-      supportsContentRange
-    };
-  },
-  getLength: async (src) => {
-    if (typeof src !== "string") {
-      throw new Error("src must be a string when using `fetchReader`");
-    }
-    const res = await fetch(src, {
-      method: "HEAD"
-    });
-    if (!res.body) {
-      throw new Error("No body");
-    }
-    const length = res.headers.get("content-length");
-    if (!length) {
-      throw new Error("No content-length");
-    }
-    return parseInt(length, 10);
-  }
-};
-
 // src/aac-codecprivate.ts
 var getSampleRateFromSampleFrequencyIndex = (samplingFrequencyIndex) => {
   switch (samplingFrequencyIndex) {
@@ -1135,6 +901,9 @@ var isFlac = (data) => {
   const flacPattern = new Uint8Array([102, 76, 97, 67]);
   return matchesPattern(flacPattern)(data.subarray(0, 4));
 };
+var isM3u = (data) => {
+  return new TextDecoder("utf-8").decode(data.slice(0, 7)) === "#EXTM3U";
+};
 
 // src/file-types/bmp.ts
 function getBmpDimensions(bmpData) {
@@ -1282,6 +1051,9 @@ var detectFileType = (data) => {
   if (isFlac(data)) {
     return { type: "flac" };
   }
+  if (isM3u(data)) {
+    return { type: "m3u" };
+  }
   const webp = isWebp(data);
   if (webp) {
     return webp;
@@ -1395,6 +1167,21 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     counter.decrement(1);
     return new TextDecoder().decode(new Uint8Array(bytes));
   };
+  const readUntilLineEnd = () => {
+    const bytes = [];
+    while (true) {
+      if (bytesRemaining() === 0) {
+        return null;
+      }
+      const byte = getUint8();
+      bytes.push(byte);
+      if (byte === 10) {
+        break;
+      }
+    }
+    const str = new TextDecoder().decode(new Uint8Array(bytes)).trim();
+    return str;
+  };
   const getUint8 = () => {
     const val = view.getUint8(counter.getDiscardedOffset());
     counter.increment(1);
@@ -1822,6 +1609,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     readExpGolomb,
     startCheckpoint,
     getFlacCodecNumber,
+    readUntilLineEnd,
     getSyncSafeInt32
   };
 };
@@ -1975,6 +1763,11 @@ var combineUint8Arrays = (arrays) => {
   return result;
 };
 
+// src/truthy.ts
+function truthy(value) {
+  return Boolean(value);
+}
+
 // src/containers/avc/create-sps-pps-data.ts
 function serializeUint16(value) {
   const buffer = new ArrayBuffer(2);
@@ -1996,8 +1789,9 @@ var createSpsPpsData = (avc1Profile) => {
     avc1Profile.sps.sps,
     new Uint8Array([1]),
     serializeUint16(avc1Profile.pps.pps.length),
-    avc1Profile.pps.pps
-  ]);
+    avc1Profile.pps.pps,
+    [66, 77, 88].some((b) => avc1Profile.sps.spsData.profile === b) ? null : new Uint8Array([253, 248, 248, 0])
+  ].filter(truthy));
 };
 
 // src/add-avc-profile-to-track.ts
@@ -2013,29 +1807,45 @@ var addAvcProfileToTrack = (track, avc1Profile) => {
 };
 
 // src/register-track.ts
-var registerTrack = async ({
+var registerVideoTrack = async ({
   state,
   track,
   container
 }) => {
   if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
     Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
-    return;
+    return null;
   }
-  if (track.type === "video") {
-    state.callbacks.tracks.addTrack(track);
-    if (state.onVideoTrack) {
-      const callback = await state.onVideoTrack({ track, container });
-      await state.callbacks.registerVideoSampleCallback(track.trackId, callback ?? null);
-    }
+  if (track.type !== "video") {
+    throw new Error("Expected video track");
   }
-  if (track.type === "audio") {
-    state.callbacks.tracks.addTrack(track);
-    if (state.onAudioTrack) {
-      const callback = await state.onAudioTrack({ track, container });
-      await state.callbacks.registerAudioSampleCallback(track.trackId, callback ?? null);
-    }
+  state.callbacks.tracks.addTrack(track);
+  if (!state.onVideoTrack) {
+    return null;
+  }
+  const callback = await state.onVideoTrack({ track, container });
+  await state.callbacks.registerVideoSampleCallback(track.trackId, callback ?? null);
+  return callback;
+};
+var registerAudioTrack = async ({
+  state,
+  track,
+  container
+}) => {
+  if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
+    Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+    return null;
   }
+  if (track.type !== "audio") {
+    throw new Error("Expected audio track");
+  }
+  state.callbacks.tracks.addTrack(track);
+  if (!state.onAudioTrack) {
+    return null;
+  }
+  const callback = await state.onAudioTrack({ track, container });
+  await state.callbacks.registerAudioSampleCallback(track.trackId, callback ?? null);
+  return callback;
 };
 var registerVideoTrackWhenProfileIsAvailable = ({
   state,
@@ -2043,7 +1853,7 @@ var registerVideoTrackWhenProfileIsAvailable = ({
   container
 }) => {
   state.riff.registerOnAvcProfileCallback(async (profile) => {
-    await registerTrack({
+    await registerVideoTrack({
       state,
       track: addAvcProfileToTrack(track, profile),
       container
@@ -2392,6 +2202,9 @@ var isAudioStructure = (structure) => {
   if (structure.type === "riff") {
     return false;
   }
+  if (structure.type === "m3u") {
+    return false;
+  }
   throw new Error(`Unhandled structure type: ${structure}`);
 };
 
@@ -2496,6 +2309,9 @@ var getFps = (state) => {
   if (segments.type === "transport-stream") {
     return null;
   }
+  if (segments.type === "m3u") {
+    return null;
+  }
   if (segments.type === "mp3" || segments.type === "wav" || segments.type === "flac" || segments.type === "aac") {
     return null;
   }
@@ -2519,20 +2335,10 @@ var hasFps = (state) => {
   if (structure.type === "transport-stream") {
     return true;
   }
-  return hasFpsSuitedForSlowFps(state);
-};
-
-// src/containers/mp3/get-tracks-from-mp3.ts
-var getTracksFromMp3OrWavOrAac = (parserState) => {
-  const tracks2 = parserState.callbacks.tracks.getTracks();
-  if (tracks2.length === 0) {
-    throw new Error("No tracks found");
+  if (structure.type === "m3u") {
+    return true;
   }
-  return {
-    audioTracks: tracks2.filter((t) => t.type === "audio"),
-    otherTracks: [],
-    videoTracks: []
-  };
+  return hasFpsSuitedForSlowFps(state);
 };
 
 // src/containers/riff/timescale.ts
@@ -2638,11 +2444,6 @@ var hasAllTracksFromAvi = (state) => {
   }
 };
 
-// src/truthy.ts
-function truthy(value) {
-  return Boolean(value);
-}
-
 // src/containers/transport-stream/traversal.ts
 var findProgramAssociationTableOrThrow = (structure) => {
   const box = structure.boxes.find((b) => b.type === "transport-stream-pat-box");
@@ -2704,8 +2505,8 @@ var getHvc1CodecString = (data) => {
   const generalProfileSpaceTierFlagAndIdc = data.getUint8();
   let generalProfileCompatibility = data.getUint32();
   const generalProfileSpace = generalProfileSpaceTierFlagAndIdc >> 6;
-  const generalTierFlag = generalProfileSpaceTierFlagAndIdc >> 5;
-  const generalProfileIdc = generalProfileSpaceTierFlagAndIdc >> 0;
+  const generalTierFlag = (generalProfileSpaceTierFlagAndIdc & 32) >> 5;
+  const generalProfileIdc = generalProfileSpaceTierFlagAndIdc & 31;
   const generalConstraintIndicator = data.getSlice(6);
   const generalLevelIdc = data.getUint8();
   let profileId = 0;
@@ -2726,7 +2527,7 @@ var getHvc1CodecString = (data) => {
       hasByte = true;
     }
   }
-  return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${profileId.toString(16)}.${generalTierChar}${generalLevelIdc}.${generalConstraintString}`;
+  return `${profileSpaceChar}${generalProfileIdc.toString(16)}.${profileId.toString(16)}.${generalTierChar}${generalLevelIdc}${generalConstraintString ? "." : ""}${generalConstraintString}`;
 };
 
 // src/containers/webm/av1-codec-private.ts
@@ -3387,6 +3188,9 @@ var getHasTracks = (state) => {
   if (structure.type === "flac") {
     return state.callbacks.tracks.hasAllTracks();
   }
+  if (structure.type === "m3u") {
+    return state.callbacks.tracks.hasAllTracks();
+  }
   throw new Error("Unknown container " + structure);
 };
 var getTracksFromMa = (segments, state) => {
@@ -3445,6 +3249,17 @@ var getTracksFromIsoBaseMedia = (state) => {
     otherTracks
   };
 };
+var defaultGetTracks = (parserState) => {
+  const tracks2 = parserState.callbacks.tracks.getTracks();
+  if (tracks2.length === 0) {
+    throw new Error("No tracks found");
+  }
+  return {
+    audioTracks: tracks2.filter((t) => t.type === "audio"),
+    otherTracks: [],
+    videoTracks: tracks2.filter((t) => t.type === "video")
+  };
+};
 var getTracks = (state) => {
   const structure = state.getStructure();
   if (structure.type === "matroska") {
@@ -3459,8 +3274,8 @@ var getTracks = (state) => {
   if (structure.type === "transport-stream") {
     return getTracksFromTransportStream(state);
   }
-  if (structure.type === "mp3" || structure.type === "wav" || structure.type === "flac" || structure.type === "aac") {
-    return getTracksFromMp3OrWavOrAac(state);
+  if (structure.type === "mp3" || structure.type === "wav" || structure.type === "flac" || structure.type === "aac" || structure.type === "m3u") {
+    return defaultGetTracks(state);
   }
   throw new Error(`Unknown container${structure}`);
 };
@@ -4873,7 +4688,7 @@ var parseTrun = ({
   size
 }) => {
   const version = iterator.getUint8();
-  if (version !== 0) {
+  if (version !== 0 && version !== 1) {
     throw new Error(`Unsupported TRUN version ${version}`);
   }
   const flags = iterator.getUint24();
@@ -5057,8 +4872,15 @@ var processBox = async (state) => {
       state
     });
     const transformedTrack = makeBaseMediaTrack(box);
-    if (transformedTrack) {
-      await registerTrack({
+    if (transformedTrack && transformedTrack.type === "video") {
+      await registerVideoTrack({
+        state,
+        track: transformedTrack,
+        container: "mp4"
+      });
+    }
+    if (transformedTrack && transformedTrack.type === "audio") {
+      await registerAudioTrack({
         state,
         track: transformedTrack,
         container: "mp4"
@@ -5639,8 +5461,15 @@ var postprocessEbml = async ({
       track: ebml,
       timescale: state.webm.getTimescale()
     });
-    if (track) {
-      await registerTrack({
+    if (track && track.type === "audio") {
+      await registerAudioTrack({
+        state,
+        track,
+        container: "webm"
+      });
+    }
+    if (track && track.type === "video") {
+      await registerVideoTrack({
         state,
         track,
         container: "webm"
@@ -5699,6 +5528,73 @@ var postprocessEbml = async ({
   return ebml;
 };
 
+// src/containers/m3u/get-streams.ts
+var isIndependentSegments = (structure) => {
+  if (structure === null || structure.type !== "m3u") {
+    return false;
+  }
+  return structure.boxes.some((box) => box.type === "m3u-independent-segments" || box.type === "m3u-stream-info");
+};
+var getM3uStreams = (structure, originalSrc) => {
+  if (structure === null || structure.type !== "m3u") {
+    return null;
+  }
+  const boxes = [];
+  for (let i = 0;i < structure.boxes.length; i++) {
+    const str = structure.boxes[i];
+    if (str.type === "m3u-stream-info") {
+      const next = structure.boxes[i + 1];
+      if (next.type !== "m3u-text-value") {
+        throw new Error("Expected m3u-text-value");
+      }
+      const dedicatedAudioTracks = [];
+      if (str.audio) {
+        const match = structure.boxes.filter((box) => {
+          return box.type === "m3u-media-info" && box.groupId === str.audio;
+        });
+        for (const audioTrack of match) {
+          dedicatedAudioTracks.push({
+            autoselect: audioTrack.autoselect,
+            channels: audioTrack.channels,
+            default: audioTrack.default,
+            groupId: audioTrack.groupId,
+            language: audioTrack.language,
+            name: audioTrack.name,
+            url: originalSrc && originalSrc.startsWith("http") ? new URL(audioTrack.uri, originalSrc).href : audioTrack.uri
+          });
+        }
+      }
+      boxes.push({
+        url: originalSrc && originalSrc.startsWith("http") ? new URL(next.value, originalSrc).href : next.value,
+        averageBandwidth: str.averageBandwidth,
+        bandwidth: str.bandwidth,
+        codecs: str.codecs,
+        resolution: str.resolution,
+        dedicatedAudioTracks
+      });
+    }
+  }
+  if (boxes.length === 0) {
+    return null;
+  }
+  const sorted = boxes.slice().sort((a, b) => {
+    const aResolution = a.resolution ? a.resolution.width * a.resolution.height : 0;
+    const bResolution = b.resolution ? b.resolution.width * b.resolution.height : 0;
+    return bResolution - aResolution;
+  });
+  return sorted.map((box, index) => ({ ...box, id: index }));
+};
+var m3uHasStreams = (state) => {
+  const structure = state.getStructureOrNull();
+  if (!structure) {
+    return false;
+  }
+  if (structure.type !== "m3u") {
+    return true;
+  }
+  return state.m3u.hasFinishedManifest();
+};
+
 // src/get-container.ts
 var getContainer = (segments) => {
   if (segments.type === "iso-base-media") {
@@ -5728,6 +5624,9 @@ var getContainer = (segments) => {
   if (segments.type === "aac") {
     return "aac";
   }
+  if (segments.type === "m3u") {
+    return "m3u8";
+  }
   throw new Error("Unknown container " + segments);
 };
 var hasContainer = (boxes) => {
@@ -5994,6 +5893,35 @@ var getSamplePositionsFromTrack = ({
   return samplePositions;
 };
 
+// src/containers/m3u/get-playlist.ts
+var getPlaylist = (structure) => {
+  const isIndependent = isIndependentSegments(structure);
+  if (!isIndependent) {
+    return {
+      type: "m3u-playlist",
+      boxes: structure.boxes
+    };
+  }
+  const playlists = structure.boxes.filter((box) => box.type === "m3u-playlist");
+  if (playlists.length !== 1) {
+    throw new Error("Expected one playlist");
+  }
+  return playlists[0];
+};
+var getDurationFromPlaylist = (playlist) => {
+  const duration2 = playlist.boxes.filter((box) => box.type === "m3u-extinf");
+  if (duration2.length === 0) {
+    throw new Error("Expected duration in m3u playlist");
+  }
+  return duration2.reduce((acc, d) => acc + d.value, 0);
+};
+
+// src/containers/m3u/get-duration-from-m3u.ts
+var getDurationFromM3u = (structure) => {
+  const playlist = getPlaylist(structure);
+  return getDurationFromPlaylist(playlist);
+};
+
 // src/containers/mp3/get-frame-length.ts
 var getUnroundedMpegFrameLength = ({
   samplesPerFrame,
@@ -6146,6 +6074,27 @@ var getDurationFromMatroska = (segments) => {
   }
   return duration2.value.value / timestampScale2.value.value * 1000;
 };
+var isoHasDuration = (parserState) => {
+  const structure = parserState.getIsoStructure();
+  const moovBox = getMoovBox(parserState);
+  if (!moovBox) {
+    return false;
+  }
+  const mvhdBox = getMvhdBox(moovBox);
+  if (!mvhdBox) {
+    return false;
+  }
+  if (mvhdBox.type !== "mvhd-box") {
+    throw new Error("Expected mvhd-box");
+  }
+  if (mvhdBox.durationInSeconds > 0) {
+    return true;
+  }
+  const moofBoxes = getMoofBoxes(structure.boxes);
+  const hasMvex = moovBox.children.some((b) => b.type === "regular-box" && b.boxType === "mvex");
+  const isFragmented = moofBoxes.length > 0 || hasMvex;
+  return !isFragmented;
+};
 var getDurationFromIsoBaseMedia = (parserState) => {
   const structure = parserState.getIsoStructure();
   const moovBox = getMoovBox(parserState);
@@ -6207,14 +6156,24 @@ var getDuration = (parserState) => {
   if (structure.type === "flac") {
     return getDurationFromFlac(parserState);
   }
+  if (structure.type === "m3u") {
+    return getDurationFromM3u(parserState.getM3uStructure());
+  }
   throw new Error("Has no duration " + structure);
 };
 var hasDuration = (parserState) => {
+  const structure = parserState.getStructureOrNull();
+  if (structure === null) {
+    return false;
+  }
+  if (structure.type === "iso-base-media") {
+    return isoHasDuration(parserState);
+  }
   return getHasTracks(parserState);
 };
 var hasSlowDuration = (parserState) => {
   try {
-    return getDuration(parserState) !== null;
+    return hasDuration(parserState) && getDuration(parserState) !== null;
   } catch {
     return false;
   }
@@ -6485,7 +6444,7 @@ var getMetadata = (state) => {
   if (structure.type === "riff") {
     return getMetadataFromRiff(structure);
   }
-  if (structure.type === "transport-stream") {
+  if (structure.type === "transport-stream" || structure.type === "m3u") {
     return [];
   }
   if (structure.type === "mp3") {
@@ -6504,7 +6463,10 @@ var getMetadata = (state) => {
   if (structure.type === "flac") {
     return getMetadataFromFlac(structure) ?? [];
   }
-  return getMetadataFromIsoBase(state);
+  if (structure.type === "iso-base-media") {
+    return getMetadataFromIsoBase(state);
+  }
+  throw new Error("Unknown container " + structure);
 };
 var hasMetadata = (structure) => {
   if (structure.type === "mp3") {
@@ -6513,7 +6475,25 @@ var hasMetadata = (structure) => {
   if (structure.type === "wav") {
     return getMetadataFromWav(structure) !== null;
   }
-  return false;
+  if (structure.type === "m3u" || structure.type === "transport-stream") {
+    return true;
+  }
+  if (structure.type === "flac") {
+    return getMetadataFromFlac(structure) !== null;
+  }
+  if (structure.type === "iso-base-media") {
+    return false;
+  }
+  if (structure.type === "matroska") {
+    return false;
+  }
+  if (structure.type === "riff") {
+    return false;
+  }
+  if (structure.type === "aac") {
+    return true;
+  }
+  throw new Error("Unknown container " + structure);
 };
 
 // src/get-location.ts
@@ -6891,6 +6871,17 @@ var emitAvailableInfo = async ({
       }
       continue;
     }
+    if (key === "m3uStreams") {
+      if (!emittedFields.m3uStreams && hasInfo.m3uStreams) {
+        const streams = getM3uStreams(state.getStructureOrNull(), typeof state.src === "string" ? state.src : null);
+        await callbacks.onM3uStreams?.(streams);
+        if (fieldsInReturnValue.m3uStreams) {
+          returnValue.m3uStreams = streams;
+        }
+        emittedFields.m3uStreams = true;
+      }
+      continue;
+    }
     throw new Error(`Unhandled key: ${key}`);
   }
 };
@@ -6928,6 +6919,7 @@ var getFieldsFromCallback = ({
     sampleRate: Boolean(callbacks.onSampleRate),
     slowAudioBitrate: Boolean(callbacks.onSlowAudioBitrate),
     slowVideoBitrate: Boolean(callbacks.onSlowVideoBitrate),
+    m3uStreams: Boolean(callbacks.onM3uStreams),
     ...fields
   };
   return newFields;
@@ -6961,7 +6953,8 @@ var needsSamples = {
   numberOfAudioChannels: false,
   sampleRate: false,
   slowAudioBitrate: true,
-  slowVideoBitrate: true
+  slowVideoBitrate: true,
+  m3uStreams: false
 };
 var needsToIterateOverSamples = ({
   fields,
@@ -7052,6 +7045,9 @@ var getAvailableInfo = ({
     if (key === "sampleRate") {
       return hasSampleRate(state);
     }
+    if (key === "m3uStreams") {
+      return m3uHasStreams(state);
+    }
     throw new Error(`Unknown key: ${key}`);
   });
   const entries = [];
@@ -7080,7 +7076,8 @@ var hasAllInfo = ({
 class MediaParserEmitter {
   listeners = {
     pause: [],
-    resume: []
+    resume: [],
+    abort: []
   };
   addEventListener = (name, callback) => {
     this.listeners[name].push(callback);
@@ -7099,7 +7096,136 @@ class MediaParserEmitter {
   dispatchResume = () => {
     this.dispatchEvent("resume", undefined);
   };
+  dispatchAbort = (reason) => {
+    this.dispatchEvent("abort", { reason });
+  };
+}
+
+// src/errors.ts
+class IsAGifError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.fileName = "IsAGifError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAGifError);
+    }
+  }
+}
+
+class IsAnImageError extends Error {
+  imageType;
+  dimensions;
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    dimensions,
+    imageType,
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnImageError";
+    this.imageType = imageType;
+    this.dimensions = dimensions;
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnImageError);
+    }
+  }
+}
+
+class IsAPdfError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAPdfError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAPdfError);
+    }
+  }
+}
+
+class IsAnUnsupportedFileTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedFileTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
+    }
+  }
+}
+
+class IsAnUnsupportedAudioTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  audioType;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName,
+    audioType
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedAudioTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    this.audioType = audioType;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
+    }
+  }
+}
+
+class MediaParserAbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MediaParserAbortError";
+    this.cause = undefined;
+  }
 }
+var hasBeenAborted = (error) => {
+  return error instanceof MediaParserAbortError;
+};
 
 // src/pause-signal.ts
 var makePauseSignal = (emitter) => {
@@ -7143,13 +7269,14 @@ var mediaParserController = () => {
   const pauseSignal = makePauseSignal(emitter);
   const checkForAbortAndPause = async () => {
     if (abortController.signal.aborted) {
-      throw new Error("Aborted");
+      throw new MediaParserAbortError("Aborted");
     }
     await pauseSignal.waitUntilResume();
   };
   return {
     abort: (reason) => {
       abortController.abort(reason);
+      emitter.dispatchAbort(reason);
     },
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
@@ -7279,7 +7406,7 @@ var parseAac = async (state) => {
   iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
   const data = iterator.getSlice(frameLength);
   if (state.callbacks.tracks.getTracks().length === 0) {
-    await registerTrack({
+    await registerAudioTrack({
       state,
       container: "aac",
       track: {
@@ -7656,7 +7783,7 @@ var parseStreamInfo = async ({
     totalSamples
   };
   state.getFlacStructure().boxes.push(flacStreamInfo);
-  await registerTrack({
+  await registerAudioTrack({
     container: "flac",
     state,
     track: {
@@ -7814,7 +7941,8 @@ var emittedState = () => {
     numberOfAudioChannels: false,
     sampleRate: false,
     slowAudioBitrate: false,
-    slowVideoBitrate: false
+    slowVideoBitrate: false,
+    m3uStreams: false
   };
   return emittedFields;
 };
@@ -7889,6 +8017,52 @@ var eventLoopState = (logLevel) => {
   return { eventLoopBreakIfNeeded };
 };
 
+// src/state/m3u-state.ts
+var m3uState = () => {
+  let selectedStream = null;
+  let hasEmittedVideoTrack = false;
+  let hasEmittedAudioTrack = false;
+  let hasEmittedDoneWithTracks = false;
+  let hasFinishedManifest = false;
+  let readyToIterateOverM3u = false;
+  let lastChunkProcessed = -1;
+  let allChunksProcessed = false;
+  return {
+    setSelectedStream: (stream) => {
+      selectedStream = stream;
+    },
+    getSelectedStream: () => selectedStream,
+    setHasEmittedVideoTrack: (callback) => {
+      hasEmittedVideoTrack = callback;
+    },
+    hasEmittedVideoTrack: () => hasEmittedVideoTrack,
+    setHasEmittedAudioTrack: (callback) => {
+      hasEmittedAudioTrack = callback;
+    },
+    hasEmittedAudioTrack: () => hasEmittedAudioTrack,
+    setHasEmittedDoneWithTracks: () => {
+      hasEmittedDoneWithTracks = true;
+    },
+    hasEmittedDoneWithTracks: () => hasEmittedDoneWithTracks,
+    setReadyToIterateOverM3u: () => {
+      readyToIterateOverM3u = true;
+    },
+    isReadyToIterateOverM3u: () => readyToIterateOverM3u,
+    setLastChunkProcessed: (chunk) => {
+      lastChunkProcessed = chunk;
+    },
+    getLastChunkProcessed: () => lastChunkProcessed,
+    getAllChunksProcessed: () => allChunksProcessed,
+    setAllChunksProcessed: () => {
+      allChunksProcessed = true;
+    },
+    setHasFinishedManifest: () => {
+      hasFinishedManifest = true;
+    },
+    hasFinishedManifest: () => hasFinishedManifest
+  };
+};
+
 // src/state/mp3.ts
 var makeMp3State = () => {
   let mp3Info = null;
@@ -7941,7 +8115,7 @@ var needsTracksForField = ({
     }
     return true;
   }
-  if (field === "audioCodec" || field === "durationInSeconds" || field === "slowDurationInSeconds" || field === "slowFps" || field === "fps" || field === "isHdr" || field === "rotation" || field === "structure" || field === "tracks" || field === "unrotatedDimensions" || field === "videoCodec" || field === "metadata" || field === "location" || field === "slowKeyframes" || field === "slowNumberOfFrames" || field === "keyframes" || field === "images" || field === "sampleRate" || field === "numberOfAudioChannels" || field === "slowAudioBitrate" || field === "slowVideoBitrate") {
+  if (field === "audioCodec" || field === "durationInSeconds" || field === "slowDurationInSeconds" || field === "slowFps" || field === "fps" || field === "isHdr" || field === "rotation" || field === "structure" || field === "tracks" || field === "unrotatedDimensions" || field === "videoCodec" || field === "metadata" || field === "location" || field === "slowKeyframes" || field === "slowNumberOfFrames" || field === "keyframes" || field === "images" || field === "sampleRate" || field === "numberOfAudioChannels" || field === "slowAudioBitrate" || field === "slowVideoBitrate" || field === "m3uStreams") {
     return true;
   }
   if (field === "container" || field === "internalStats" || field === "mimeType" || field === "name" || field === "size") {
@@ -8224,6 +8398,13 @@ var structureState = () => {
       }
       return struc;
     },
+    getM3uStructure: () => {
+      const struc = getStructure();
+      if (struc.type !== "m3u") {
+        throw new Error("Invalid structure type");
+      }
+      return struc;
+    },
     getRiffStructure: () => {
       const struc = getStructure();
       if (struc.type !== "riff") {
@@ -8411,7 +8592,8 @@ var makeParserState = ({
   mode,
   src,
   readerInterface,
-  onDiscardedData
+  onDiscardedData,
+  selectM3uStreamFn
 }) => {
   let skippedBytes = 0;
   const iterator = getArrayBufferIterator(new Uint8Array([]), contentLength);
@@ -8441,6 +8623,7 @@ var makeParserState = ({
     mp3Info,
     aac: aacState(),
     flac: flacState(),
+    m3u: m3uState(),
     callbacks: sampleCallback({
       controller,
       hasAudioTrackHandlers,
@@ -8474,7 +8657,8 @@ var makeParserState = ({
     eventLoop: eventLoopState(logLevel),
     src,
     readerInterface,
-    discardReadBytes
+    discardReadBytes,
+    selectM3uStreamFn
   };
 };
 
@@ -8498,11 +8682,11 @@ var getMoovAtom = async ({
       structure: true
     },
     onAudioTrack: state.onAudioTrack ? async ({ track, container }) => {
-      await registerTrack({ state, track, container });
+      await registerAudioTrack({ state, track, container });
       return null;
     } : null,
     onVideoTrack: state.onVideoTrack ? async ({ track, container }) => {
-      await registerTrack({ state, track, container });
+      await registerVideoTrack({ state, track, container });
       return null;
     } : null,
     contentLength: state.contentLength,
@@ -8510,7 +8694,8 @@ var getMoovAtom = async ({
     mode: "query",
     readerInterface: state.readerInterface,
     src: state.src,
-    onDiscardedData: null
+    onDiscardedData: null,
+    selectM3uStreamFn: state.selectM3uStreamFn
   });
   while (true) {
     const result = await reader.reader.read();
@@ -8549,85 +8734,699 @@ var parseMdatSection = async (state) => {
   if (maySkipVideoData({ state })) {
     return makeSkip(endOfMdat);
   }
-  const alreadyHas = getHasTracks(state);
-  if (!alreadyHas) {
-    const moov = await getMoovAtom({
-      endOfMdat,
-      state
+  const alreadyHas = getHasTracks(state);
+  if (!alreadyHas) {
+    const moov = await getMoovAtom({
+      endOfMdat,
+      state
+    });
+    state.iso.moov.setMoovBox(moov);
+    state.callbacks.tracks.setIsDone(state.logLevel);
+    state.getIsoStructure().boxes.push(moov);
+    return parseMdatSection(state);
+  }
+  if (!state.iso.flatSamples.getSamples(videoSection.start)) {
+    state.iso.flatSamples.setSamples(videoSection.start, calculateFlatSamples(state));
+  }
+  const flatSamples = state.iso.flatSamples.getSamples(videoSection.start);
+  const { iterator } = state;
+  const samplesWithIndex = flatSamples.find((sample) => {
+    return sample.samplePosition.offset === iterator.counter.getOffset();
+  });
+  if (!samplesWithIndex) {
+    const nextSample_ = flatSamples.filter((s) => s.samplePosition.offset > iterator.counter.getOffset()).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+    if (nextSample_) {
+      iterator.discard(nextSample_.samplePosition.offset - iterator.counter.getOffset());
+      return null;
+    }
+    return makeSkip(endOfMdat);
+  }
+  if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
+    return null;
+  }
+  const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
+  const { cts, dts, duration: duration2, isKeyframe, offset } = samplesWithIndex.samplePosition;
+  if (samplesWithIndex.track.type === "audio") {
+    await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      data: bytes,
+      timestamp: cts,
+      duration: duration2,
+      cts,
+      dts,
+      trackId: samplesWithIndex.track.trackId,
+      type: isKeyframe ? "key" : "delta",
+      offset,
+      timescale: samplesWithIndex.track.timescale
+    }, samplesWithIndex.track.timescale));
+  }
+  if (samplesWithIndex.track.type === "video") {
+    const nalUnitType = bytes[4] & 31;
+    let isRecoveryPoint = false;
+    if (nalUnitType === 6) {
+      const seiType = bytes[5];
+      isRecoveryPoint = seiType === 6;
+    }
+    await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      data: bytes,
+      timestamp: cts,
+      duration: duration2,
+      cts,
+      dts,
+      trackId: samplesWithIndex.track.trackId,
+      type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
+      offset,
+      timescale: samplesWithIndex.track.timescale
+    }, samplesWithIndex.track.timescale));
+  }
+  return null;
+};
+
+// src/containers/iso-base-media/parse-boxes.ts
+var parseIsoBaseMedia = async (state) => {
+  const videoSectionState2 = state.videoSection.isInVideoSectionState(state.iterator);
+  if (videoSectionState2 === "in-section") {
+    const skipTo = await parseMdatSection(state);
+    return skipTo;
+  }
+  const result = await processBox(state);
+  if (result) {
+    state.getIsoStructure().boxes.push(result);
+  }
+  return null;
+};
+
+// src/containers/m3u/parse-stream-inf.ts
+function splitRespectingQuotes(input) {
+  const result = [];
+  let currentPart = "";
+  let insideQuote = false;
+  for (let i = 0;i < input.length; i++) {
+    const char = input[i];
+    if (char === '"') {
+      insideQuote = !insideQuote;
+      currentPart += char;
+    } else if (char === "," && !insideQuote) {
+      result.push(currentPart);
+      currentPart = "";
+    } else {
+      currentPart += char;
+    }
+  }
+  if (currentPart) {
+    result.push(currentPart);
+  }
+  return result;
+}
+var parseStreamInf = (str) => {
+  const quotes = splitRespectingQuotes(str);
+  const map = {};
+  for (const quote of quotes) {
+    const firstColon = quote.indexOf("=");
+    const key = firstColon === -1 ? quote : quote.slice(0, firstColon);
+    const value = firstColon === -1 ? null : quote.slice(firstColon + 1);
+    if (value === null) {
+      throw new Error("Value is null");
+    }
+    const actualValue = value?.startsWith('"') && value?.endsWith('"') ? value.slice(1, -1) : value;
+    map[key] = actualValue;
+  }
+  return {
+    type: "m3u-stream-info",
+    averageBandwidth: map["AVERAGE-BANDWIDTH"] ? parseInt(map["AVERAGE-BANDWIDTH"], 10) : null,
+    bandwidth: map.BANDWIDTH ? parseInt(map.BANDWIDTH, 10) : null,
+    codecs: map.CODECS ? map.CODECS.split(",") : null,
+    resolution: map.RESOLUTION ? {
+      width: parseInt(map.RESOLUTION.split("x")[0], 10),
+      height: parseInt(map.RESOLUTION.split("x")[1], 10)
+    } : null,
+    audio: map.AUDIO || null
+  };
+};
+
+// src/containers/m3u/parse-m3u-media-directive.ts
+var parseM3uMediaDirective = (str) => {
+  const quotes = splitRespectingQuotes(str);
+  const map = {};
+  for (const quote of quotes) {
+    const firstColon = quote.indexOf("=");
+    const key = firstColon === -1 ? quote : quote.slice(0, firstColon);
+    const value = firstColon === -1 ? null : quote.slice(firstColon + 1);
+    if (value === null) {
+      throw new Error("Value is null");
+    }
+    const actualValue = value?.startsWith('"') && value?.endsWith('"') ? value.slice(1, -1) : value;
+    map[key] = actualValue;
+  }
+  return {
+    type: "m3u-media-info",
+    autoselect: map.AUTOSELECT === "YES",
+    channels: map.CHANNELS ? parseInt(map.CHANNELS, 10) : null,
+    default: map.DEFAULT === "YES",
+    groupId: map["GROUP-ID"],
+    language: map.LANGUAGE || null,
+    name: map.NAME || null,
+    uri: map.URI
+  };
+};
+
+// src/containers/m3u/parse-directive.ts
+var parseM3uDirective = (str) => {
+  const firstColon = str.indexOf(":");
+  const directive = firstColon === -1 ? str : str.slice(0, firstColon);
+  const value = firstColon === -1 ? null : str.slice(firstColon + 1);
+  if (directive === "#EXT-X-VERSION") {
+    if (!value) {
+      throw new Error("EXT-X-VERSION directive must have a value");
+    }
+    return {
+      type: "m3u-version",
+      version: value
+    };
+  }
+  if (directive === "#EXT-X-INDEPENDENT-SEGMENTS") {
+    return {
+      type: "m3u-independent-segments"
+    };
+  }
+  if (directive === "#EXT-X-MEDIA") {
+    if (!value) {
+      throw new Error("EXT-X-MEDIA directive must have a value");
+    }
+    const parsed = parseM3uMediaDirective(value);
+    return parsed;
+  }
+  if (directive === "#EXT-X-TARGETDURATION") {
+    if (!value) {
+      throw new Error("EXT-X-TARGETDURATION directive must have a value");
+    }
+    return {
+      type: "m3u-target-duration",
+      duration: parseFloat(value)
+    };
+  }
+  if (directive === "#EXTINF") {
+    if (!value) {
+      throw new Error("EXTINF has no value");
+    }
+    return {
+      type: "m3u-extinf",
+      value: parseFloat(value)
+    };
+  }
+  if (directive === "#EXT-X-ENDLIST") {
+    return {
+      type: "m3u-endlist"
+    };
+  }
+  if (directive === "#EXT-X-PLAYLIST-TYPE") {
+    if (!value) {
+      throw new Error("#EXT-X-PLAYLIST-TYPE. directive must have a value");
+    }
+    return {
+      type: "m3u-playlist-type",
+      playlistType: value
+    };
+  }
+  if (directive === "#EXT-X-STREAM-INF") {
+    if (!value) {
+      throw new Error("EXT-X-STREAM-INF directive must have a value");
+    }
+    const res = parseStreamInf(value);
+    return res;
+  }
+  throw new Error(`Unknown directive ${directive}. Value: ${value}`);
+};
+
+// src/containers/m3u/parse-m3u8-text.ts
+var parseM3u8Text = (line, boxes) => {
+  if (line === "#EXTM3U") {
+    boxes.push({
+      type: "m3u-header"
+    });
+    return;
+  }
+  if (line.startsWith("#")) {
+    boxes.push(parseM3uDirective(line));
+    return;
+  }
+  if (line.trim()) {
+    boxes.push({
+      type: "m3u-text-value",
+      value: line
+    });
+  }
+};
+
+// src/containers/m3u/fetch-m3u8-stream.ts
+var fetchM3u8Stream = async (stream) => {
+  const res = await fetch(stream.url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${stream.url} (HTTP code: ${res.status})`);
+  }
+  const text = await res.text();
+  const lines = text.split(`
+`);
+  const boxes = [];
+  for (const line of lines) {
+    parseM3u8Text(line, boxes);
+  }
+  return boxes;
+};
+
+// src/forward-controller.ts
+var forwardMediaParserController = ({
+  parentController,
+  childController
+}) => {
+  const onAbort = ({ detail }) => {
+    childController.abort(detail.reason);
+  };
+  const onResume = () => {
+    childController.resume();
+  };
+  const onPause = () => {
+    childController.pause();
+  };
+  parentController.addEventListener("abort", onAbort);
+  parentController.addEventListener("resume", onResume);
+  parentController.addEventListener("pause", onPause);
+  return {
+    cleanup: () => {
+      parentController.removeEventListener("abort", onAbort);
+      parentController.removeEventListener("resume", onResume);
+      parentController.removeEventListener("pause", onPause);
+    }
+  };
+};
+
+// src/containers/m3u/select-stream.ts
+var selectStream = async ({
+  streams,
+  fn
+}) => {
+  if (streams.length < 1) {
+    throw new Error("No streams found");
+  }
+  const selectedStreamId = await fn({ streams });
+  const selectedStream = streams.find((stream) => stream.id === selectedStreamId);
+  if (!selectedStream) {
+    throw new Error(`No stream with the id ${selectedStreamId} found`);
+  }
+  return Promise.resolve(selectedStream);
+};
+var defaultSelectM3uStreamFn = ({ streams }) => {
+  return Promise.resolve(streams[0].id);
+};
+
+// src/readers/fetch/get-body-and-reader.ts
+var getLengthAndReader = async (endsWithM3u8, res, ownController) => {
+  if (endsWithM3u8) {
+    const text = await res.text();
+    const encoded = new TextEncoder().encode(text);
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoded);
+        controller.close();
+      }
+    });
+    return {
+      contentLength: encoded.byteLength,
+      reader: {
+        reader: stream.getReader(),
+        abort() {
+          ownController.abort();
+        }
+      },
+      needsContentRange: false
+    };
+  }
+  const length = res.headers.get("content-length");
+  const contentLength = length === null ? null : parseInt(length, 10);
+  if (!res.body) {
+    throw new Error("No body");
+  }
+  const reader = res.body.getReader();
+  return {
+    reader: {
+      reader,
+      abort: () => {
+        ownController.abort();
+      }
+    },
+    contentLength,
+    needsContentRange: true
+  };
+};
+
+// src/readers/fetch/resolve-url.ts
+var resolveUrl = (src) => {
+  try {
+    const resolvedUrl = typeof window !== "undefined" && typeof window.location !== "undefined" ? new URL(src, window.location.origin) : new URL(src);
+    return resolvedUrl;
+  } catch {
+    return src;
+  }
+};
+
+// src/readers/from-fetch.ts
+function parseContentRange(input) {
+  const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
+  if (!matches)
+    return null;
+  const [, unit, , start, end, size] = matches;
+  const range2 = {
+    unit,
+    start: start != null ? Number(start) : null,
+    end: end != null ? Number(end) : null,
+    size: size === "*" ? null : Number(size)
+  };
+  if (range2.start === null && range2.end === null && range2.size === null) {
+    return null;
+  }
+  return range2;
+}
+var validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange, statusCode) => {
+  if (statusCode === 206) {
+    return { supportsContentRange: true };
+  }
+  if (typeof actualRange === "number" && parsedContentRange?.start !== actualRange) {
+    if (actualRange === 0) {
+      return { supportsContentRange: false };
+    }
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  if (actualRange !== null && typeof actualRange !== "number" && (parsedContentRange?.start !== actualRange[0] || parsedContentRange?.end !== actualRange[1])) {
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  return { supportsContentRange: true };
+};
+var fetchReader = {
+  read: async ({ src, range: range2, controller }) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const resolvedUrl = resolveUrl(src);
+    const resolvedUrlString = resolvedUrl.toString();
+    if (!resolvedUrlString.startsWith("https://") && !resolvedUrlString.startsWith("blob:") && !resolvedUrlString.startsWith("http://")) {
+      return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
+    }
+    const ownController = new AbortController;
+    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
+    const actualRange = range2 === null ? 0 : range2;
+    const endsWithM3u8 = (typeof resolvedUrl === "string" ? resolvedUrl : resolvedUrl.pathname).endsWith(".m3u8");
+    const headers = actualRange === 0 && endsWithM3u8 ? {} : typeof actualRange === "number" ? {
+      Range: `bytes=${actualRange}-`
+    } : {
+      Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
+    };
+    const res = await fetch(resolvedUrl, {
+      headers,
+      signal: ownController.signal,
+      cache
+    });
+    const contentRange = res.headers.get("content-range");
+    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
+    controller._internals.signal.addEventListener("abort", () => {
+      ownController.abort(new MediaParserAbortError("Aborted by user"));
+    }, { once: true });
+    if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
+      throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
+    }
+    const contentDisposition = res.headers.get("content-disposition");
+    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
+    const fallbackName = src.split("/").pop();
+    const { contentLength, needsContentRange, reader } = await getLengthAndReader(endsWithM3u8, res, ownController);
+    if (controller) {
+      controller._internals.signal.addEventListener("abort", () => {
+        reader.reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader,
+      contentLength,
+      contentType: res.headers.get("content-type"),
+      name: name ?? fallbackName,
+      supportsContentRange,
+      needsContentRange
+    };
+  }
+};
+
+// src/parse-media.ts
+var parseMedia = (options) => {
+  return internalParseMedia({
+    fields: options.fields ?? null,
+    logLevel: options.logLevel ?? "info",
+    onAudioCodec: options.onAudioCodec ?? null,
+    onAudioTrack: options.onAudioTrack ?? null,
+    onContainer: options.onContainer ?? null,
+    onDimensions: options.onDimensions ?? null,
+    onDurationInSeconds: options.onDurationInSeconds ?? null,
+    onFps: options.onFps ?? null,
+    onImages: options.onImages ?? null,
+    onInternalStats: options.onInternalStats ?? null,
+    onIsHdr: options.onIsHdr ?? null,
+    onKeyframes: options.onKeyframes ?? null,
+    onLocation: options.onLocation ?? null,
+    onMetadata: options.onMetadata ?? null,
+    onMimeType: options.onMimeType ?? null,
+    onName: options.onName ?? null,
+    onNumberOfAudioChannels: options.onNumberOfAudioChannels ?? null,
+    onParseProgress: options.onParseProgress ?? null,
+    onRotation: options.onRotation ?? null,
+    onSampleRate: options.onSampleRate ?? null,
+    onSize: options.onSize ?? null,
+    onSlowAudioBitrate: options.onSlowAudioBitrate ?? null,
+    onSlowDurationInSeconds: options.onSlowDurationInSeconds ?? null,
+    onSlowFps: options.onSlowFps ?? null,
+    onSlowKeyframes: options.onSlowKeyframes ?? null,
+    onSlowNumberOfFrames: options.onSlowNumberOfFrames ?? null,
+    onSlowVideoBitrate: options.onSlowVideoBitrate ?? null,
+    onStructure: options.onStructure ?? null,
+    onM3uStreams: options.onM3uStreams ?? null,
+    onTracks: options.onTracks ?? null,
+    onUnrotatedDimensions: options.onUnrotatedDimensions ?? null,
+    onVideoCodec: options.onVideoCodec ?? null,
+    onVideoTrack: options.onVideoTrack ?? null,
+    progressIntervalInMs: options.progressIntervalInMs ?? null,
+    reader: options.reader ?? fetchReader,
+    controller: options.controller ?? undefined,
+    selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
+    src: options.src,
+    mode: "query",
+    onDiscardedData: null,
+    onError: () => ({ action: "fail" }),
+    acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
+    apiName: "parseMedia()"
+  });
+};
+
+// src/containers/m3u/get-chunks.ts
+var getChunks = (playlist) => {
+  const chunks = [];
+  for (let i = 0;i < playlist.boxes.length; i++) {
+    const box = playlist.boxes[i];
+    if (box.type === "m3u-extinf") {
+      const nextBox = playlist.boxes[i + 1];
+      i++;
+      if (nextBox.type !== "m3u-text-value") {
+        throw new Error("Expected m3u-text-value");
+      }
+      chunks.push({ duration: box.value, url: nextBox.value });
+    }
+    continue;
+  }
+  return chunks;
+};
+
+// src/containers/m3u/return-packets.ts
+var iteratorOverTsFiles = async ({
+  structure,
+  onVideoTrack,
+  m3uState: m3uState2,
+  onAudioTrack,
+  onDoneWithTracks,
+  playlistUrl,
+  logLevel,
+  parentController
+}) => {
+  const playlist = getPlaylist(structure);
+  const chunks = getChunks(playlist);
+  const lastChunkProcessed = m3uState2.getLastChunkProcessed();
+  const chunkIndex = lastChunkProcessed + 1;
+  const chunk = chunks[chunkIndex];
+  const isLastChunk = chunkIndex === chunks.length - 1;
+  const src = new URL(chunk.url, playlistUrl).toString();
+  const childController = mediaParserController();
+  const forwarded = forwardMediaParserController({
+    childController,
+    parentController
+  });
+  await parseMedia({
+    src,
+    acknowledgeRemotionLicense: true,
+    logLevel,
+    controller: childController,
+    onTracks: () => {
+      if (!m3uState2.hasEmittedDoneWithTracks()) {
+        m3uState2.setHasEmittedDoneWithTracks();
+        onDoneWithTracks();
+        return null;
+      }
+    },
+    onAudioTrack: async ({ track }) => {
+      const callbackOrFalse = m3uState2.hasEmittedAudioTrack();
+      if (callbackOrFalse === false) {
+        const callback = await onAudioTrack(track);
+        if (!callback) {
+          m3uState2.setHasEmittedAudioTrack(null);
+          return null;
+        }
+        m3uState2.setHasEmittedAudioTrack(callback);
+        return (sample) => {
+          return callback(sample);
+        };
+      }
+      return callbackOrFalse;
+    },
+    onVideoTrack: async ({ track }) => {
+      const callbackOrFalse = m3uState2.hasEmittedVideoTrack();
+      if (callbackOrFalse === false) {
+        const callback = await onVideoTrack(track);
+        if (!callback) {
+          m3uState2.setHasEmittedVideoTrack(null);
+          return null;
+        }
+        m3uState2.setHasEmittedVideoTrack(callback);
+        return (sample) => {
+          return callback(sample);
+        };
+      }
+      return callbackOrFalse;
+    }
+  });
+  m3uState2.setLastChunkProcessed(chunkIndex);
+  if (isLastChunk) {
+    m3uState2.setAllChunksProcessed();
+  }
+  forwarded.cleanup();
+};
+
+// src/containers/m3u/after-manifest-fetch.ts
+var afterManifestFetch = async ({
+  structure,
+  m3uState: m3uState2,
+  src,
+  selectM3uStreamFn
+}) => {
+  const independentSegments = isIndependentSegments(structure);
+  if (!independentSegments) {
+    if (!src) {
+      throw new Error("No src");
+    }
+    m3uState2.setSelectedStream({
+      type: "initial-url",
+      url: src
     });
-    state.iso.moov.setMoovBox(moov);
-    state.callbacks.tracks.setIsDone(state.logLevel);
-    state.getIsoStructure().boxes.push(moov);
-    return parseMdatSection(state);
+    return m3uState2.setReadyToIterateOverM3u();
   }
-  if (!state.iso.flatSamples.getSamples(videoSection.start)) {
-    state.iso.flatSamples.setSamples(videoSection.start, calculateFlatSamples(state));
+  const streams = getM3uStreams(structure, src);
+  if (streams === null) {
+    throw new Error("No streams found");
   }
-  const flatSamples = state.iso.flatSamples.getSamples(videoSection.start);
-  const { iterator } = state;
-  const samplesWithIndex = flatSamples.find((sample) => {
-    return sample.samplePosition.offset === iterator.counter.getOffset();
-  });
-  if (!samplesWithIndex) {
-    const nextSample_ = flatSamples.filter((s) => s.samplePosition.offset > iterator.counter.getOffset()).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
-    if (nextSample_) {
-      iterator.discard(nextSample_.samplePosition.offset - iterator.counter.getOffset());
-      return null;
-    }
-    return makeSkip(endOfMdat);
+  const selectedStream = await selectStream({ streams, fn: selectM3uStreamFn });
+  m3uState2.setSelectedStream({ type: "selected-stream", stream: selectedStream });
+  if (!selectedStream.resolution) {
+    throw new Error("Stream does not have a resolution");
   }
-  if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-    return null;
+  const boxes = await fetchM3u8Stream(selectedStream);
+  structure.boxes.push({ type: "m3u-playlist", boxes });
+  m3uState2.setReadyToIterateOverM3u();
+};
+var runOverM3u = async ({
+  state,
+  structure
+}) => {
+  const selectedStream = state.m3u.getSelectedStream();
+  if (!selectedStream) {
+    throw new Error("No stream selected");
   }
-  const bytes = iterator.getSlice(samplesWithIndex.samplePosition.size);
-  const { cts, dts, duration: duration2, isKeyframe, offset } = samplesWithIndex.samplePosition;
-  if (samplesWithIndex.track.type === "audio") {
-    await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      data: bytes,
-      timestamp: cts,
-      duration: duration2,
-      cts,
-      dts,
-      trackId: samplesWithIndex.track.trackId,
-      type: isKeyframe ? "key" : "delta",
-      offset,
-      timescale: samplesWithIndex.track.timescale
-    }, samplesWithIndex.track.timescale));
+  await iteratorOverTsFiles({
+    playlistUrl: selectedStream.type === "initial-url" ? selectedStream.url : selectedStream.stream.url,
+    structure,
+    logLevel: state.logLevel,
+    onDoneWithTracks() {
+      state.callbacks.tracks.setIsDone(state.logLevel);
+    },
+    onAudioTrack: (track) => {
+      return registerAudioTrack({
+        container: "m3u8",
+        state,
+        track
+      });
+    },
+    onVideoTrack: (track) => {
+      return registerVideoTrack({
+        container: "m3u8",
+        state,
+        track
+      });
+    },
+    m3uState: state.m3u,
+    parentController: state.controller
+  });
+};
+
+// src/containers/m3u/parse-m3u-manifest.ts
+var parseM3uManifest = ({
+  iterator,
+  structure,
+  contentLength
+}) => {
+  const start = iterator.startCheckpoint();
+  const line = iterator.readUntilLineEnd();
+  if (iterator.counter.getOffset() > contentLength) {
+    throw new Error("Unexpected end of file");
   }
-  if (samplesWithIndex.track.type === "video") {
-    const nalUnitType = bytes[4] & 31;
-    let isRecoveryPoint = false;
-    if (nalUnitType === 6) {
-      const seiType = bytes[5];
-      isRecoveryPoint = seiType === 6;
-    }
-    await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-      data: bytes,
-      timestamp: cts,
-      duration: duration2,
-      cts,
-      dts,
-      trackId: samplesWithIndex.track.trackId,
-      type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
-      offset,
-      timescale: samplesWithIndex.track.timescale
-    }, samplesWithIndex.track.timescale));
+  if (line === null) {
+    start.returnToCheckpoint();
+    return Promise.resolve(null);
   }
-  return null;
+  parseM3u8Text(line, structure.boxes);
+  return Promise.resolve(null);
 };
 
-// src/containers/iso-base-media/parse-boxes.ts
-var parseIsoBaseMedia = async (state) => {
-  const videoSectionState2 = state.videoSection.isInVideoSectionState(state.iterator);
-  if (videoSectionState2 === "in-section") {
-    const skipTo = await parseMdatSection(state);
-    return skipTo;
+// src/containers/m3u/parse-m3u.ts
+var parseM3u = async ({ state }) => {
+  const structure = state.getM3uStructure();
+  if (state.m3u.isReadyToIterateOverM3u()) {
+    await runOverM3u({
+      state,
+      structure
+    });
+    return null;
   }
-  const result = await processBox(state);
-  if (result) {
-    state.getIsoStructure().boxes.push(result);
+  if (state.m3u.hasFinishedManifest()) {
+    await afterManifestFetch({
+      structure,
+      m3uState: state.m3u,
+      src: typeof state.src === "string" ? state.src : null,
+      selectM3uStreamFn: state.selectM3uStreamFn
+    });
+    return null;
   }
-  return null;
+  const box = await parseM3uManifest({
+    iterator: state.iterator,
+    structure,
+    contentLength: state.contentLength
+  });
+  const isDoneNow = state.iterator.counter.getOffset() === state.contentLength;
+  if (isDoneNow) {
+    state.m3u.setHasFinishedManifest();
+  }
+  return box;
 };
 
 // src/containers/mp3/id3.ts
@@ -8926,7 +9725,7 @@ var parseMpegHeader = async ({
       bitrateKbit,
       startOfMpegStream: initialOffset
     });
-    await registerTrack({
+    await registerAudioTrack({
       container: "mp3",
       state,
       track: {
@@ -9274,7 +10073,7 @@ var expectRiffBox = async (state) => {
         index: state.riff.getNextTrackIndex(),
         strf: box.strf
       });
-      await registerTrack({
+      await registerAudioTrack({
         state,
         track: audioTrack,
         container: "avi"
@@ -9381,26 +10180,25 @@ var readSps = (iterator) => {
   let frame_crop_top_offset = null;
   let frame_crop_bottom_offset = null;
   let vui_parameters = null;
-  if (!(profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128 || profile === 138 || profile === 139 || profile === 134 || profile === 135)) {
-    throw new Error("Invalid profile");
-  }
-  const chromaFormat = iterator.readExpGolomb();
-  if (chromaFormat === 3) {
-    separate_colour_plane_flag = iterator.getBits(1);
-  }
-  bit_depth_luma_minus8 = iterator.readExpGolomb();
-  bit_depth_chroma_minus8 = iterator.readExpGolomb();
-  qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
-  const seq_scaling_matrix_present_flag = iterator.getBits(1);
-  const seq_scaling_list_present_flag = [];
-  if (seq_scaling_matrix_present_flag) {
-    for (let i = 0;i < (chromaFormat !== 3 ? 8 : 12); i++) {
-      seq_scaling_list_present_flag[i] = iterator.getBits(1);
-      if (seq_scaling_list_present_flag[i]) {
-        if (i < 6) {
-          throw new Error("Not implemented");
-        } else {
-          throw new Error("Not implemented");
+  if (profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128 || profile === 138 || profile === 139 || profile === 134 || profile === 135) {
+    const chromaFormat = iterator.readExpGolomb();
+    if (chromaFormat === 3) {
+      separate_colour_plane_flag = iterator.getBits(1);
+    }
+    bit_depth_luma_minus8 = iterator.readExpGolomb();
+    bit_depth_chroma_minus8 = iterator.readExpGolomb();
+    qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
+    const seq_scaling_matrix_present_flag = iterator.getBits(1);
+    const seq_scaling_list_present_flag = [];
+    if (seq_scaling_matrix_present_flag) {
+      for (let i = 0;i < (chromaFormat !== 3 ? 8 : 12); i++) {
+        seq_scaling_list_present_flag[i] = iterator.getBits(1);
+        if (seq_scaling_list_present_flag[i]) {
+          if (i < 6) {
+            throw new Error("Not implemented");
+          } else {
+            throw new Error("Not implemented");
+          }
         }
       }
     }
@@ -9742,6 +10540,20 @@ var parsePat = (iterator) => {
   discardRestOfPacket(iterator);
   return tables;
 };
+var parseSdt = (iterator) => {
+  iterator.startReadingBits();
+  iterator.getBits(8);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(2);
+  const sectionLength = iterator.getBits(12);
+  iterator.stopReadingBits();
+  iterator.discard(sectionLength);
+  discardRestOfPacket(iterator);
+  return {
+    type: "transport-stream-sdt-box"
+  };
+};
 
 // src/containers/transport-stream/parse-pes.ts
 var parsePes = (iterator) => {
@@ -9935,9 +10747,10 @@ var readAdtsHeader = (buffer) => {
 };
 
 // src/containers/transport-stream/find-separator.ts
-function findSubarrayIndex(array, subarray) {
+function findNthSubarrayIndex(array, subarray, n) {
   const subarrayLength = subarray.length;
   const arrayLength = array.length;
+  let count = 0;
   for (let i = 0;i <= arrayLength - subarrayLength; i++) {
     let match = true;
     for (let j = 0;j < subarrayLength; j++) {
@@ -9947,28 +10760,22 @@ function findSubarrayIndex(array, subarray) {
       }
     }
     if (match) {
-      if (subarray[i - 1] === 0) {
-        i--;
+      count++;
+      if (count === n) {
+        return i;
       }
-      return i;
     }
   }
   return -1;
 }
-var findNextSeparator = (restOfPacket, transportStreamEntry) => {
-  if (transportStreamEntry.streamType === 27) {
-    return findSubarrayIndex(restOfPacket, new Uint8Array([0, 0, 1, 9]));
-  }
-  throw new Error(`Unsupported stream ID ${transportStreamEntry.streamType}`);
-};
 
 // src/containers/avc/interpret-sps.ts
 var getDimensionsFromSps = (sps) => {
   const height = sps.pic_height_in_map_units_minus1;
   const width = sps.pic_width_in_mbs_minus1;
   return {
-    height: (height + 1) * 16,
-    width: (width + 1) * 16
+    height: (height + 1) * 16 - (sps.frame_crop_bottom_offset ?? 0) * 2 - (sps.frame_crop_top_offset ?? 0) * 2,
+    width: (width + 1) * 16 - (sps.frame_crop_right_offset ?? 0) * 2 - (sps.frame_crop_left_offset ?? 0) * 2
   };
 };
 var getSampleAspectRatioFromSps = (sps) => {
@@ -10044,7 +10851,7 @@ var handleAvcPacket = async ({
       },
       color: getVideoColorFromSps(spsAndPps.sps.spsData)
     };
-    await registerTrack({ track, state, container: "transport-stream" });
+    await registerVideoTrack({ track, state, container: "transport-stream" });
   }
   const sample = {
     cts: streamBuffer.pesHeader.pts,
@@ -10088,7 +10895,7 @@ var handleAacPacket = async ({
       numberOfChannels: channelConfiguration,
       sampleRate
     };
-    await registerTrack({
+    await registerAudioTrack({
       track,
       state,
       container: "transport-stream"
@@ -10161,36 +10968,35 @@ var processFinalStreamBuffers = async ({
 
 // src/containers/transport-stream/parse-stream-packet.ts
 var parseAdtsStream = async ({
-  restOfPacket,
   transportStreamEntry,
   state,
   structure,
   offset
 }) => {
   const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-  if (!streamBuffer) {
-    streamBuffers.set(transportStreamEntry.pid, {
-      buffer: restOfPacket,
-      pesHeader: nextPesHeader.getNextPesHeader(),
-      offset
-    });
-    return;
-  }
-  const expectedLength = readAdtsHeader(streamBuffer.buffer)?.frameLength ?? null;
-  const bytesToTake = expectedLength ? Math.min(restOfPacket.length, expectedLength - streamBuffer.buffer.byteLength) : restOfPacket.length;
-  streamBuffer.buffer = combineUint8Arrays([
-    streamBuffer.buffer,
-    restOfPacket.slice(0, bytesToTake)
-  ]);
-  if (expectedLength === streamBuffer.buffer.byteLength) {
+  while (true) {
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    if (!streamBuffer) {
+      throw new Error("Stream buffer not found");
+    }
+    const expectedLength = readAdtsHeader(streamBuffer.buffer)?.frameLength ?? null;
+    if (expectedLength === null) {
+      break;
+    }
+    if (expectedLength > streamBuffer.buffer.length) {
+      break;
+    }
     await processStreamBuffer({
-      streamBuffer,
+      streamBuffer: {
+        buffer: streamBuffer.buffer.slice(0, expectedLength),
+        offset,
+        pesHeader: streamBuffer.pesHeader
+      },
       programId: transportStreamEntry.pid,
       state,
       structure
     });
-    const rest = restOfPacket.slice(bytesToTake);
+    const rest = streamBuffer.buffer.slice(expectedLength);
     streamBuffers.set(transportStreamEntry.pid, {
       buffer: rest,
       pesHeader: nextPesHeader.getNextPesHeader(),
@@ -10199,82 +11005,91 @@ var parseAdtsStream = async ({
   }
 };
 var parseAvcStream = async ({
-  restOfPacket,
-  transportStreamEntry,
   programId,
   state,
   structure,
-  offset
+  streamBuffer
 }) => {
-  const indexOfSeparator = findNextSeparator(restOfPacket, transportStreamEntry);
-  const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-  if (indexOfSeparator === -1) {
-    if (streamBuffer) {
-      streamBuffer.buffer = combineUint8Arrays([
-        streamBuffer.buffer,
-        restOfPacket
-      ]);
-      return;
-    }
-    streamBuffers.set(programId, {
-      pesHeader: nextPesHeader.getNextPesHeader(),
-      buffer: restOfPacket,
-      offset
-    });
-    return;
-  }
-  if (streamBuffer) {
-    const packet = restOfPacket.slice(0, indexOfSeparator);
-    streamBuffer.buffer = combineUint8Arrays([streamBuffer.buffer, packet]);
-    await processStreamBuffer({
-      state,
-      streamBuffer,
-      programId,
-      structure
-    });
-    const rest = restOfPacket.slice(indexOfSeparator);
-    streamBuffers.set(programId, {
-      pesHeader: nextPesHeader.getNextPesHeader(),
-      buffer: rest,
-      offset
-    });
-    return;
-  }
-  if (indexOfSeparator !== 0) {
-    throw new Error("No stream buffer found but new separator is not at the beginning");
+  const indexOfSeparator = findNthSubarrayIndex(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
+  if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+    return null;
   }
-  streamBuffers.set(programId, {
-    pesHeader: nextPesHeader.getNextPesHeader(),
-    buffer: restOfPacket.slice(indexOfSeparator),
-    offset
+  const packet = streamBuffer.buffer.slice(0, indexOfSeparator);
+  const rest = streamBuffer.buffer.slice(indexOfSeparator);
+  await processStreamBuffer({
+    state,
+    streamBuffer: {
+      offset: streamBuffer.offset,
+      pesHeader: streamBuffer.pesHeader,
+      buffer: packet
+    },
+    programId,
+    structure
   });
+  return rest;
 };
-var parseStream = ({
+var parseStream = async ({
   transportStreamEntry,
   state,
   programId,
   structure
 }) => {
   const { iterator } = state;
-  const restOfPacket = getRestOfPacket(iterator);
+  let restOfPacket = getRestOfPacket(iterator);
+  const offset = iterator.counter.getOffset();
   if (transportStreamEntry.streamType === 27) {
-    return parseAvcStream({
-      restOfPacket,
-      transportStreamEntry,
-      state,
-      programId,
-      structure,
-      offset: iterator.counter.getOffset()
-    });
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
+    while (true) {
+      if (!streamBuffers.has(transportStreamEntry.pid)) {
+        streamBuffers.set(programId, {
+          pesHeader: nextPesHeader.getNextPesHeader(),
+          buffer: new Uint8Array([]),
+          offset
+        });
+      }
+      const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+      streamBuffer.buffer = combineUint8Arrays([
+        streamBuffer.buffer,
+        restOfPacket
+      ]);
+      const rest = await parseAvcStream({
+        state,
+        programId,
+        structure,
+        streamBuffer: streamBuffers.get(transportStreamEntry.pid)
+      });
+      if (rest !== null) {
+        streamBuffers.delete(transportStreamEntry.pid);
+        if (rest.length === 0) {
+          break;
+        }
+        restOfPacket = rest;
+      } else {
+        break;
+      }
+    }
+    return;
   }
   if (transportStreamEntry.streamType === 15) {
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    if (!streamBuffer) {
+      streamBuffers.set(transportStreamEntry.pid, {
+        buffer: restOfPacket,
+        pesHeader: nextPesHeader.getNextPesHeader(),
+        offset
+      });
+    } else {
+      streamBuffer.buffer = combineUint8Arrays([
+        streamBuffer.buffer,
+        restOfPacket
+      ]);
+    }
     return parseAdtsStream({
-      restOfPacket,
       transportStreamEntry,
       state,
       structure,
-      offset: iterator.counter.getOffset()
+      offset
     });
   }
   throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
@@ -10335,7 +11150,10 @@ var parsePacket = async ({
   if (programId === 0) {
     return Promise.resolve(parsePat(iterator));
   }
-  const program = getProgramForId(structure, programId);
+  if (programId === 17) {
+    return Promise.resolve(parseSdt(iterator));
+  }
+  const program = programId === 17 ? null : getProgramForId(structure, programId);
   if (program) {
     const pmt = parsePmt(iterator);
     return Promise.resolve(pmt);
@@ -10426,7 +11244,7 @@ var parseFmt = async ({
     type: "wav-fmt"
   };
   state.getWavStructure().boxes.push(wavHeader);
-  await registerTrack({
+  await registerAudioTrack({
     state,
     track: {
       type: "audio",
@@ -10764,6 +11582,14 @@ var initVideo = ({
     });
     return;
   }
+  if (fileType.type === "m3u") {
+    Log.verbose(state.logLevel, "Detected M3U");
+    state.setStructure({
+      type: "m3u",
+      boxes: []
+    });
+    return;
+  }
   if (fileType.type === "gif") {
     return Promise.reject(new IsAGifError({
       message: "GIF files are not yet supported",
@@ -10808,10 +11634,13 @@ var runParseIteration = async ({
   contentLength,
   name
 }) => {
+  const structure = state.getStructureOrNull();
+  if (structure && structure.type === "m3u") {
+    return parseM3u({ state });
+  }
   if (state.iterator.bytesRemaining() === 0) {
     return Promise.reject(new Error("no bytes"));
   }
-  const structure = state.getStructureOrNull();
   if (structure === null) {
     await initVideo({ state, mimeType, name, contentLength });
     return null;
@@ -10906,6 +11735,7 @@ var internalParseMedia = async function({
   onError,
   acknowledgeRemotionLicense,
   apiName,
+  selectM3uStream: selectM3uStreamFn,
   ...more
 }) {
   warnIfRemotionLicenseNotAcknowledged({
@@ -10918,17 +11748,19 @@ var internalParseMedia = async function({
     fields: fieldsInReturnValue,
     callbacks: more
   });
+  Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src.name}`);
   const {
     reader: readerInstance,
     contentLength,
     name,
     contentType,
-    supportsContentRange
+    supportsContentRange,
+    needsContentRange
   } = await readerInterface.read({ src, range: null, controller });
   if (contentLength === null) {
     throw new Error('Cannot read media without a content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.');
   }
-  if (!supportsContentRange) {
+  if (!supportsContentRange && needsContentRange) {
     throw new Error('Cannot read media without it supporting the "Content-Range" header. This is currently not supported. Ensure the media supports the "Content-Range" HTTP header.');
   }
   const hasAudioTrackHandlers = Boolean(onAudioTrack);
@@ -10954,7 +11786,8 @@ var internalParseMedia = async function({
     mode,
     readerInterface,
     src,
-    onDiscardedData
+    onDiscardedData,
+    selectM3uStreamFn
   });
   const { iterator } = state;
   let currentReader = readerInstance;
@@ -10994,6 +11827,9 @@ var internalParseMedia = async function({
       return true;
     }
     if (state.iterator.counter.getOffset() === contentLength) {
+      if (state.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessed()) {
+        return false;
+      }
       Log.verbose(logLevel, "Reached end of file");
       await state.discardReadBytes(true);
       return true;
@@ -11037,7 +11873,7 @@ var internalParseMedia = async function({
     }));
     if (!errored) {
       Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength} (0x${iterator.counter.getOffset().toString(16)})`);
-      if (iterationWithThisOffset > 300) {
+      if (iterationWithThisOffset > 300 && state.getStructure().type !== "m3u") {
         throw new Error("Infinite loop detected. The parser is not progressing. This is likely a bug in the parser. You can report this at https://remotion.dev/report and we will fix it as soon as possible.");
       }
       try {
@@ -11135,6 +11971,7 @@ var downloadAndParseMedia = async (options) => {
     onAudioTrack: null,
     onContainer: options.onContainer ?? null,
     onDimensions: options.onDimensions ?? null,
+    selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
     onDiscardedData: async (data) => {
       await content.write(data);
     },
@@ -11160,6 +11997,7 @@ var downloadAndParseMedia = async (options) => {
     onSlowNumberOfFrames: options.onSlowNumberOfFrames ?? null,
     onSlowVideoBitrate: options.onSlowVideoBitrate ?? null,
     onStructure: options.onStructure ?? null,
+    onM3uStreams: options.onM3uStreams ?? null,
     onTracks: options.onTracks ?? null,
     onUnrotatedDimensions: options.onUnrotatedDimensions ?? null,
     onVideoCodec: options.onVideoCodec ?? null,
@@ -11183,54 +12021,8 @@ var downloadAndParseMedia = async (options) => {
   await content.finish();
   return returnValue;
 };
-// src/parse-media.ts
-var parseMedia = (options) => {
-  return internalParseMedia({
-    fields: options.fields ?? null,
-    logLevel: options.logLevel ?? "info",
-    onAudioCodec: options.onAudioCodec ?? null,
-    onAudioTrack: options.onAudioTrack ?? null,
-    onContainer: options.onContainer ?? null,
-    onDimensions: options.onDimensions ?? null,
-    onDurationInSeconds: options.onDurationInSeconds ?? null,
-    onFps: options.onFps ?? null,
-    onImages: options.onImages ?? null,
-    onInternalStats: options.onInternalStats ?? null,
-    onIsHdr: options.onIsHdr ?? null,
-    onKeyframes: options.onKeyframes ?? null,
-    onLocation: options.onLocation ?? null,
-    onMetadata: options.onMetadata ?? null,
-    onMimeType: options.onMimeType ?? null,
-    onName: options.onName ?? null,
-    onNumberOfAudioChannels: options.onNumberOfAudioChannels ?? null,
-    onParseProgress: options.onParseProgress ?? null,
-    onRotation: options.onRotation ?? null,
-    onSampleRate: options.onSampleRate ?? null,
-    onSize: options.onSize ?? null,
-    onSlowAudioBitrate: options.onSlowAudioBitrate ?? null,
-    onSlowDurationInSeconds: options.onSlowDurationInSeconds ?? null,
-    onSlowFps: options.onSlowFps ?? null,
-    onSlowKeyframes: options.onSlowKeyframes ?? null,
-    onSlowNumberOfFrames: options.onSlowNumberOfFrames ?? null,
-    onSlowVideoBitrate: options.onSlowVideoBitrate ?? null,
-    onStructure: options.onStructure ?? null,
-    onTracks: options.onTracks ?? null,
-    onUnrotatedDimensions: options.onUnrotatedDimensions ?? null,
-    onVideoCodec: options.onVideoCodec ?? null,
-    onVideoTrack: options.onVideoTrack ?? null,
-    progressIntervalInMs: options.progressIntervalInMs ?? null,
-    reader: options.reader ?? fetchReader,
-    controller: options.controller ?? undefined,
-    src: options.src,
-    mode: "query",
-    onDiscardedData: null,
-    onError: () => ({ action: "fail" }),
-    acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
-    apiName: "parseMedia()"
-  });
-};
 // src/version.ts
-var VERSION = "4.0.265";
+var VERSION = "4.0.267";
 
 // src/index.ts
 var MediaParserInternals = {
@@ -11253,6 +12045,7 @@ export {
   mediaParserController,
   hasBeenAborted,
   downloadAndParseMedia,
+  defaultSelectM3uStreamFn,
   VERSION,
   MediaParserInternals,
   MediaParserAbortError,