@remotion/media-parser 4.0.268 → 4.0.270

package/dist/esm/index.mjs

@@ -5824,20 +5824,21 @@ var getM3uStreams = (structure, originalSrc) => {
       if (next.type !== "m3u-text-value") {
         throw new Error("Expected m3u-text-value");
       }
-      const dedicatedAudioTracks = [];
+      const associatedPlaylists = [];
       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({
+          associatedPlaylists.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
+            url: originalSrc && originalSrc.startsWith("http") ? new URL(audioTrack.uri, originalSrc).href : audioTrack.uri,
+            id: associatedPlaylists.length
           });
         }
       }
@@ -5847,7 +5848,7 @@ var getM3uStreams = (structure, originalSrc) => {
         bandwidth: str.bandwidth,
         codecs: str.codecs,
         resolution: str.resolution,
-        dedicatedAudioTracks
+        associatedPlaylists
       });
     }
   }
@@ -5857,6 +5858,11 @@ var getM3uStreams = (structure, originalSrc) => {
   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;
+    if (aResolution === bResolution) {
+      const bandwidthA = a.averageBandwidth ?? a.bandwidth ?? 0;
+      const bandwidthB = b.averageBandwidth ?? b.bandwidth ?? 0;
+      return bandwidthB - bandwidthA;
+    }
     return bResolution - aResolution;
   });
   return sorted.map((box, index) => ({ ...box, id: index }));
@@ -6171,19 +6177,30 @@ var getSamplePositionsFromTrack = ({
 };
 
 // src/containers/m3u/get-playlist.ts
-var getPlaylist = (structure) => {
+var getAllPlaylists = ({
+  structure,
+  src
+}) => {
   const isIndependent = isIndependentSegments(structure);
   if (!isIndependent) {
-    return {
-      type: "m3u-playlist",
-      boxes: structure.boxes
-    };
+    return [
+      {
+        type: "m3u-playlist",
+        boxes: structure.boxes,
+        src
+      }
+    ];
   }
   const playlists = structure.boxes.filter((box) => box.type === "m3u-playlist");
-  if (playlists.length !== 1) {
-    throw new Error("Expected one playlist");
+  return playlists;
+};
+var getPlaylist = (structure, src) => {
+  const allPlaylists = getAllPlaylists({ structure, src });
+  const playlists = allPlaylists.find((box) => box.src === src);
+  if (!playlists) {
+    throw new Error(`Expected m3u-playlist with src ${src}`);
   }
-  return playlists[0];
+  return playlists;
 };
 var getDurationFromPlaylist = (playlist) => {
   const duration2 = playlist.boxes.filter((box) => box.type === "m3u-extinf");
@@ -6194,9 +6211,14 @@ var getDurationFromPlaylist = (playlist) => {
 };
 
 // src/containers/m3u/get-duration-from-m3u.ts
-var getDurationFromM3u = (structure) => {
-  const playlist = getPlaylist(structure);
-  return getDurationFromPlaylist(playlist);
+var getDurationFromM3u = (state) => {
+  const playlists = getAllPlaylists({
+    structure: state.getM3uStructure(),
+    src: state.src
+  });
+  return Math.max(...playlists.map((p) => {
+    return getDurationFromPlaylist(p);
+  }));
 };
 
 // src/containers/mp3/get-frame-length.ts
@@ -6435,7 +6457,7 @@ var getDuration = (parserState) => {
     return getDurationFromFlac(parserState);
   }
   if (structure.type === "m3u") {
-    return getDurationFromM3u(parserState.getM3uStructure());
+    return getDurationFromM3u(parserState);
   }
   throw new Error("Has no duration " + structure);
 };
@@ -8300,49 +8322,171 @@ var eventLoopState = (logLevel) => {
   return { eventLoopBreakIfNeeded };
 };
 
+// src/containers/m3u/sample-sorter.ts
+var sampleSorter = ({
+  logLevel,
+  getAllChunksProcessedForPlaylist
+}) => {
+  const streamsWithTracks = [];
+  const audioCallbacks = {};
+  const videoCallbacks = {};
+  const latestSample = {};
+  return {
+    addToStreamWithTrack: (src) => {
+      streamsWithTracks.push(src);
+    },
+    addVideoStreamToConsider: (src, callback) => {
+      videoCallbacks[src] = callback;
+    },
+    addAudioStreamToConsider: (src, callback) => {
+      audioCallbacks[src] = callback;
+    },
+    addAudioSample: async (src, sample) => {
+      const callback = audioCallbacks[src];
+      if (!callback) {
+        throw new Error("No callback found for audio sample");
+      }
+      latestSample[src] = sample.dts;
+      await callback(sample);
+    },
+    addVideoSample: async (src, sample) => {
+      const callback = videoCallbacks[src];
+      if (!callback) {
+        throw new Error("No callback found for audio sample");
+      }
+      latestSample[src] = sample.dts;
+      await callback(sample);
+    },
+    getNextStreamToRun: (streams) => {
+      for (const stream of streams) {
+        if (!streamsWithTracks.includes(stream)) {
+          Log.trace(logLevel, `Did not yet detect track of ${stream}, working on that`);
+          return stream;
+        }
+      }
+      let smallestDts = Infinity;
+      for (const stream of streams) {
+        if (getAllChunksProcessedForPlaylist(stream)) {
+          continue;
+        }
+        if ((latestSample[stream] ?? 0) < smallestDts) {
+          smallestDts = latestSample[stream] ?? 0;
+        }
+      }
+      for (const stream of streams) {
+        if ((latestSample[stream] ?? 0) === smallestDts) {
+          Log.trace(logLevel, `Working on ${stream} because it has the smallest DTS`);
+          return stream;
+        }
+      }
+      throw new Error("should be done with parsing now");
+    }
+  };
+};
+
 // src/state/m3u-state.ts
-var m3uState = () => {
-  let selectedStream = null;
-  let hasEmittedVideoTrack = false;
-  let hasEmittedAudioTrack = false;
-  let hasEmittedDoneWithTracks = false;
+var m3uState = (logLevel) => {
+  let selectedMainPlaylist = null;
+  let associatedPlaylists = null;
+  const hasEmittedVideoTrack = {};
+  const hasEmittedAudioTrack = {};
+  const hasEmittedDoneWithTracks = {};
   let hasFinishedManifest = false;
   let readyToIterateOverM3u = false;
-  let lastChunkProcessed = -1;
-  let allChunksProcessed = false;
+  const allChunksProcessed = {};
+  const m3uStreamRuns = {};
+  const tracksDone = {};
+  const getMainPlaylistUrl = () => {
+    if (!selectedMainPlaylist) {
+      throw new Error("No main playlist selected");
+    }
+    const playlistUrl = selectedMainPlaylist.type === "initial-url" ? selectedMainPlaylist.url : selectedMainPlaylist.stream.url;
+    return playlistUrl;
+  };
+  const getSelectedPlaylists = () => {
+    return [
+      getMainPlaylistUrl(),
+      ...(associatedPlaylists ?? []).map((p) => p.url)
+    ];
+  };
+  const getAllChunksProcessedForPlaylist = (src) => allChunksProcessed[src];
   return {
-    setSelectedStream: (stream) => {
-      selectedStream = stream;
+    setSelectedMainPlaylist: (stream) => {
+      selectedMainPlaylist = stream;
+    },
+    getSelectedMainPlaylist: () => selectedMainPlaylist,
+    setHasEmittedVideoTrack: (src, callback) => {
+      hasEmittedVideoTrack[src] = callback;
+    },
+    hasEmittedVideoTrack: (src) => {
+      const value = hasEmittedVideoTrack[src];
+      if (value === undefined) {
+        return false;
+      }
+      return value;
     },
-    getSelectedStream: () => selectedStream,
-    setHasEmittedVideoTrack: (callback) => {
-      hasEmittedVideoTrack = callback;
+    setHasEmittedAudioTrack: (src, callback) => {
+      hasEmittedAudioTrack[src] = callback;
     },
-    hasEmittedVideoTrack: () => hasEmittedVideoTrack,
-    setHasEmittedAudioTrack: (callback) => {
-      hasEmittedAudioTrack = callback;
+    hasEmittedAudioTrack: (src) => {
+      const value = hasEmittedAudioTrack[src];
+      if (value === undefined) {
+        return false;
+      }
+      return value;
     },
-    hasEmittedAudioTrack: () => hasEmittedAudioTrack,
-    setHasEmittedDoneWithTracks: () => {
-      hasEmittedDoneWithTracks = true;
+    setHasEmittedDoneWithTracks: (src) => {
+      hasEmittedDoneWithTracks[src] = true;
     },
-    hasEmittedDoneWithTracks: () => hasEmittedDoneWithTracks,
+    hasEmittedDoneWithTracks: (src) => hasEmittedDoneWithTracks[src],
     setReadyToIterateOverM3u: () => {
       readyToIterateOverM3u = true;
     },
     isReadyToIterateOverM3u: () => readyToIterateOverM3u,
-    setLastChunkProcessed: (chunk) => {
-      lastChunkProcessed = chunk;
+    setAllChunksProcessed: (src) => {
+      allChunksProcessed[src] = true;
     },
-    getLastChunkProcessed: () => lastChunkProcessed,
-    getAllChunksProcessed: () => allChunksProcessed,
-    setAllChunksProcessed: () => {
-      allChunksProcessed = true;
+    getAllChunksProcessedForPlaylist,
+    getAllChunksProcessedOverall: () => {
+      if (!selectedMainPlaylist) {
+        return false;
+      }
+      const selectedPlaylists = getSelectedPlaylists();
+      return selectedPlaylists.every((url) => allChunksProcessed[url]);
     },
     setHasFinishedManifest: () => {
       hasFinishedManifest = true;
     },
-    hasFinishedManifest: () => hasFinishedManifest
+    hasFinishedManifest: () => hasFinishedManifest,
+    setM3uStreamRun: (playlistUrl, run) => {
+      if (!run) {
+        delete m3uStreamRuns[playlistUrl];
+        return;
+      }
+      m3uStreamRuns[playlistUrl] = run;
+    },
+    setTracksDone: (playlistUrl) => {
+      tracksDone[playlistUrl] = true;
+      const selectedPlaylists = getSelectedPlaylists();
+      return selectedPlaylists.every((url) => tracksDone[url]);
+    },
+    getM3uStreamRun: (playlistUrl) => m3uStreamRuns[playlistUrl] ?? null,
+    abortM3UStreamRuns: () => {
+      const values = Object.values(m3uStreamRuns);
+      if (values.length === 0) {
+        return;
+      }
+      Log.trace(logLevel, `Aborting ${values.length} M3U stream runs`);
+      values.forEach((run) => {
+        run.abort();
+      });
+    },
+    setAssociatedPlaylists: (playlists) => {
+      associatedPlaylists = playlists;
+    },
+    getAssociatedPlaylists: () => associatedPlaylists,
+    getSelectedPlaylists,
+    sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist })
   };
 };
 
@@ -8890,7 +9034,8 @@ var makeParserState = ({
   src,
   readerInterface,
   onDiscardedData,
-  selectM3uStreamFn
+  selectM3uStreamFn,
+  selectM3uAssociatedPlaylistsFn
 }) => {
   let skippedBytes = 0;
   const iterator = getArrayBufferIterator(new Uint8Array([]), contentLength);
@@ -8920,7 +9065,7 @@ var makeParserState = ({
     mp3Info,
     aac: aacState(),
     flac: flacState(),
-    m3u: m3uState(),
+    m3u: m3uState(logLevel),
     callbacks: sampleCallback({
       controller,
       hasAudioTrackHandlers,
@@ -8955,7 +9100,8 @@ var makeParserState = ({
     src,
     readerInterface,
     discardReadBytes,
-    selectM3uStreamFn
+    selectM3uStreamFn,
+    selectM3uAssociatedPlaylistsFn
   };
 };
 
@@ -8992,7 +9138,8 @@ var getMoovAtom = async ({
     readerInterface: state.readerInterface,
     src: state.src,
     onDiscardedData: null,
-    selectM3uStreamFn: state.selectM3uStreamFn
+    selectM3uStreamFn: state.selectM3uStreamFn,
+    selectM3uAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn
   });
   while (true) {
     const result = await reader.reader.read();
@@ -9189,7 +9336,7 @@ var parseM3uMediaDirective = (str) => {
 // src/containers/m3u/parse-directive.ts
 var parseM3uDirective = (str) => {
   const firstColon = str.indexOf(":");
-  const directive = firstColon === -1 ? str : str.slice(0, firstColon);
+  const directive = (firstColon === -1 ? str : str.slice(0, firstColon)).trim();
   const value = firstColon === -1 ? null : str.slice(firstColon + 1);
   if (directive === "#EXT-X-VERSION") {
     if (!value) {
@@ -9244,6 +9391,24 @@ var parseM3uDirective = (str) => {
       playlistType: value
     };
   }
+  if (directive === "#EXT-X-MEDIA-SEQUENCE") {
+    if (!value) {
+      throw new Error("#EXT-X-MEDIA-SEQUENCE directive must have a value");
+    }
+    return {
+      type: "m3u-media-sequence",
+      value: Number(value)
+    };
+  }
+  if (directive === "#EXT-X-DISCONTINUITY-SEQUENCE") {
+    if (!value) {
+      throw new Error("#EXT-X-DISCONTINUITY-SEQUENCE directive must have a value");
+    }
+    return {
+      type: "m3u-discontinuity-sequence",
+      value: Number(value)
+    };
+  }
   if (directive === "#EXT-X-STREAM-INF") {
     if (!value) {
       throw new Error("EXT-X-STREAM-INF directive must have a value");
@@ -9251,6 +9416,15 @@ var parseM3uDirective = (str) => {
     const res = parseStreamInf(value);
     return res;
   }
+  if (directive === "#EXT-X-MAP") {
+    if (!value) {
+      throw new Error("#EXT-X-MAP directive must have a value");
+    }
+    return {
+      type: "m3u-map",
+      value: Number(value)
+    };
+  }
   throw new Error(`Unknown directive ${directive}. Value: ${value}`);
 };
 
@@ -9275,21 +9449,134 @@ var parseM3u8Text = (line, boxes) => {
 };
 
 // src/containers/m3u/fetch-m3u8-stream.ts
-var fetchM3u8Stream = async (stream) => {
-  const res = await fetch(stream.url);
+var fetchM3u8Stream = async (url) => {
+  const res = await fetch(url);
   if (!res.ok) {
-    throw new Error(`Failed to fetch ${stream.url} (HTTP code: ${res.status})`);
+    throw new Error(`Failed to fetch ${url} (HTTP code: ${res.status})`);
   }
   const text = await res.text();
   const lines = text.split(`
 `);
   const boxes = [];
   for (const line of lines) {
-    parseM3u8Text(line, boxes);
+    parseM3u8Text(line.trim(), boxes);
   }
   return boxes;
 };
 
+// src/containers/m3u/select-stream.ts
+var selectAssociatedPlaylists = async ({
+  playlists,
+  fn
+}) => {
+  if (playlists.length < 1) {
+    return Promise.resolve([]);
+  }
+  const streams = await fn({ associatedPlaylists: playlists });
+  if (!Array.isArray(streams)) {
+    throw new Error("Expected an array of associated playlists");
+  }
+  for (const stream of streams) {
+    if (!playlists.find((playlist) => playlist.url === stream.url)) {
+      throw new Error(`The associated playlist ${JSON.stringify(streams)} cannot be selected because it was not in the list of selectable playlists`);
+    }
+  }
+  return streams;
+};
+var defaultSelectM3uAssociatedPlaylists = ({ associatedPlaylists }) => {
+  return Promise.resolve(associatedPlaylists.filter((playlist) => playlist.default));
+};
+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/containers/m3u/after-manifest-fetch.ts
+var afterManifestFetch = async ({
+  structure,
+  m3uState: m3uState2,
+  src,
+  selectM3uStreamFn,
+  logLevel,
+  selectAssociatedPlaylists: selectAssociatedPlaylistsFn
+}) => {
+  const independentSegments = isIndependentSegments(structure);
+  if (!independentSegments) {
+    if (!src) {
+      throw new Error("No src");
+    }
+    m3uState2.setSelectedMainPlaylist({
+      type: "initial-url",
+      url: src
+    });
+    return m3uState2.setReadyToIterateOverM3u();
+  }
+  const streams = getM3uStreams(structure, src);
+  if (streams === null) {
+    throw new Error("No streams found");
+  }
+  const selectedPlaylist = await selectStream({ streams, fn: selectM3uStreamFn });
+  if (!selectedPlaylist.resolution) {
+    throw new Error("Stream does not have a resolution");
+  }
+  m3uState2.setSelectedMainPlaylist({
+    type: "selected-stream",
+    stream: selectedPlaylist
+  });
+  const associatedPlaylists = await selectAssociatedPlaylists({
+    playlists: selectedPlaylist.associatedPlaylists,
+    fn: selectAssociatedPlaylistsFn
+  });
+  m3uState2.setAssociatedPlaylists(associatedPlaylists);
+  const playlistUrls = [
+    selectedPlaylist.url,
+    ...associatedPlaylists.map((p) => p.url)
+  ];
+  const struc = await Promise.all(playlistUrls.map(async (url) => {
+    Log.verbose(logLevel, `Fetching playlist ${url}`);
+    const boxes = await fetchM3u8Stream(url);
+    return {
+      type: "m3u-playlist",
+      boxes,
+      src: url
+    };
+  }));
+  structure.boxes.push(...struc);
+  m3uState2.setReadyToIterateOverM3u();
+};
+
+// 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 (line === null) {
+    start.returnToCheckpoint();
+    return Promise.resolve(null);
+  }
+  parseM3u8Text(line.trim(), structure.boxes);
+  return Promise.resolve(null);
+};
+
 // src/forward-controller.ts
 var forwardMediaParserController = ({
   parentController,
@@ -9316,25 +9603,6 @@ var forwardMediaParserController = ({
   };
 };
 
-// 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 ({
   canLiveWithoutContentLength,
@@ -9531,6 +9799,7 @@ var parseMedia = (options) => {
     reader: options.reader ?? fetchReader,
     controller: options.controller ?? undefined,
     selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
+    selectM3uAssociatedPlaylists: options.selectM3uAssociatedPlaylists ?? defaultSelectM3uAssociatedPlaylists,
     src: options.src,
     mode: "query",
     onDiscardedData: null,
@@ -9567,161 +9836,198 @@ var iteratorOverTsFiles = async ({
   onDoneWithTracks,
   playlistUrl,
   logLevel,
-  parentController
+  parentController,
+  onInitialProgress
 }) => {
-  const playlist = getPlaylist(structure);
+  const playlist = getPlaylist(structure, playlistUrl);
   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();
+  let resolver = onInitialProgress;
+  let rejector = (_e) => {
+  };
   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);
-        };
+  const makeContinuationFn = () => {
+    return {
+      continue() {
+        const { promise, reject, resolve } = Promise.withResolvers();
+        resolver = resolve;
+        rejector = reject;
+        childController.resume();
+        return promise;
+      },
+      abort() {
+        childController.abort();
       }
-      return callbackOrFalse;
-    },
-    onVideoTrack: async ({ track }) => {
-      const callbackOrFalse = m3uState2.hasEmittedVideoTrack();
-      if (callbackOrFalse === false) {
-        const callback = await onVideoTrack(track);
-        if (!callback) {
-          m3uState2.setHasEmittedVideoTrack(null);
-          return null;
+    };
+  };
+  for (const chunk of chunks) {
+    const isLastChunk = chunk === chunks[chunks.length - 1];
+    await childController._internals.checkForAbortAndPause();
+    const src = new URL(chunk.url, playlistUrl).toString();
+    try {
+      await parseMedia({
+        src,
+        acknowledgeRemotionLicense: true,
+        logLevel,
+        controller: childController,
+        progressIntervalInMs: 0,
+        onParseProgress: () => {
+          childController.pause();
+          resolver(makeContinuationFn());
+        },
+        onTracks: () => {
+          if (!m3uState2.hasEmittedDoneWithTracks(playlistUrl)) {
+            m3uState2.setHasEmittedDoneWithTracks(playlistUrl);
+            onDoneWithTracks();
+            return null;
+          }
+        },
+        onAudioTrack: async ({ track }) => {
+          const callbackOrFalse = m3uState2.hasEmittedAudioTrack(playlistUrl);
+          if (callbackOrFalse === false) {
+            const callback = await onAudioTrack(track);
+            if (!callback) {
+              m3uState2.setHasEmittedAudioTrack(playlistUrl, null);
+              return null;
+            }
+            m3uState2.setHasEmittedAudioTrack(playlistUrl, callback);
+            return (sample) => {
+              return callback(sample);
+            };
+          }
+          return callbackOrFalse;
+        },
+        onVideoTrack: async ({ track }) => {
+          const callbackOrFalse = m3uState2.hasEmittedVideoTrack(playlistUrl);
+          if (callbackOrFalse === false) {
+            const callback = await onVideoTrack(track);
+            if (!callback) {
+              m3uState2.setHasEmittedVideoTrack(playlistUrl, null);
+              return null;
+            }
+            m3uState2.setHasEmittedVideoTrack(playlistUrl, callback);
+            return (sample) => {
+              return callback(sample);
+            };
+          }
+          return callbackOrFalse;
         }
-        m3uState2.setHasEmittedVideoTrack(callback);
-        return (sample) => {
-          return callback(sample);
-        };
-      }
-      return callbackOrFalse;
+      });
+    } catch (e) {
+      rejector(e);
+      throw e;
     }
-  });
-  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");
+    forwarded.cleanup();
+    if (!isLastChunk) {
+      childController.pause();
+      resolver(makeContinuationFn());
     }
-    m3uState2.setSelectedStream({
-      type: "initial-url",
-      url: src
-    });
-    return m3uState2.setReadyToIterateOverM3u();
-  }
-  const streams = getM3uStreams(structure, src);
-  if (streams === null) {
-    throw new Error("No streams found");
-  }
-  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");
   }
-  const boxes = await fetchM3u8Stream(selectedStream);
-  structure.boxes.push({ type: "m3u-playlist", boxes });
-  m3uState2.setReadyToIterateOverM3u();
+  resolver(null);
 };
+
+// src/containers/m3u/run-over-m3u.ts
 var runOverM3u = async ({
   state,
-  structure
-}) => {
-  const selectedStream = state.m3u.getSelectedStream();
-  if (!selectedStream) {
-    throw new Error("No stream selected");
-  }
-  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
+  playlistUrl,
+  logLevel
 }) => {
-  const start = iterator.startCheckpoint();
-  const line = iterator.readUntilLineEnd();
-  if (iterator.counter.getOffset() > contentLength) {
-    throw new Error("Unexpected end of file");
-  }
-  if (line === null) {
-    start.returnToCheckpoint();
-    return Promise.resolve(null);
+  const existingRun = state.m3u.getM3uStreamRun(playlistUrl);
+  if (existingRun) {
+    Log.trace(logLevel, "Existing M3U parsing process found for", playlistUrl);
+    const run = await existingRun.continue();
+    state.m3u.setM3uStreamRun(playlistUrl, run);
+    if (!run) {
+      state.m3u.setAllChunksProcessed(playlistUrl);
+    }
+    return;
   }
-  parseM3u8Text(line, structure.boxes);
-  return Promise.resolve(null);
+  Log.trace(logLevel, "Starting new M3U parsing process for", playlistUrl);
+  return new Promise((resolve, reject) => {
+    const run = iteratorOverTsFiles({
+      playlistUrl,
+      structure,
+      onInitialProgress: (newRun) => {
+        state.m3u.setM3uStreamRun(playlistUrl, newRun);
+        resolve();
+      },
+      logLevel: state.logLevel,
+      onDoneWithTracks() {
+        const allDone = state.m3u.setTracksDone(playlistUrl);
+        if (allDone) {
+          state.callbacks.tracks.setIsDone(state.logLevel);
+        }
+      },
+      onAudioTrack: async (track) => {
+        const existingTracks = state.callbacks.tracks.getTracks();
+        let { trackId } = track;
+        while (existingTracks.find((t) => t.trackId === trackId)) {
+          trackId++;
+        }
+        const onAudioSample = await registerAudioTrack({
+          container: "m3u8",
+          state,
+          track: {
+            ...track,
+            trackId
+          }
+        });
+        state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+        if (onAudioSample === null) {
+          return null;
+        }
+        state.m3u.sampleSorter.addAudioStreamToConsider(playlistUrl, onAudioSample);
+        return async (sample) => {
+          await state.m3u.sampleSorter.addAudioSample(playlistUrl, sample);
+        };
+      },
+      onVideoTrack: async (track) => {
+        const existingTracks = state.callbacks.tracks.getTracks();
+        let { trackId } = track;
+        while (existingTracks.find((t) => t.trackId === trackId)) {
+          trackId++;
+        }
+        const onVideoSample = await registerVideoTrack({
+          container: "m3u8",
+          state,
+          track: {
+            ...track,
+            trackId
+          }
+        });
+        state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+        if (onVideoSample === null) {
+          return null;
+        }
+        state.m3u.sampleSorter.addVideoStreamToConsider(playlistUrl, onVideoSample);
+        return async (sample) => {
+          await state.m3u.sampleSorter.addVideoSample(playlistUrl, sample);
+        };
+      },
+      m3uState: state.m3u,
+      parentController: state.controller
+    });
+    run.catch((err) => {
+      reject(err);
+    });
+  });
 };
 
 // src/containers/m3u/parse-m3u.ts
 var parseM3u = async ({ state }) => {
   const structure = state.getM3uStructure();
   if (state.m3u.isReadyToIterateOverM3u()) {
+    const selectedPlaylists = state.m3u.getSelectedPlaylists();
+    const whichPlaylistToRunOver = state.m3u.sampleSorter.getNextStreamToRun(selectedPlaylists);
     await runOverM3u({
       state,
-      structure
+      structure,
+      playlistUrl: whichPlaylistToRunOver,
+      logLevel: state.logLevel
     });
     return null;
   }
@@ -9730,7 +10036,9 @@ var parseM3u = async ({ state }) => {
       structure,
       m3uState: state.m3u,
       src: typeof state.src === "string" ? state.src : null,
-      selectM3uStreamFn: state.selectM3uStreamFn
+      selectM3uStreamFn: state.selectM3uStreamFn,
+      logLevel: state.logLevel,
+      selectAssociatedPlaylists: state.selectM3uAssociatedPlaylistsFn
     });
     return null;
   }
@@ -11411,7 +11719,12 @@ var parseList = ({
     throw new Error(`Only supporting LIST INFO, but got ${type}`);
   }
   const metadata = [];
-  while (iterator.counter.getOffset() < startOffset + ckSize) {
+  const remainingBytes = () => ckSize - (iterator.counter.getOffset() - startOffset);
+  while (remainingBytes() > 0) {
+    if (remainingBytes() < 4) {
+      iterator.discard(remainingBytes());
+      break;
+    }
     const key = iterator.getByteString(4, false);
     const size = iterator.getUint32Le();
     const value = iterator.getByteString(size, true);
@@ -11802,21 +12115,33 @@ var throttledStateUpdate = ({
     updateFn(currentState);
     lastUpdated = currentState;
   };
-  const interval = setInterval(() => {
-    callUpdateIfChanged();
-  }, everyMilliseconds);
-  const onAbort = () => {
-    clearInterval(interval);
+  let cleanup = () => {
   };
-  controller._internals.signal.addEventListener("abort", onAbort, { once: true });
+  if (everyMilliseconds > 0) {
+    const interval = setInterval(() => {
+      callUpdateIfChanged();
+    }, everyMilliseconds);
+    const onAbort = () => {
+      clearInterval(interval);
+    };
+    controller._internals.signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    cleanup = () => {
+      clearInterval(interval);
+      controller._internals.signal.removeEventListener("abort", onAbort);
+    };
+  }
   return {
     get: () => currentState,
     update: (fn) => {
       currentState = fn(currentState);
+      if (everyMilliseconds === 0) {
+        callUpdateIfChanged();
+      }
     },
     stopAndGetLastProgress: () => {
-      clearInterval(interval);
-      controller._internals.signal.removeEventListener("abort", onAbort);
+      cleanup();
       return currentState;
     }
   };
@@ -11839,6 +12164,7 @@ var internalParseMedia = async function({
   acknowledgeRemotionLicense,
   apiName,
   selectM3uStream: selectM3uStreamFn,
+  selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn,
   ...more
 }) {
   warnIfRemotionLicenseNotAcknowledged({
@@ -11890,7 +12216,8 @@ var internalParseMedia = async function({
     readerInterface,
     src,
     onDiscardedData,
-    selectM3uStreamFn
+    selectM3uStreamFn,
+    selectM3uAssociatedPlaylistsFn
   });
   const { iterator } = state;
   let currentReader = readerInstance;
@@ -11930,7 +12257,7 @@ var internalParseMedia = async function({
       return true;
     }
     if (state.iterator.counter.getOffset() === contentLength) {
-      if (state.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessed()) {
+      if (state.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
         return false;
       }
       Log.verbose(logLevel, "Reached end of file");
@@ -12053,6 +12380,7 @@ var internalParseMedia = async function({
   currentReader.abort();
   iterator?.destroy();
   state.callbacks.tracks.ensureHasTracksAtEnd(fields);
+  state.m3u.abortM3UStreamRuns();
   if (errored) {
     throw errored;
   }
@@ -12075,6 +12403,7 @@ var downloadAndParseMedia = async (options) => {
     onContainer: options.onContainer ?? null,
     onDimensions: options.onDimensions ?? null,
     selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
+    selectM3uAssociatedPlaylists: options.selectM3uAssociatedPlaylists ?? defaultSelectM3uAssociatedPlaylists,
     onDiscardedData: async (data) => {
       await content.write(data);
     },
@@ -12125,7 +12454,7 @@ var downloadAndParseMedia = async (options) => {
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.268";
+var VERSION = "4.0.270";
 
 // src/index.ts
 var MediaParserInternals = {
@@ -12149,6 +12478,7 @@ export {
   hasBeenAborted,
   downloadAndParseMedia,
   defaultSelectM3uStreamFn,
+  defaultSelectM3uAssociatedPlaylists,
   VERSION,
   MediaParserInternals,
   MediaParserAbortError,