@remotion/media-parser 4.0.290 → 4.0.291

package/dist/esm/worker-server-entry.mjs

@@ -98,6 +98,40 @@ class MediaParserAbortError extends Error {
   }
 }
 
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
 // src/readers/fetch/get-body-and-reader.ts
 var getLengthAndReader = async ({
   canLiveWithoutContentLength,
@@ -110,10 +144,22 @@ var getLengthAndReader = async ({
   if (requestedWithoutRange || canLiveWithoutContentLength && contentLength === null) {
     const buffer = await res.arrayBuffer();
     const encoded = new Uint8Array(buffer);
+    let streamCancelled = false;
     const stream = new ReadableStream({
       start(controller) {
-        controller.enqueue(encoded);
-        controller.close();
+        if (ownController.signal.aborted) {
+          return;
+        }
+        if (streamCancelled) {
+          return;
+        }
+        try {
+          controller.enqueue(encoded);
+          controller.close();
+        } catch {}
+      },
+      cancel() {
+        streamCancelled = true;
       }
     });
     return {
@@ -189,14 +235,11 @@ var validateContentRangeAndDetectIfSupported = ({
   }
   return { supportsContentRange: true };
 };
-var fetchReadContent = async ({
-  src,
+var makeFetchRequest = async ({
   range,
+  src,
   controller
 }) => {
-  if (typeof src !== "string" && src instanceof URL === false) {
-    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://")) {
@@ -225,21 +268,83 @@ var fetchReadContent = async ({
     parsedContentRange,
     statusCode: res.status
   });
-  controller._internals.signal.addEventListener("abort", () => {
-    ownController.abort(new MediaParserAbortError("Aborted by user"));
-  }, { once: true });
+  if (controller) {
+    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 ${requestedRange}`);
+    throw new Error(`Server returned status code ${res.status} for ${resolvedUrl} and range ${requestedRange}`);
   }
   const contentDisposition = res.headers.get("content-disposition");
   const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
-  const fallbackName = src.toString().split("/").pop();
   const { contentLength, needsContentRange, reader } = await getLengthAndReader({
     canLiveWithoutContentLength,
     res,
     ownController,
     requestedWithoutRange: requestWithoutRange
   });
+  const contentType = res.headers.get("content-type");
+  return {
+    contentLength,
+    needsContentRange,
+    reader,
+    name,
+    contentType,
+    supportsContentRange
+  };
+};
+var cacheKey = ({
+  src,
+  range
+}) => {
+  return `${src}-${JSON.stringify(range)}`;
+};
+var makeFetchRequestOrGetCached = ({
+  range,
+  src,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  const key = cacheKey({ src, range });
+  const cached = prefetchCache.get(key);
+  if (cached) {
+    Log.verbose(logLevel, `Reading from preload cache for ${key}`);
+    return cached;
+  }
+  Log.verbose(logLevel, `Fetching ${key}`);
+  const result = makeFetchRequest({ range, src, controller });
+  prefetchCache.set(key, result);
+  return result;
+};
+var fetchReadContent = async ({
+  src,
+  range,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const fallbackName = src.toString().split("/").pop();
+  const {
+    reader,
+    contentLength,
+    needsContentRange,
+    name,
+    supportsContentRange,
+    contentType
+  } = await makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller,
+    logLevel,
+    prefetchCache
+  });
+  const key = cacheKey({ src, range });
+  prefetchCache.delete(key);
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.reader.cancel().catch(() => {});
@@ -248,12 +353,33 @@ var fetchReadContent = async ({
   return {
     reader,
     contentLength,
-    contentType: res.headers.get("content-type"),
+    contentType,
     name: name ?? fallbackName,
     supportsContentRange,
     needsContentRange
   };
 };
+var fetchPreload = ({
+  src,
+  range,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const key = cacheKey({ src, range });
+  if (prefetchCache.has(key)) {
+    return prefetchCache.get(key);
+  }
+  makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller: null,
+    logLevel,
+    prefetchCache
+  });
+};
 var fetchReadWholeAsText = async (src) => {
   if (typeof src !== "string" && src instanceof URL === false) {
     throw new Error("src must be a string when using `fetchReader`");
@@ -274,7 +400,6 @@ var fetchCreateAdjacentFileSource = (relativePath, src) => {
 // src/readers/from-node.ts
 import { createReadStream, promises, statSync } from "fs";
 import { dirname, join, relative, sep } from "path";
-import { Readable } from "stream";
 var nodeReadContent = ({ src, range, controller }) => {
   if (typeof src !== "string") {
     throw new Error("src must be a string when using `nodeReader`");
@@ -289,7 +414,27 @@ var nodeReadContent = ({ src, range, controller }) => {
     ownController.abort();
   }, { once: true });
   const stats = statSync(src);
-  const reader = Readable.toWeb(stream).getReader();
+  let readerCancelled = false;
+  const reader = new ReadableStream({
+    start(c) {
+      if (readerCancelled) {
+        return;
+      }
+      stream.on("data", (chunk) => {
+        c.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        c.close();
+      });
+      stream.on("error", (err) => {
+        c.error(err);
+      });
+    },
+    cancel() {
+      readerCancelled = true;
+      stream.destroy();
+    }
+  }).getReader();
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.cancel().catch(() => {});
@@ -405,12 +550,21 @@ var universalReader = {
       return fetchCreateAdjacentFileSource(relativePath, src);
     }
     return nodeCreateAdjacentFileSource(relativePath, src);
+  },
+  preload: ({ src, range, logLevel, prefetchCache }) => {
+    if (src instanceof Blob) {
+      return;
+    }
+    if (src.toString().startsWith("http") || src.toString().startsWith("blob:")) {
+      return fetchPreload({ range, src, logLevel, prefetchCache });
+    }
   }
 };
 // src/containers/m3u/select-stream.ts
 var selectAssociatedPlaylists = async ({
   playlists,
-  fn
+  fn,
+  skipAudioTracks
 }) => {
   if (playlists.length < 1) {
     return Promise.resolve([]);
@@ -419,12 +573,17 @@ var selectAssociatedPlaylists = async ({
   if (!Array.isArray(streams)) {
     throw new Error("Expected an array of associated playlists");
   }
+  const selectedStreams = [];
   for (const stream of streams) {
+    if (stream.isAudio && skipAudioTracks) {
+      continue;
+    }
     if (!playlists.find((playlist) => playlist.src === stream.src)) {
       throw new Error(`The associated playlist ${JSON.stringify(streams)} cannot be selected because it was not in the list of selectable playlists`);
     }
+    selectedStreams.push(stream);
   }
-  return streams;
+  return selectedStreams;
 };
 var defaultSelectM3uAssociatedPlaylists = ({ associatedPlaylists }) => {
   if (associatedPlaylists.length === 1) {
@@ -596,7 +755,11 @@ var mediaParserController = () => {
   const performedSeeksSignal = performedSeeksStats();
   const checkForAbortAndPause = async () => {
     if (abortController.signal.aborted) {
-      throw new MediaParserAbortError("Aborted");
+      const err = new MediaParserAbortError("Aborted");
+      if (abortController.signal.reason) {
+        err.cause = abortController.signal.reason;
+      }
+      throw err;
     }
     await pauseSignal.waitUntilResume();
   };
@@ -618,7 +781,7 @@ var mediaParserController = () => {
       abortController.abort(reason);
       emitter.dispatchAbort(reason);
     },
-    _experimentalSeek: seekSignal.seek,
+    seek: seekSignal.seek,
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
@@ -672,7 +835,8 @@ var getM3uStreams = ({
             language: audioTrack.language,
             name: audioTrack.name,
             src: readerInterface.createAdjacentFileSource(audioTrack.uri, originalSrc),
-            id: associatedPlaylists.length
+            id: associatedPlaylists.length,
+            isAudio: true
           });
         }
       }
@@ -1033,7 +1197,7 @@ var getFpsFromIsoMaseMedia = (state) => {
   const moovBox = getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    mp4HeaderSegment: state.m3uPlaylistContext?.mp4HeaderSegment ?? null,
     mayUsePrecomputed: true
   });
   if (!moovBox) {
@@ -2192,40 +2356,6 @@ var detectFileType = (data) => {
   return { type: "unknown" };
 };
 
-// src/log.ts
-var logLevels = ["trace", "verbose", "info", "warn", "error"];
-var getNumberForLogLevel = (level) => {
-  return logLevels.indexOf(level);
-};
-var isEqualOrBelowLogLevel = (currentLevel, level) => {
-  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-var Log = {
-  trace: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
-      return console.log(...args);
-    }
-  },
-  verbose: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
-      return console.log(...args);
-    }
-  },
-  info: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "info")) {
-      return console.log(...args);
-    }
-  },
-  warn: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
-      return console.warn(...args);
-    }
-  },
-  error: (...args) => {
-    return console.error(...args);
-  }
-};
-
 // src/iterator/buffer-manager.ts
 var bufferManager = ({
   initialData,
@@ -2403,7 +2533,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       const six = getUint8();
       const seven = getUint8();
       const eight = getUint8();
-      return eight << 56 | seven << 48 | six << 40 | five << 32 | four << 24 | three << 16 | two << 8 | one;
+      return (eight << 56 | seven << 48 | six << 40 | five << 32 | four << 24 | three << 16 | two << 8 | one) >>> 0;
     }
     function byteArrayToBigInt(byteArray) {
       let result = BigInt(0);
@@ -2425,7 +2555,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     return Number(bigInt);
   };
   const getFourByteNumber = () => {
-    return getUint8() << 24 | getUint8() << 16 | getUint8() << 8 | getUint8();
+    const unsigned = getUint8() << 24 | getUint8() << 16 | getUint8() << 8 | getUint8();
+    return unsigned >>> 0;
   };
   const getPaddedFourByteNumber = () => {
     let lastInt = 128;
@@ -4091,7 +4222,7 @@ var isoBaseMediaHasTracks = (state, mayUsePrecomputed) => {
   return Boolean(getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    mp4HeaderSegment: state.m3uPlaylistContext?.mp4HeaderSegment ?? null,
     mayUsePrecomputed
   }));
 };
@@ -4176,11 +4307,16 @@ var getTracksFromMoovBox = (moovBox) => {
     otherTracks
   };
 };
-var getTracksFromIsoBaseMedia = (state, mayUsePrecomputed) => {
+var getTracksFromIsoBaseMedia = ({
+  mayUsePrecomputed,
+  structure,
+  isoState,
+  m3uPlaylistContext
+}) => {
   const moovBox = getMoovBoxFromState({
-    structureState: state.structure,
-    isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    structureState: structure,
+    isoState,
+    mp4HeaderSegment: m3uPlaylistContext?.mp4HeaderSegment ?? null,
     mayUsePrecomputed
   });
   if (!moovBox) {
@@ -4209,7 +4345,12 @@ var getTracks = (state, mayUsePrecomputed) => {
     return getCategorizedTracksFromMatroska(state);
   }
   if (structure.type === "iso-base-media") {
-    return getTracksFromIsoBaseMedia(state, mayUsePrecomputed);
+    return getTracksFromIsoBaseMedia({
+      isoState: state.iso,
+      m3uPlaylistContext: state.m3uPlaylistContext,
+      structure: state.structure,
+      mayUsePrecomputed
+    });
   }
   if (structure.type === "riff") {
     return getTracksFromAvi(structure, state);
@@ -4415,6 +4556,9 @@ var getAudioCodecFromAudioCodecInfo = (codec) => {
   if (codec.format === "ac-3") {
     return "ac3";
   }
+  if (codec.format === "Opus") {
+    return "opus";
+  }
   if (codec.format === "mp4a") {
     if (codec.primarySpecificator === 64) {
       return "aac";
@@ -4597,11 +4741,15 @@ var collectSamplePositionsFromMoofBoxes = ({
   tkhdBox
 }) => {
   const isComplete = tfraBoxes.length > 0 && tfraBoxes.every((t) => t.entries.length === moofBoxes.length);
-  const samplePositions = moofBoxes.map((m) => {
-    return getSamplesFromMoof({
-      moofBox: m,
-      trackId: tkhdBox.trackId
-    });
+  const samplePositions = moofBoxes.map((m, index) => {
+    const isLastFragment = index === moofBoxes.length - 1 && isComplete;
+    return {
+      isLastFragment,
+      samples: getSamplesFromMoof({
+        moofBox: m,
+        trackId: tkhdBox.trackId
+      })
+    };
   });
   return { samplePositions, isComplete };
 };
@@ -4634,14 +4782,14 @@ var getSamplePositions = ({
   const samples = [];
   let samplesPerChunk = 1;
   for (let i = 0;i < chunks.length; i++) {
-    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
-    if (hasEntry) {
-      samplesPerChunk = hasEntry.samplesPerChunk;
+    const hasEntry = stscBox.entries.get(i + 1);
+    if (hasEntry !== undefined) {
+      samplesPerChunk = hasEntry;
     }
     let offsetInThisChunk = 0;
     for (let j = 0;j < samplesPerChunk; j++) {
       const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
-      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
+      const isKeyframe = stssBox ? stssBox.sampleNumber.has(samples.length + 1) : true;
       const delta = sttsDeltas[samples.length];
       const ctsOffset = cttsEntries[samples.length];
       const cts = dts + ctsOffset;
@@ -4685,11 +4833,16 @@ var getGroupedSamplesPositionsFromMp4 = ({
   }
   const samples = [];
   let timestamp = 0;
+  const stscKeys = Array.from(stscBox.entries.keys());
   for (let i = 0;i < stcoBox.entries.length; i++) {
     const entry = stcoBox.entries[i];
     const chunk = i + 1;
-    const stscEntry = stscBox.entries.findLast((e) => e.firstChunk <= chunk);
-    if (!stscEntry) {
+    const stscEntry = stscKeys.findLast((e) => e <= chunk);
+    if (stscEntry === undefined) {
+      throw new Error("should not be");
+    }
+    const samplesPerChunk = stscBox.entries.get(stscEntry);
+    if (samplesPerChunk === undefined) {
       throw new Error("should not be");
     }
     samples.push({
@@ -4697,13 +4850,13 @@ var getGroupedSamplesPositionsFromMp4 = ({
       cts: timestamp,
       dts: timestamp,
       offset: Number(entry),
-      size: stszBox.sampleSize * stscEntry.samplesPerChunk,
-      duration: stscEntry.samplesPerChunk,
+      size: stszBox.sampleSize * samplesPerChunk,
+      duration: samplesPerChunk,
       isKeyframe: true,
       bigEndian,
       chunkSize: stszBox.sampleSize
     });
-    timestamp += stscEntry.samplesPerChunk;
+    timestamp += samplesPerChunk;
   }
   return samples;
 };
@@ -4780,7 +4933,7 @@ var getSamplePositionsFromTrack = ({
       tkhdBox
     });
     return {
-      samplePositions: samplePositions.flat(1),
+      samplePositions: samplePositions.map((s) => s.samples).flat(1),
       isComplete
     };
   }
@@ -5014,7 +5167,7 @@ var getDurationFromIsoBaseMedia = (parserState) => {
   const moovBox = getMoovBoxFromState({
     structureState: parserState.structure,
     isoState: parserState.iso,
-    mp4HeaderSegment: parserState.mp4HeaderSegment,
+    mp4HeaderSegment: parserState.m3uPlaylistContext?.mp4HeaderSegment ?? null,
     mayUsePrecomputed: true
   });
   if (!moovBox) {
@@ -5120,7 +5273,12 @@ var hasHdr = (state) => {
 
 // src/containers/iso-base-media/get-keyframes.ts
 var getKeyframesFromIsoBaseMedia = (state) => {
-  const { videoTracks } = getTracksFromIsoBaseMedia(state, true);
+  const { videoTracks } = getTracksFromIsoBaseMedia({
+    isoState: state.iso,
+    m3uPlaylistContext: state.m3uPlaylistContext,
+    structure: state.structure,
+    mayUsePrecomputed: true
+  });
   const structure = state.structure.getIsoStructure();
   const moofBoxes = getMoofBoxes(structure.boxes);
   const tfraBoxes = getTfraBoxes(structure);
@@ -5274,7 +5432,7 @@ var getMetadataFromIsoBase = (state) => {
   const moov = getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    mp4HeaderSegment: state.m3uPlaylistContext?.mp4HeaderSegment ?? null,
     mayUsePrecomputed: true
   });
   if (!moov) {
@@ -5540,6 +5698,75 @@ var getSeekingByteForFlac = ({
   return null;
 };
 
+// src/containers/iso-base-media/find-keyframe-before-time.ts
+var findKeyframeBeforeTime = ({
+  samplePositions,
+  time,
+  timescale,
+  mediaSections,
+  logLevel
+}) => {
+  let videoByte = 0;
+  let videoSample = null;
+  for (const sample of samplePositions) {
+    const ctsInSeconds = sample.cts / timescale;
+    const dtsInSeconds = sample.dts / timescale;
+    if (!sample.isKeyframe) {
+      continue;
+    }
+    if (!(ctsInSeconds <= time || dtsInSeconds <= time)) {
+      continue;
+    }
+    if (videoByte <= sample.offset) {
+      videoByte = sample.offset;
+      videoSample = sample;
+    }
+  }
+  if (!videoSample) {
+    throw new Error("No sample found");
+  }
+  const mediaSection = mediaSections.find((section) => videoSample.offset >= section.start && videoSample.offset < section.start + section.size);
+  if (!mediaSection) {
+    Log.trace(logLevel, "Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.", videoSample);
+    return null;
+  }
+  return videoSample.offset;
+};
+
+// src/containers/iso-base-media/find-track-to-seek.ts
+var findAnyTrackWithSamplePositions = (allTracks, struc) => {
+  for (const track of allTracks) {
+    if (track.type === "video" || track.type === "audio") {
+      const { samplePositions } = getSamplePositionsFromTrack({
+        trakBox: track.trakBox,
+        moofBoxes: getMoofBoxes(struc.boxes),
+        tfraBoxes: getTfraBoxes(struc)
+      });
+      if (samplePositions.length === 0) {
+        continue;
+      }
+      return { track, samplePositions };
+    }
+  }
+  return null;
+};
+var findTrackToSeek = (allTracks, structure) => {
+  const firstVideoTrack = allTracks.find((t) => t.type === "video");
+  const struc = structure.getIsoStructure();
+  if (!firstVideoTrack) {
+    return findAnyTrackWithSamplePositions(allTracks, struc);
+  }
+  const { samplePositions } = getSamplePositionsFromTrack({
+    trakBox: firstVideoTrack.trakBox,
+    moofBoxes: getMoofBoxes(struc.boxes),
+    tfraBoxes: getTfraBoxes(struc)
+  });
+  if (samplePositions.length === 0) {
+    return findAnyTrackWithSamplePositions(allTracks, struc);
+  }
+  return { track: firstVideoTrack, samplePositions };
+};
+
 // src/state/video-section.ts
 var isByteInMediaSection = ({
   position,
@@ -5608,42 +5835,13 @@ var mediaSectionState = () => {
   };
 };
 
-// src/containers/iso-base-media/find-keyframe-before-time.ts
-var findKeyframeBeforeTime = ({
-  samplePositions,
-  time,
-  timescale,
-  mediaSections,
-  logLevel
-}) => {
-  let byte = 0;
-  let sam = null;
-  for (const sample of samplePositions) {
-    const ctsInSeconds = sample.cts / timescale;
-    const dtsInSeconds = sample.dts / timescale;
-    if ((ctsInSeconds <= time || dtsInSeconds <= time) && byte <= sample.offset && sample.isKeyframe) {
-      byte = sample.offset;
-      sam = sample;
-    }
-  }
-  if (!sam) {
-    throw new Error("No sample found");
-  }
-  const mediaSection = mediaSections.find((section) => sam.offset >= section.start && sam.offset < section.start + section.size);
-  if (!mediaSection) {
-    Log.trace(logLevel, "Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.", sam);
-    return null;
-  }
-  return sam.offset;
-};
-
 // src/containers/iso-base-media/get-sample-position-bounds.ts
 var getSamplePositionBounds = (samplePositions, timescale) => {
   let min = Infinity;
   let max = -Infinity;
   for (const samplePosition of samplePositions) {
     const timestampMin = Math.min(samplePosition.cts, samplePosition.dts);
-    const timestampMax = Math.max(samplePosition.cts, samplePosition.dts);
+    const timestampMax = Math.max(samplePosition.cts, samplePosition.dts) + (samplePosition.duration ?? 0);
     if (timestampMin < min) {
       min = timestampMin;
     }
@@ -5658,10 +5856,10 @@ var getSamplePositionBounds = (samplePositions, timescale) => {
 var findBestSegmentFromTfra = ({
   mfra,
   time,
-  firstVideoTrack,
+  firstTrack,
   timescale
 }) => {
-  const tfra = mfra.find((b) => b.type === "tfra-box" && b.trackId === firstVideoTrack.trackId);
+  const tfra = mfra.find((b) => b.type === "tfra-box" && b.trackId === firstTrack.trackId);
   if (!tfra) {
     return null;
   }
@@ -5682,130 +5880,191 @@ var findBestSegmentFromTfra = ({
   };
 };
 
-// src/containers/iso-base-media/get-seeking-byte.ts
-var getSeekingByteFromIsoBaseMedia = async ({
+// src/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.ts
+var getSeekingByteFromFragmentedMp4 = async ({
   info,
   time,
   logLevel,
   currentPosition,
   isoState,
-  mp4HeaderSegment,
-  structure
+  allTracks,
+  isLastChunkInPlaylist
 }) => {
-  const tracks2 = getTracksFromMoovBox(info.moovBox);
-  const allTracks = [
-    ...tracks2.videoTracks,
-    ...tracks2.audioTracks,
-    ...tracks2.otherTracks
-  ];
-  const hasMoov = Boolean(getMoovBoxFromState({
-    mp4HeaderSegment,
-    structureState: structure,
-    isoState,
-    mayUsePrecomputed: false
-  }));
-  if (!hasMoov) {
-    Log.trace(logLevel, "No moov box found, must wait");
-    return {
-      type: "valid-but-must-wait"
-    };
-  }
   const firstVideoTrack = allTracks.find((t) => t.type === "video");
-  if (!firstVideoTrack) {
-    throw new Error("No video track found");
+  const firstTrack = firstVideoTrack ?? allTracks.find((t) => t.type === "audio");
+  if (!firstTrack) {
+    throw new Error("no video and no audio tracks");
   }
-  const { timescale } = firstVideoTrack;
-  if (info.moofBoxes.length > 0) {
-    const tkhdBox = getTkhdBox(firstVideoTrack.trakBox);
-    if (!tkhdBox) {
-      throw new Error("Expected tkhd box in trak box");
-    }
-    const { samplePositions: samplePositionsArray } = collectSamplePositionsFromMoofBoxes({
-      moofBoxes: info.moofBoxes,
-      tfraBoxes: info.tfraBoxes,
-      tkhdBox
-    });
-    Log.trace(logLevel, "Fragmented MP4 - Checking if we have seeking info for this time range");
-    for (const positions of samplePositionsArray) {
-      const { min, max } = getSamplePositionBounds(positions, timescale);
-      if (min <= time && time <= max) {
-        Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
-        const kf = findKeyframeBeforeTime({
-          samplePositions: positions,
-          time,
-          timescale,
-          logLevel,
-          mediaSections: info.mediaSections
-        });
-        if (kf) {
-          return {
-            type: "do-seek",
-            byte: kf
-          };
-        }
-      }
-    }
-    const atom = await (info.mfraAlreadyLoaded ? Promise.resolve(info.mfraAlreadyLoaded) : isoState.mfra.triggerLoad());
-    if (atom) {
-      const moofOffset = findBestSegmentFromTfra({
-        mfra: atom,
+  const tkhdBox = getTkhdBox(firstTrack.trakBox);
+  if (!tkhdBox) {
+    throw new Error("Expected tkhd box in trak box");
+  }
+  const { samplePositions: samplePositionsArray } = collectSamplePositionsFromMoofBoxes({
+    moofBoxes: info.moofBoxes,
+    tfraBoxes: info.tfraBoxes,
+    tkhdBox
+  });
+  Log.trace(logLevel, "Fragmented MP4 - Checking if we have seeking info for this time range");
+  for (const positions of samplePositionsArray) {
+    const { min, max } = getSamplePositionBounds(positions.samples, firstTrack.timescale);
+    if (min <= time && (positions.isLastFragment || isLastChunkInPlaylist || time <= max)) {
+      Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
+      const kf = findKeyframeBeforeTime({
+        samplePositions: positions.samples,
         time,
-        firstVideoTrack,
-        timescale
+        timescale: firstTrack.timescale,
+        logLevel,
+        mediaSections: info.mediaSections
       });
-      if (moofOffset !== null && !(moofOffset.start <= currentPosition && currentPosition < moofOffset.end)) {
-        Log.verbose(logLevel, `Fragmented MP4 - Found based on mfra information that we should seek to: ${moofOffset.start} ${moofOffset.end}`);
+      if (kf) {
         return {
-          type: "intermediary-seek",
-          byte: moofOffset.start
+          type: "do-seek",
+          byte: kf
         };
       }
     }
-    Log.trace(logLevel, "Fragmented MP4 - No seeking info found for this time range.");
-    if (isByteInMediaSection({
-      position: currentPosition,
-      mediaSections: info.mediaSections
-    }) !== "in-section") {
+  }
+  const atom = await (info.mfraAlreadyLoaded ? Promise.resolve(info.mfraAlreadyLoaded) : isoState.mfra.triggerLoad());
+  if (atom) {
+    const moofOffset = findBestSegmentFromTfra({
+      mfra: atom,
+      time,
+      firstTrack,
+      timescale: firstTrack.timescale
+    });
+    if (moofOffset !== null && !(moofOffset.start <= currentPosition && currentPosition < moofOffset.end)) {
+      Log.verbose(logLevel, `Fragmented MP4 - Found based on mfra information that we should seek to: ${moofOffset.start} ${moofOffset.end}`);
       return {
-        type: "valid-but-must-wait"
+        type: "intermediary-seek",
+        byte: moofOffset.start
       };
     }
-    Log.trace(logLevel, "Fragmented MP4 - Inside the wrong video section, skipping to the end of the section");
-    const mediaSection = getCurrentMediaSection({
-      offset: currentPosition,
-      mediaSections: info.mediaSections
-    });
-    if (!mediaSection) {
-      throw new Error("No video section defined");
-    }
+  }
+  Log.trace(logLevel, "Fragmented MP4 - No seeking info found for this time range.");
+  if (isByteInMediaSection({
+    position: currentPosition,
+    mediaSections: info.mediaSections
+  }) !== "in-section") {
     return {
-      type: "intermediary-seek",
-      byte: mediaSection.start + mediaSection.size
+      type: "valid-but-must-wait"
     };
   }
-  const { samplePositions, isComplete } = getSamplePositionsFromTrack({
-    trakBox: firstVideoTrack.trakBox,
-    moofBoxes: info.moofBoxes,
-    tfraBoxes: info.tfraBoxes
+  Log.trace(logLevel, "Fragmented MP4 - Inside the wrong video section, skipping to the end of the section");
+  const mediaSection = getCurrentMediaSection({
+    offset: currentPosition,
+    mediaSections: info.mediaSections
   });
-  if (!isComplete) {
-    throw new Error("Incomplete sample positions");
+  if (!mediaSection) {
+    throw new Error("No video section defined");
   }
+  return {
+    type: "intermediary-seek",
+    byte: mediaSection.start + mediaSection.size
+  };
+};
+
+// src/containers/iso-base-media/get-seeking-byte.ts
+var getSeekingByteFromIsoBaseMedia = ({
+  info,
+  time,
+  logLevel,
+  currentPosition,
+  isoState,
+  m3uPlaylistContext,
+  structure
+}) => {
+  const tracks2 = getTracksFromIsoBaseMedia({
+    isoState,
+    m3uPlaylistContext,
+    structure,
+    mayUsePrecomputed: false
+  });
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  const hasMoov = Boolean(getMoovBoxFromState({
+    structureState: structure,
+    isoState,
+    mayUsePrecomputed: false,
+    mp4HeaderSegment: m3uPlaylistContext?.mp4HeaderSegment ?? null
+  }));
+  if (!hasMoov) {
+    Log.trace(logLevel, "No moov box found, must wait");
+    return Promise.resolve({
+      type: "valid-but-must-wait"
+    });
+  }
+  if (info.moofBoxes.length > 0) {
+    return getSeekingByteFromFragmentedMp4({
+      info,
+      time,
+      logLevel,
+      currentPosition,
+      isoState,
+      allTracks,
+      isLastChunkInPlaylist: m3uPlaylistContext?.isLastChunkInPlaylist ?? false
+    });
+  }
+  const trackWithSamplePositions = findTrackToSeek(allTracks, structure);
+  if (!trackWithSamplePositions) {
+    return Promise.resolve({
+      type: "valid-but-must-wait"
+    });
+  }
+  const { track, samplePositions } = trackWithSamplePositions;
   const keyframe = findKeyframeBeforeTime({
     samplePositions,
     time,
-    timescale,
+    timescale: track.timescale,
     logLevel,
     mediaSections: info.mediaSections
   });
   if (keyframe) {
-    return {
+    return Promise.resolve({
       type: "do-seek",
       byte: keyframe
-    };
+    });
   }
-  return {
+  return Promise.resolve({
     type: "invalid"
+  });
+};
+
+// src/containers/m3u/get-seeking-byte.ts
+var clearM3uStateInPrepareForSeek = ({
+  m3uState,
+  logLevel
+}) => {
+  const selectedPlaylists = m3uState.getSelectedPlaylists();
+  for (const playlistUrl of selectedPlaylists) {
+    const streamRun = m3uState.getM3uStreamRun(playlistUrl);
+    if (streamRun) {
+      streamRun.abort();
+    }
+    Log.trace(logLevel, "Clearing M3U stream run for", playlistUrl);
+    m3uState.setM3uStreamRun(playlistUrl, null);
+  }
+  m3uState.clearAllChunksProcessed();
+  m3uState.sampleSorter.clearSamples();
+};
+var getSeekingByteForM3u8 = ({
+  time,
+  currentPosition,
+  m3uState,
+  logLevel
+}) => {
+  clearM3uStateInPrepareForSeek({ m3uState, logLevel });
+  const selectedPlaylists = m3uState.getSelectedPlaylists();
+  for (const playlistUrl of selectedPlaylists) {
+    m3uState.setSeekToSecondsToProcess(playlistUrl, {
+      targetTime: time
+    });
+  }
+  return {
+    type: "do-seek",
+    byte: currentPosition
   };
 };
 
@@ -6742,9 +7001,10 @@ var getSeekingByte = ({
   transportStream,
   webmState,
   mediaSection,
-  mp4HeaderSegment,
+  m3uPlaylistContext,
   structure,
-  riffState
+  riffState,
+  m3uState
 }) => {
   if (info.type === "iso-base-media-seeking-hints") {
     return getSeekingByteFromIsoBaseMedia({
@@ -6753,8 +7013,8 @@ var getSeekingByte = ({
       logLevel,
       currentPosition,
       isoState,
-      mp4HeaderSegment,
-      structure
+      structure,
+      m3uPlaylistContext
     });
   }
   if (info.type === "wav-seeking-hints") {
@@ -6819,6 +7079,14 @@ var getSeekingByte = ({
       seekingHints: info
     }));
   }
+  if (info.type === "m3u8-seeking-hints") {
+    return Promise.resolve(getSeekingByteForM3u8({
+      time,
+      currentPosition,
+      m3uState,
+      logLevel
+    }));
+  }
   throw new Error(`Unknown seeking info type: ${info}`);
 };
 
@@ -6907,6 +7175,13 @@ var getSeekingHintsFromMp4 = ({
 };
 var setSeekingHintsForMp4 = ({}) => {};
 
+// src/containers/m3u/seeking-hints.ts
+var getSeekingHintsForM3u = () => {
+  return {
+    type: "m3u8-seeking-hints"
+  };
+};
+
 // src/containers/mp3/seeking-hints.ts
 var getSeekingHintsForMp3 = ({
   mp3State,
@@ -7053,7 +7328,7 @@ var setSeekingHintsForWebm = ({
 // src/get-seeking-hints.ts
 var getSeekingHints = ({
   structureState,
-  mp4HeaderSegment,
+  m3uPlaylistContext,
   mediaSectionState: mediaSectionState2,
   isoState,
   transportStream,
@@ -7075,7 +7350,7 @@ var getSeekingHints = ({
     return getSeekingHintsFromMp4({
       structureState,
       isoState,
-      mp4HeaderSegment,
+      mp4HeaderSegment: m3uPlaylistContext?.mp4HeaderSegment ?? null,
       mediaSectionState: mediaSectionState2
     });
   }
@@ -7118,7 +7393,10 @@ var getSeekingHints = ({
       samplesObserved
     });
   }
-  throw new Error(`Seeking is not supported for this format: ${structure.type}`);
+  if (structure.type === "m3u") {
+    return getSeekingHintsForM3u();
+  }
+  throw new Error(`Seeking is not supported for this format: ${structure}`);
 };
 
 // src/seek-backwards.ts
@@ -7129,10 +7407,12 @@ var seekBackwards = async ({
   src,
   controller,
   logLevel,
-  currentReader
+  currentReader,
+  prefetchCache
 }) => {
   const howManyBytesWeCanGoBack = iterator.counter.getDiscardedOffset();
   if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+    Log.verbose(logLevel, `Seeking back to ${seekTo}`);
     iterator.skipTo(seekTo);
     return;
   }
@@ -7141,7 +7421,9 @@ var seekBackwards = async ({
   const { reader: newReader } = await readerInterface.read({
     src,
     range: seekTo,
-    controller
+    controller,
+    logLevel,
+    prefetchCache
   });
   iterator.replaceData(new Uint8Array([]), seekTo);
   Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
@@ -7211,7 +7493,8 @@ var seekForward = async ({
   readerInterface,
   src,
   controller,
-  discardReadBytes
+  discardReadBytes,
+  prefetchCache
 }) => {
   if (userInitiated) {
     disallowForwardSeekIfSamplesAreNeeded({
@@ -7232,7 +7515,9 @@ var seekForward = async ({
   const { reader: newReader } = await readerInterface.read({
     src,
     range: seekTo,
-    controller
+    controller,
+    logLevel,
+    prefetchCache
   });
   iterator.skipTo(seekTo);
   await discardReadBytes(true);
@@ -7255,7 +7540,8 @@ var performSeek = async ({
   readerInterface,
   src,
   discardReadBytes,
-  fields
+  fields,
+  prefetchCache
 }) => {
   const byteInMediaSection = isByteInMediaSection({
     position: seekTo,
@@ -7304,7 +7590,8 @@ var performSeek = async ({
       readerInterface,
       src,
       controller,
-      discardReadBytes
+      discardReadBytes,
+      prefetchCache
     });
   } else {
     await seekBackwards({
@@ -7314,7 +7601,8 @@ var performSeek = async ({
       logLevel,
       currentReader,
       readerInterface,
-      src
+      src,
+      prefetchCache
     });
   }
   await controller._internals.checkForAbortAndPause();
@@ -7327,7 +7615,7 @@ var turnSeekIntoByte = async ({
   logLevel,
   iterator,
   structureState,
-  mp4HeaderSegment,
+  m3uPlaylistContext,
   isoState,
   transportStream,
   tracksState,
@@ -7338,7 +7626,8 @@ var turnSeekIntoByte = async ({
   riffState,
   mp3State,
   contentLength,
-  aacState
+  aacState,
+  m3uState
 }) => {
   const mediaSections = mediaSectionState2.getMediaSections();
   if (mediaSections.length === 0) {
@@ -7355,7 +7644,6 @@ var turnSeekIntoByte = async ({
       riffState,
       samplesObserved,
       structureState,
-      mp4HeaderSegment,
       mediaSectionState: mediaSectionState2,
       isoState,
       transportStream,
@@ -7365,7 +7653,8 @@ var turnSeekIntoByte = async ({
       flacState,
       mp3State,
       contentLength,
-      aacState
+      aacState,
+      m3uPlaylistContext
     });
     if (!seekingHints) {
       Log.trace(logLevel, "No seeking info, cannot seek yet");
@@ -7382,18 +7671,13 @@ var turnSeekIntoByte = async ({
       transportStream,
       webmState,
       mediaSection: mediaSectionState2,
-      mp4HeaderSegment,
+      m3uPlaylistContext,
       structure: structureState,
-      riffState
+      riffState,
+      m3uState
     });
     return seekingByte;
   }
-  if (seek2.type === "byte") {
-    return {
-      type: "do-seek",
-      byte: seek2.byte
-    };
-  }
   throw new Error(`Cannot process seek request for ${seek2}: ${JSON.stringify(seek2)}`);
 };
 var getWorkOnSeekRequestOptions = (state) => {
@@ -7407,7 +7691,7 @@ var getWorkOnSeekRequestOptions = (state) => {
     contentLength: state.contentLength,
     readerInterface: state.readerInterface,
     mediaSection: state.mediaSection,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    m3uPlaylistContext: state.m3uPlaylistContext,
     mode: state.mode,
     seekInfiniteLoop: state.seekInfiniteLoop,
     currentReader: state.currentReader,
@@ -7421,7 +7705,9 @@ var getWorkOnSeekRequestOptions = (state) => {
     samplesObserved: state.samplesObserved,
     riffState: state.riff,
     mp3State: state.mp3,
-    aacState: state.aac
+    aacState: state.aac,
+    m3uState: state.m3u,
+    prefetchCache: state.prefetchCache
   };
 };
 var workOnSeekRequest = async (options) => {
@@ -7429,7 +7715,7 @@ var workOnSeekRequest = async (options) => {
     logLevel,
     controller,
     mediaSection,
-    mp4HeaderSegment,
+    m3uPlaylistContext,
     isoState,
     iterator,
     structureState,
@@ -7449,20 +7735,22 @@ var workOnSeekRequest = async (options) => {
     samplesObserved,
     riffState,
     mp3State,
-    aacState
+    aacState,
+    prefetchCache,
+    m3uState
   } = options;
   const seek2 = controller._internals.seekSignal.getSeek();
   if (!seek2) {
     return;
   }
-  Log.trace(logLevel, `Has seek request: ${JSON.stringify(seek2)}`);
+  Log.trace(logLevel, `Has seek request for ${src}: ${JSON.stringify(seek2)}`);
   const resolution = await turnSeekIntoByte({
     seek: seek2,
     mediaSectionState: mediaSection,
     logLevel,
     iterator,
     structureState,
-    mp4HeaderSegment,
+    m3uPlaylistContext,
     isoState,
     transportStream,
     tracksState,
@@ -7473,7 +7761,8 @@ var workOnSeekRequest = async (options) => {
     riffState,
     mp3State,
     contentLength,
-    aacState
+    aacState,
+    m3uState
   });
   Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
   if (resolution.type === "intermediary-seek") {
@@ -7491,7 +7780,8 @@ var workOnSeekRequest = async (options) => {
       readerInterface,
       src,
       discardReadBytes,
-      fields
+      fields,
+      prefetchCache
     });
     return;
   }
@@ -7510,7 +7800,8 @@ var workOnSeekRequest = async (options) => {
       readerInterface,
       src,
       discardReadBytes,
-      fields
+      fields,
+      prefetchCache
     });
     const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek2);
     if (hasChanged) {
@@ -8136,6 +8427,10 @@ var makeSkip = (skipTo) => ({
   action: "skip",
   skipTo
 });
+var makeFetchMoreData = (bytesNeeded) => ({
+  action: "fetch-more-data",
+  bytesNeeded
+});
 
 // src/containers/flac/get-block-size.ts
 var getBlockSize = (iterator) => {
@@ -8590,11 +8885,12 @@ var calculateFlatSamples = (state) => {
         samplePosition
       };
     });
-  }).flat(1);
+  });
   return flatSamples;
 };
 var cachedSamplePositionsState = () => {
   const cachedForMdatStart = {};
+  const jumpMarksForMdatStart = {};
   return {
     getSamples: (mdatStart) => {
       if (cachedForMdatStart[mdatStart]) {
@@ -8604,6 +8900,12 @@ var cachedSamplePositionsState = () => {
     },
     setSamples: (mdatStart, samples) => {
       cachedForMdatStart[mdatStart] = samples;
+    },
+    setJumpMarks: (mdatStart, marks) => {
+      jumpMarksForMdatStart[mdatStart] = marks;
+    },
+    getJumpMarks: (mdatStart) => {
+      return jumpMarksForMdatStart[mdatStart];
     }
   };
 };
@@ -8633,17 +8935,21 @@ var makeCanSkipTracksState = ({
   hasVideoTrackHandlers,
   structure
 }) => {
+  const doFieldsNeedTracks = () => {
+    const keys = Object.keys(fields ?? {});
+    const selectedKeys = keys.filter((k) => fields[k]);
+    return selectedKeys.some((k) => needsTracksForField({
+      field: k,
+      structure: structure.getStructureOrNull()
+    }));
+  };
   return {
+    doFieldsNeedTracks,
     canSkipTracks: () => {
       if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
         return false;
       }
-      const keys = Object.keys(fields ?? {});
-      const selectedKeys = keys.filter((k) => fields[k]);
-      return !selectedKeys.some((k) => needsTracksForField({
-        field: k,
-        structure: structure.getStructureOrNull()
-      }));
+      return !doFieldsNeedTracks();
     }
   };
 };
@@ -8934,10 +9240,10 @@ var getIsoBaseMediaChildren = async ({
       onlyIfMdatAtomExpected: null,
       contentLength
     });
-    if (!parsed) {
+    if (parsed.type !== "box") {
       throw new Error("Expected box");
     }
-    boxes.push(parsed);
+    boxes.push(parsed.box);
   }
   if (iterator.counter.getOffset() > size + initial) {
     throw new Error(`read too many bytes - size: ${size}, read: ${iterator.counter.getOffset() - initial}. initial offset: ${initial}`);
@@ -9637,7 +9943,7 @@ var parseStsc = ({
   }
   const flags = iterator.getSlice(3);
   const entryCount = iterator.getUint32();
-  const entries = [];
+  const entries = new Map;
   for (let i = 0;i < entryCount; i++) {
     const firstChunk = iterator.getUint32();
     const samplesPerChunk = iterator.getUint32();
@@ -9645,10 +9951,7 @@ var parseStsc = ({
     if (sampleDescriptionIndex !== 1) {
       throw new Error(`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`);
     }
-    entries.push({
-      firstChunk,
-      samplesPerChunk
-    });
+    entries.set(firstChunk, samplesPerChunk);
   }
   return {
     type: "stsc-box",
@@ -9719,7 +10022,8 @@ var audioTags = [
   1836253269,
   ".mp3",
   "mp4a",
-  "ac-3"
+  "ac-3",
+  "Opus"
 ];
 var processIsoFormatBox = async ({
   iterator,
@@ -9992,9 +10296,9 @@ var parseStss = ({
   }
   const flags = iterator.getSlice(3);
   const sampleCount = iterator.getUint32();
-  const sampleNumber = [];
+  const sampleNumber = new Set;
   for (let i = 0;i < sampleCount; i++) {
-    sampleNumber.push(iterator.getUint32());
+    sampleNumber.add(iterator.getUint32());
   }
   const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - offset);
   if (bytesRemainingInBox > 0) {
@@ -10310,8 +10614,11 @@ var processBox = async ({
   const boxSizeRaw = iterator.getFourByteNumber();
   if (boxSizeRaw === 0) {
     return {
-      type: "void-box",
-      boxSize: 0
+      type: "box",
+      box: {
+        type: "void-box",
+        boxSize: 0
+      }
     };
   }
   if (boxSizeRaw === 1 && iterator.bytesRemaining() < 12 || iterator.bytesRemaining() < 4) {
@@ -10325,120 +10632,177 @@ var processBox = async ({
   const headerLength = iterator.counter.getOffset() - startOff;
   if (boxType === "mdat") {
     if (!onlyIfMdatAtomExpected) {
-      return null;
+      return { type: "nothing" };
     }
     const { mediaSectionState: mediaSectionState2 } = onlyIfMdatAtomExpected;
     mediaSectionState2.addMediaSection({
       size: boxSize - headerLength,
       start: iterator.counter.getOffset()
     });
-    return null;
+    return { type: "nothing" };
   }
   if (bytesRemaining < boxSize) {
     returnToCheckpoint();
-    return null;
+    return {
+      type: "fetch-more-data",
+      bytesNeeded: makeFetchMoreData(boxSize - bytesRemaining)
+    };
   }
   if (boxType === "ftyp") {
-    return parseFtyp({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "box",
+      box: await parseFtyp({ iterator, size: boxSize, offset: fileOffset })
+    };
   }
   if (boxType === "colr") {
-    return parseColorParameterBox({
-      iterator,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseColorParameterBox({
+        iterator,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "mvhd") {
-    return parseMvhd({ iterator, offset: fileOffset, size: boxSize });
+    return {
+      type: "box",
+      box: await parseMvhd({ iterator, offset: fileOffset, size: boxSize })
+    };
   }
   if (boxType === "tkhd") {
-    return parseTkhd({ iterator, offset: fileOffset, size: boxSize });
+    return {
+      type: "box",
+      box: await parseTkhd({ iterator, offset: fileOffset, size: boxSize })
+    };
   }
   if (boxType === "trun") {
-    return parseTrun({ iterator, offset: fileOffset, size: boxSize });
+    return {
+      type: "box",
+      box: await parseTrun({ iterator, offset: fileOffset, size: boxSize })
+    };
   }
   if (boxType === "tfdt") {
-    return parseTfdt({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "box",
+      box: await parseTfdt({ iterator, size: boxSize, offset: fileOffset })
+    };
   }
   if (boxType === "stsd") {
-    return parseStsd({
-      offset: fileOffset,
-      size: boxSize,
-      iterator,
-      logLevel,
-      contentLength
-    });
+    return {
+      type: "box",
+      box: await parseStsd({
+        offset: fileOffset,
+        size: boxSize,
+        iterator,
+        logLevel,
+        contentLength
+      })
+    };
   }
   if (boxType === "stsz") {
-    return parseStsz({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseStsz({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "stco" || boxType === "co64") {
-    return parseStco({
-      iterator,
-      offset: fileOffset,
-      size: boxSize,
-      mode64Bit: boxType === "co64"
-    });
+    return {
+      type: "box",
+      box: await parseStco({
+        iterator,
+        offset: fileOffset,
+        size: boxSize,
+        mode64Bit: boxType === "co64"
+      })
+    };
   }
   if (boxType === "pasp") {
-    return parsePasp({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parsePasp({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "stss") {
-    return parseStss({
-      iterator,
-      offset: fileOffset,
-      boxSize
-    });
+    return {
+      type: "box",
+      box: await parseStss({
+        iterator,
+        offset: fileOffset,
+        boxSize
+      })
+    };
   }
   if (boxType === "ctts") {
-    return parseCtts({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseCtts({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "stsc") {
-    return parseStsc({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseStsc({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "mebx") {
-    return parseMebx({
-      offset: fileOffset,
-      size: boxSize,
-      iterator,
-      logLevel,
-      contentLength
-    });
+    return {
+      type: "box",
+      box: await parseMebx({
+        offset: fileOffset,
+        size: boxSize,
+        iterator,
+        logLevel,
+        contentLength
+      })
+    };
   }
   if (boxType === "hdlr") {
-    return parseHdlr({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "box",
+      box: await parseHdlr({ iterator, size: boxSize, offset: fileOffset })
+    };
   }
   if (boxType === "keys") {
-    return parseKeys({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "box",
+      box: await parseKeys({ iterator, size: boxSize, offset: fileOffset })
+    };
   }
   if (boxType === "ilst") {
-    return parseIlstBox({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseIlstBox({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "tfra") {
-    return parseTfraBox({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseTfraBox({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "moov") {
     if (!onlyIfMoovAtomExpected) {
@@ -10447,12 +10811,12 @@ var processBox = async ({
     const { tracks: tracks2, isoState } = onlyIfMoovAtomExpected;
     if (tracks2.hasAllTracks()) {
       iterator.discard(boxSize - 8);
-      return null;
+      return { type: "nothing" };
     }
     if (isoState && isoState.moov.getMoovBoxAndPrecomputed() && !isoState.moov.getMoovBoxAndPrecomputed()?.precomputed) {
       Log.verbose(logLevel, "Moov box already parsed, skipping");
       iterator.discard(boxSize - 8);
-      return null;
+      return { type: "nothing" };
     }
     const box = await parseMoov({
       offset: fileOffset,
@@ -10463,7 +10827,7 @@ var processBox = async ({
       contentLength
     });
     tracks2.setIsDone(logLevel);
-    return box;
+    return { type: "box", box };
   }
   if (boxType === "trak") {
     if (!onlyIfMoovAtomExpected) {
@@ -10498,54 +10862,75 @@ var processBox = async ({
         onAudioTrack
       });
     }
-    return box;
+    return { type: "box", box };
   }
   if (boxType === "stts") {
-    return parseStts({
-      data: iterator,
-      size: boxSize,
-      fileOffset
-    });
+    return {
+      type: "box",
+      box: await parseStts({
+        data: iterator,
+        size: boxSize,
+        fileOffset
+      })
+    };
   }
   if (boxType === "avcC") {
-    return parseAvcc({
-      data: iterator,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseAvcc({
+        data: iterator,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "av1C") {
-    return parseAv1C({
-      data: iterator,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await parseAv1C({
+        data: iterator,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "hvcC") {
-    return parseHvcc({
-      data: iterator,
-      size: boxSize,
-      offset: fileOffset
-    });
+    return {
+      type: "box",
+      box: await parseHvcc({
+        data: iterator,
+        size: boxSize,
+        offset: fileOffset
+      })
+    };
   }
   if (boxType === "tfhd") {
-    return getTfhd({
-      iterator,
-      offset: fileOffset,
-      size: boxSize
-    });
+    return {
+      type: "box",
+      box: await getTfhd({
+        iterator,
+        offset: fileOffset,
+        size: boxSize
+      })
+    };
   }
   if (boxType === "mdhd") {
-    return parseMdhd({
-      data: iterator,
-      size: boxSize,
-      fileOffset
-    });
+    return {
+      type: "box",
+      box: await parseMdhd({
+        data: iterator,
+        size: boxSize,
+        fileOffset
+      })
+    };
   }
   if (boxType === "esds") {
-    return parseEsds({
-      data: iterator,
-      size: boxSize,
-      fileOffset
-    });
+    return {
+      type: "box",
+      box: await parseEsds({
+        data: iterator,
+        size: boxSize,
+        fileOffset
+      })
+    };
   }
   if (boxType === "moof") {
     onlyIfMoovAtomExpected?.isoState?.mfra.triggerLoad();
@@ -10559,20 +10944,26 @@ var processBox = async ({
       contentLength
     });
     return {
-      type: "regular-box",
-      boxType,
-      boxSize,
-      children,
-      offset: fileOffset
+      type: "box",
+      box: {
+        type: "regular-box",
+        boxType,
+        boxSize,
+        children,
+        offset: fileOffset
+      }
     };
   }
   iterator.discard(boxSize - 8);
   return {
-    type: "regular-box",
-    boxType,
-    boxSize,
-    children: [],
-    offset: fileOffset
+    type: "box",
+    box: {
+      type: "regular-box",
+      boxType,
+      boxSize,
+      children: [],
+      offset: fileOffset
+    }
   };
 };
 
@@ -10581,7 +10972,7 @@ var getMoovAtom = async ({
   endOfMdat,
   state
 }) => {
-  const headerSegment = state.mp4HeaderSegment;
+  const headerSegment = state.m3uPlaylistContext?.mp4HeaderSegment;
   if (headerSegment) {
     const segment = getMoovFromFromIsoStructure(headerSegment);
     if (!segment) {
@@ -10594,7 +10985,9 @@ var getMoovAtom = async ({
   const { reader } = await state.readerInterface.read({
     src: state.src,
     range: endOfMdat,
-    controller: state.controller
+    controller: state.controller,
+    logLevel: state.logLevel,
+    prefetchCache: state.prefetchCache
   });
   const onAudioTrack = state.onAudioTrack ? async ({ track, container }) => {
     await registerAudioTrack({
@@ -10651,8 +11044,8 @@ var getMoovAtom = async ({
       onlyIfMdatAtomExpected: null,
       contentLength: state.contentLength - endOfMdat
     });
-    if (box) {
-      boxes.push(box);
+    if (box.type === "box") {
+      boxes.push(box.box);
     }
     if (iterator.counter.getOffset() + endOfMdat > state.contentLength) {
       throw new Error("Read past end of file");
@@ -10669,6 +11062,121 @@ var getMoovAtom = async ({
   return moov;
 };
 
+// src/containers/iso-base-media/mdat/calculate-jump-marks.ts
+var MAX_SPREAD_IN_SECONDS = 8;
+var getKey = (samplePositionTrack) => {
+  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.dts}`;
+};
+var findBestJump = ({
+  allSamplesSortedByOffset,
+  visited,
+  progresses
+}) => {
+  const minProgress = Math.min(...Object.values(progresses));
+  const trackNumberWithLowestProgress = Object.entries(progresses).find(([, progress]) => progress === minProgress)?.[0];
+  const firstSampleAboveMinProgress = allSamplesSortedByOffset.findIndex((sample) => sample.track.trackId === Number(trackNumberWithLowestProgress) && !visited.has(getKey(sample)));
+  return firstSampleAboveMinProgress;
+};
+var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
+  const progresses = {};
+  for (const track of samplePositionTracks) {
+    progresses[track[0].track.trackId] = 0;
+  }
+  const jumpMarks = [];
+  const allSamplesSortedByOffset = samplePositionTracks.flat(1).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset);
+  let indexToVisit = 0;
+  const visited = new Set;
+  let rollOverToProcess = false;
+  const increaseIndex = () => {
+    indexToVisit++;
+    if (indexToVisit >= allSamplesSortedByOffset.length) {
+      rollOverToProcess = true;
+      indexToVisit = 0;
+    }
+  };
+  let lastVisitedSample = null;
+  const addJumpMark = ({
+    firstSampleAboveMinProgress
+  }) => {
+    if (!lastVisitedSample) {
+      throw new Error("no last visited sample");
+    }
+    const jumpMark = {
+      afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
+      jumpToOffset: allSamplesSortedByOffset[firstSampleAboveMinProgress].samplePosition.offset
+    };
+    indexToVisit = firstSampleAboveMinProgress;
+    jumpMarks.push(jumpMark);
+  };
+  const addFinalJumpIfNecessary = () => {
+    if (indexToVisit === allSamplesSortedByOffset.length - 1) {
+      return;
+    }
+    jumpMarks.push({
+      afterSampleWithOffset: allSamplesSortedByOffset[indexToVisit].samplePosition.offset,
+      jumpToOffset: endOfMdat
+    });
+  };
+  const considerJump = () => {
+    const firstSampleAboveMinProgress = findBestJump({
+      allSamplesSortedByOffset,
+      visited,
+      progresses
+    });
+    if (firstSampleAboveMinProgress > -1 && firstSampleAboveMinProgress !== indexToVisit + 1) {
+      addJumpMark({ firstSampleAboveMinProgress });
+      indexToVisit = firstSampleAboveMinProgress;
+    } else {
+      while (true) {
+        increaseIndex();
+        if (!visited.has(getKey(allSamplesSortedByOffset[indexToVisit]))) {
+          break;
+        }
+      }
+    }
+  };
+  while (true) {
+    const currentSamplePosition = allSamplesSortedByOffset[indexToVisit];
+    const sampleKey = getKey(currentSamplePosition);
+    if (visited.has(sampleKey)) {
+      considerJump();
+      continue;
+    }
+    visited.add(sampleKey);
+    if (rollOverToProcess) {
+      if (!lastVisitedSample) {
+        throw new Error("no last visited sample");
+      }
+      jumpMarks.push({
+        afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
+        jumpToOffset: currentSamplePosition.samplePosition.offset
+      });
+      rollOverToProcess = false;
+    }
+    lastVisitedSample = currentSamplePosition;
+    if (visited.size === allSamplesSortedByOffset.length) {
+      addFinalJumpIfNecessary();
+      break;
+    }
+    const timestamp = currentSamplePosition.samplePosition.dts / currentSamplePosition.track.timescale;
+    progresses[currentSamplePosition.track.trackId] = timestamp;
+    const progressValues = Object.values(progresses);
+    const maxProgress = Math.max(...progressValues);
+    const minProgress = Math.min(...progressValues);
+    const spread = maxProgress - minProgress;
+    if (visited.size === allSamplesSortedByOffset.length) {
+      addFinalJumpIfNecessary();
+      break;
+    }
+    if (spread > MAX_SPREAD_IN_SECONDS) {
+      considerJump();
+    } else {
+      increaseIndex();
+    }
+  }
+  return jumpMarks;
+};
+
 // src/containers/iso-base-media/mdat/postprocess-bytes.ts
 var postprocessBytes = ({
   bytes,
@@ -10718,9 +11226,13 @@ var parseMdatSection = async (state) => {
     return parseMdatSection(state);
   }
   if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
-    state.iso.flatSamples.setSamples(mediaSection.start, calculateFlatSamples(state));
+    const flattedSamples = calculateFlatSamples(state);
+    const calcedJumpMarks = calculateJumpMarks(flattedSamples, endOfMdat);
+    state.iso.flatSamples.setJumpMarks(mediaSection.start, calcedJumpMarks);
+    state.iso.flatSamples.setSamples(mediaSection.start, flattedSamples.flat(1));
   }
   const flatSamples = state.iso.flatSamples.getSamples(mediaSection.start);
+  const jumpMarks = state.iso.flatSamples.getJumpMarks(mediaSection.start);
   const { iterator } = state;
   const samplesWithIndex = flatSamples.find((sample) => {
     return sample.samplePosition.offset === iterator.counter.getOffset();
@@ -10733,8 +11245,11 @@ var parseMdatSection = async (state) => {
     }
     return makeSkip(endOfMdat);
   }
+  if (samplesWithIndex.samplePosition.offset + samplesWithIndex.samplePosition.size > state.contentLength) {
+    return makeSkip(endOfMdat);
+  }
   if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-    return null;
+    return makeFetchMoreData(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
   }
   const { cts, dts, duration: duration2, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
   const bytes = postprocessBytes({
@@ -10782,6 +11297,10 @@ var parseMdatSection = async (state) => {
     });
     await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
   }
+  const jump = jumpMarks.find((j) => j.afterSampleWithOffset === offset);
+  if (jump) {
+    return makeSkip(jump.jumpToOffset);
+  }
   return null;
 };
 
@@ -10808,8 +11327,11 @@ var parseIsoBaseMedia = async (state) => {
     },
     contentLength: state.contentLength
   });
-  if (result) {
-    state.structure.getIsoStructure().boxes.push(result);
+  if (result.type === "fetch-more-data") {
+    return result.bytesNeeded;
+  }
+  if (result.type === "box") {
+    state.structure.getIsoStructure().boxes.push(result.box);
   }
   return null;
 };
@@ -10888,7 +11410,8 @@ var parseM3uMediaDirective = (str) => {
     groupId: map["GROUP-ID"],
     language: map.LANGUAGE || null,
     name: map.NAME || null,
-    uri: map.URI
+    uri: map.URI,
+    mediaType: map.TYPE || null
   };
 };
 
@@ -11048,7 +11571,9 @@ var afterManifestFetch = async ({
   selectM3uStreamFn,
   logLevel,
   selectAssociatedPlaylistsFn,
-  readerInterface
+  readerInterface,
+  onAudioTrack,
+  canSkipTracks
 }) => {
   const independentSegments = isIndependentSegments(structure);
   if (!independentSegments) {
@@ -11073,9 +11598,11 @@ var afterManifestFetch = async ({
     type: "selected-stream",
     stream: selectedPlaylist
   });
+  const skipAudioTracks = onAudioTrack === null && canSkipTracks.doFieldsNeedTracks() === false;
   const associatedPlaylists = await selectAssociatedPlaylists({
     playlists: selectedPlaylist.associatedPlaylists,
-    fn: selectAssociatedPlaylistsFn
+    fn: selectAssociatedPlaylistsFn,
+    skipAudioTracks
   });
   m3uState.setAssociatedPlaylists(associatedPlaylists);
   const playlistUrls = [
@@ -11159,6 +11686,12 @@ var webReader = {
       return webFileReadWholeAsText(src);
     }
     return fetchReadWholeAsText(src);
+  },
+  preload: ({ range: range2, src, logLevel, prefetchCache }) => {
+    if (src instanceof Blob) {
+      return;
+    }
+    return fetchPreload({ range: range2, src, logLevel, prefetchCache });
   }
 };
 // src/parse-media.ts
@@ -11202,7 +11735,7 @@ var parseMedia = (options) => {
     controller: options.controller ?? undefined,
     selectM3uStream: options.selectM3uStream ?? defaultSelectM3uStreamFn,
     selectM3uAssociatedPlaylists: options.selectM3uAssociatedPlaylists ?? defaultSelectM3uAssociatedPlaylists,
-    mp4HeaderSegment: options.mp4HeaderSegment ?? null,
+    m3uPlaylistContext: options.m3uPlaylistContext ?? null,
     src: options.src,
     mode: "query",
     onDiscardedData: null,
@@ -11214,6 +11747,39 @@ var parseMedia = (options) => {
   });
 };
 
+// src/containers/m3u/first-sample-in-m3u-chunk.ts
+var considerSeekBasedOnChunk = async ({
+  sample,
+  parentController,
+  childController,
+  callback,
+  m3uState,
+  playlistUrl,
+  subtractChunks,
+  chunkIndex
+}) => {
+  const pendingSeek = m3uState.getSeekToSecondsToProcess(playlistUrl);
+  if (pendingSeek === null) {
+    await callback(sample);
+    return;
+  }
+  const timestamp = Math.min(sample.dts / sample.timescale, sample.cts / sample.timescale);
+  if (timestamp > pendingSeek.targetTime && chunkIndex !== null && chunkIndex > 0) {
+    m3uState.setNextSeekShouldSubtractChunks(playlistUrl, subtractChunks + 1);
+    parentController.seek({
+      type: "keyframe-before-time",
+      timeInSeconds: pendingSeek.targetTime
+    });
+    return;
+  }
+  childController.seek({
+    type: "keyframe-before-time",
+    timeInSeconds: pendingSeek.targetTime
+  });
+  m3uState.setNextSeekShouldSubtractChunks(playlistUrl, 0);
+  m3uState.setSeekToSecondsToProcess(playlistUrl, null);
+};
+
 // src/containers/m3u/get-chunks.ts
 var getChunks = (playlist) => {
   const chunks = [];
@@ -11231,127 +11797,282 @@ var getChunks = (playlist) => {
       }
       chunks.push({ duration: box.value, url: nextBox.value, isHeader: false });
     }
-    continue;
+    continue;
+  }
+  return chunks;
+};
+
+// src/containers/m3u/seek/get-chunk-to-seek-to.ts
+var getChunkToSeekTo = ({
+  chunks,
+  seekToSecondsToProcess
+}) => {
+  let duration2 = 0;
+  for (let i = 0;i < chunks.length; i++) {
+    if (duration2 >= seekToSecondsToProcess) {
+      return Math.max(0, i - 1);
+    }
+    duration2 += chunks[i].duration;
   }
-  return chunks;
+  return Math.max(0, chunks.length - 1);
 };
 
-// src/containers/m3u/iterate-over-segment-files.ts
-var iteratorOverSegmentFiles = async ({
-  structure,
-  onVideoTrack,
-  m3uState,
-  onAudioTrack,
-  onDoneWithTracks,
+// src/containers/m3u/process-m3u-chunk.ts
+var processM3uChunk = ({
   playlistUrl,
-  logLevel,
-  parentController,
-  onInitialProgress,
-  readerInterface
+  state,
+  structure,
+  audioDone,
+  videoDone
 }) => {
-  const playlist = getPlaylist(structure, playlistUrl);
-  const chunks = getChunks(playlist);
-  let resolver = onInitialProgress;
-  let rejector = (_e) => {};
-  for (const chunk of chunks) {
-    resolver = onInitialProgress;
-    rejector = (_e) => {};
-    const childController = mediaParserController();
-    const forwarded = forwardMediaParserControllerPauseResume({
-      childController,
-      parentController
+  const { promise, reject, resolve } = withResolvers();
+  const onGlobalAudioTrack = audioDone ? null : 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",
+      track: {
+        ...track,
+        trackId
+      },
+      registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+      tracks: state.callbacks.tracks,
+      logLevel: state.logLevel,
+      onAudioTrack: state.onAudioTrack
     });
-    const makeContinuationFn = () => {
-      return {
-        continue() {
-          const { promise, reject, resolve } = withResolvers();
-          resolver = resolve;
-          rejector = reject;
-          childController.resume();
-          return promise;
-        },
-        abort() {
-          childController.abort();
-        }
-      };
+    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);
     };
-    const isLastChunk = chunk === chunks[chunks.length - 1];
-    await childController._internals.checkForAbortAndPause();
-    const src = readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);
-    try {
-      const mp4HeaderSegment = m3uState.getMp4HeaderSegment(playlistUrl);
-      const data = await parseMedia({
-        src,
-        acknowledgeRemotionLicense: true,
-        logLevel,
-        controller: childController,
-        progressIntervalInMs: 0,
-        onParseProgress: () => {
-          childController.pause();
-          resolver(makeContinuationFn());
-        },
-        fields: chunk.isHeader ? { structure: true } : undefined,
-        onTracks: () => {
-          if (!m3uState.hasEmittedDoneWithTracks(playlistUrl)) {
-            m3uState.setHasEmittedDoneWithTracks(playlistUrl);
-            onDoneWithTracks();
-            return null;
+  };
+  const onGlobalVideoTrack = videoDone ? null : 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",
+      track: {
+        ...track,
+        trackId
+      },
+      logLevel: state.logLevel,
+      onVideoTrack: state.onVideoTrack,
+      registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
+      tracks: state.callbacks.tracks
+    });
+    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);
+    };
+  };
+  const pausableIterator = async () => {
+    const playlist = getPlaylist(structure, playlistUrl);
+    const chunks = getChunks(playlist);
+    const seekToSecondsToProcess = state.m3u.getSeekToSecondsToProcess(playlistUrl);
+    const chunksToSubtract = state.m3u.getNextSeekShouldSubtractChunks(playlistUrl);
+    let chunkIndex = null;
+    if (seekToSecondsToProcess !== null) {
+      chunkIndex = Math.max(0, getChunkToSeekTo({
+        chunks,
+        seekToSecondsToProcess: seekToSecondsToProcess.targetTime
+      }) - chunksToSubtract);
+    }
+    const currentPromise = {
+      resolver: () => {
+        return;
+      },
+      rejector: reject
+    };
+    const requiresHeaderToBeFetched = chunks[0].isHeader;
+    for (const chunk of chunks) {
+      const mp4HeaderSegment = state.m3u.getMp4HeaderSegment(playlistUrl);
+      if (requiresHeaderToBeFetched && mp4HeaderSegment && chunk.isHeader) {
+        continue;
+      }
+      if (chunkIndex !== null && chunks.indexOf(chunk) < chunkIndex && !chunk.isHeader) {
+        continue;
+      }
+      currentPromise.resolver = (newRun) => {
+        state.m3u.setM3uStreamRun(playlistUrl, newRun);
+        resolve();
+      };
+      currentPromise.rejector = reject;
+      const childController = mediaParserController();
+      const forwarded = forwardMediaParserControllerPauseResume({
+        childController,
+        parentController: state.controller
+      });
+      const nextChunk = chunks[chunks.indexOf(chunk) + 1];
+      if (nextChunk) {
+        const nextChunkSource = state.readerInterface.createAdjacentFileSource(nextChunk.url, playlistUrl);
+        state.readerInterface.preload({
+          logLevel: state.logLevel,
+          range: null,
+          src: nextChunkSource,
+          prefetchCache: state.prefetchCache
+        });
+      }
+      const makeContinuationFn = () => {
+        return {
+          continue() {
+            const resolver = withResolvers();
+            currentPromise.resolver = resolver.resolve;
+            currentPromise.rejector = resolver.reject;
+            childController.resume();
+            return resolver.promise;
+          },
+          abort() {
+            childController.abort();
           }
-        },
-        onAudioTrack: onAudioTrack === null ? null : async ({ track }) => {
-          const callbackOrFalse = m3uState.hasEmittedAudioTrack(playlistUrl);
-          if (callbackOrFalse === false) {
-            const callback = await onAudioTrack(track);
-            if (!callback) {
-              m3uState.setHasEmittedAudioTrack(playlistUrl, null);
+        };
+      };
+      const isLastChunk = chunk === chunks[chunks.length - 1];
+      await childController._internals.checkForAbortAndPause();
+      const src = state.readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);
+      try {
+        const data = await parseMedia({
+          src,
+          acknowledgeRemotionLicense: true,
+          logLevel: state.logLevel,
+          controller: childController,
+          progressIntervalInMs: 0,
+          onParseProgress: () => {
+            childController.pause();
+            currentPromise.resolver(makeContinuationFn());
+          },
+          fields: chunk.isHeader ? { structure: true } : undefined,
+          onTracks: () => {
+            if (!state.m3u.hasEmittedDoneWithTracks(playlistUrl)) {
+              state.m3u.setHasEmittedDoneWithTracks(playlistUrl);
+              const allDone = state.m3u.setTracksDone(playlistUrl);
+              if (allDone) {
+                state.callbacks.tracks.setIsDone(state.logLevel);
+              }
+              return null;
+            }
+          },
+          onAudioTrack: onGlobalAudioTrack === null ? null : async ({ track }) => {
+            const callbackOrFalse = state.m3u.hasEmittedAudioTrack(playlistUrl);
+            if (callbackOrFalse === false) {
+              const callback = await onGlobalAudioTrack(track);
+              if (!callback) {
+                state.m3u.setHasEmittedAudioTrack(playlistUrl, null);
+                return null;
+              }
+              state.m3u.setHasEmittedAudioTrack(playlistUrl, callback);
+              return async (sample) => {
+                await considerSeekBasedOnChunk({
+                  sample,
+                  callback,
+                  parentController: state.controller,
+                  childController,
+                  m3uState: state.m3u,
+                  playlistUrl,
+                  subtractChunks: chunksToSubtract,
+                  chunkIndex
+                });
+              };
+            }
+            if (callbackOrFalse === null) {
               return null;
             }
-            m3uState.setHasEmittedAudioTrack(playlistUrl, callback);
-            return (sample) => {
-              return callback(sample);
+            return async (sample) => {
+              await considerSeekBasedOnChunk({
+                sample,
+                m3uState: state.m3u,
+                playlistUrl,
+                callback: callbackOrFalse,
+                parentController: state.controller,
+                childController,
+                subtractChunks: chunksToSubtract,
+                chunkIndex
+              });
             };
-          }
-          return callbackOrFalse;
-        },
-        onVideoTrack: onVideoTrack === null ? null : async ({ track }) => {
-          const callbackOrFalse = m3uState.hasEmittedVideoTrack(playlistUrl);
-          if (callbackOrFalse === false) {
-            const callback = await onVideoTrack({
-              ...track,
-              m3uStreamFormat: chunk.isHeader || mp4HeaderSegment ? "mp4" : "ts"
-            });
-            if (!callback) {
-              m3uState.setHasEmittedVideoTrack(playlistUrl, null);
+          },
+          onVideoTrack: onGlobalVideoTrack === null ? null : async ({ track }) => {
+            const callbackOrFalse = state.m3u.hasEmittedVideoTrack(playlistUrl);
+            if (callbackOrFalse === false) {
+              const callback = await onGlobalVideoTrack({
+                ...track,
+                m3uStreamFormat: chunk.isHeader || mp4HeaderSegment ? "mp4" : "ts"
+              });
+              if (!callback) {
+                state.m3u.setHasEmittedVideoTrack(playlistUrl, null);
+                return null;
+              }
+              state.m3u.setHasEmittedVideoTrack(playlistUrl, callback);
+              return async (sample) => {
+                await considerSeekBasedOnChunk({
+                  sample,
+                  m3uState: state.m3u,
+                  playlistUrl,
+                  callback,
+                  parentController: state.controller,
+                  childController,
+                  subtractChunks: chunksToSubtract,
+                  chunkIndex
+                });
+              };
+            }
+            if (callbackOrFalse === null) {
               return null;
             }
-            m3uState.setHasEmittedVideoTrack(playlistUrl, callback);
-            return (sample) => {
-              return callback(sample);
+            return async (sample) => {
+              await considerSeekBasedOnChunk({
+                sample,
+                m3uState: state.m3u,
+                playlistUrl,
+                callback: callbackOrFalse,
+                parentController: state.controller,
+                childController,
+                subtractChunks: chunksToSubtract,
+                chunkIndex
+              });
             };
+          },
+          reader: state.readerInterface,
+          makeSamplesStartAtZero: false,
+          m3uPlaylistContext: {
+            mp4HeaderSegment,
+            isLastChunkInPlaylist: isLastChunk
           }
-          return callbackOrFalse;
-        },
-        reader: readerInterface,
-        mp4HeaderSegment,
-        makeSamplesStartAtZero: false
-      });
-      if (chunk.isHeader) {
-        if (data.structure.type !== "iso-base-media") {
-          throw new Error("Expected an mp4 file");
+        });
+        if (chunk.isHeader) {
+          if (data.structure.type !== "iso-base-media") {
+            throw new Error("Expected an mp4 file");
+          }
+          state.m3u.setMp4HeaderSegment(playlistUrl, data.structure);
         }
-        m3uState.setMp4HeaderSegment(playlistUrl, data.structure);
+      } catch (e) {
+        currentPromise.rejector(e);
+        throw e;
+      }
+      forwarded.cleanup();
+      if (!isLastChunk) {
+        childController.pause();
+        currentPromise.resolver(makeContinuationFn());
       }
-    } catch (e) {
-      rejector(e);
-      throw e;
-    }
-    forwarded.cleanup();
-    if (!isLastChunk) {
-      childController.pause();
-      resolver(makeContinuationFn());
     }
-  }
-  resolver(null);
+    currentPromise.resolver(null);
+  };
+  const run = pausableIterator();
+  run.catch((err) => {
+    reject(err);
+  });
+  return promise;
 };
 
 // src/containers/m3u/run-over-m3u.ts
@@ -11382,80 +12103,12 @@ var runOverM3u = async ({
     return;
   }
   Log.trace(logLevel, "Starting new M3U parsing process for", playlistUrl);
-  return new Promise((resolve, reject) => {
-    const run = iteratorOverSegmentFiles({
-      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: audioDone ? null : 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",
-          track: {
-            ...track,
-            trackId
-          },
-          registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-          tracks: state.callbacks.tracks,
-          logLevel: state.logLevel,
-          onAudioTrack: state.onAudioTrack
-        });
-        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: videoDone ? null : 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",
-          track: {
-            ...track,
-            trackId
-          },
-          logLevel: state.logLevel,
-          onVideoTrack: state.onVideoTrack,
-          registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-          tracks: state.callbacks.tracks
-        });
-        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,
-      readerInterface: state.readerInterface
-    });
-    run.catch((err) => {
-      reject(err);
-    });
+  await processM3uChunk({
+    playlistUrl,
+    state,
+    structure,
+    audioDone,
+    videoDone
   });
 };
 
@@ -11477,6 +12130,10 @@ var parseM3u = async ({ state }) => {
     if (typeof state.src !== "string" && !(state.src instanceof URL)) {
       throw new Error("Expected src to be a string");
     }
+    state.mediaSection.addMediaSection({
+      start: 0,
+      size: state.contentLength + 1
+    });
     await afterManifestFetch({
       structure,
       m3uState: state.m3u,
@@ -11484,7 +12141,9 @@ var parseM3u = async ({ state }) => {
       selectM3uStreamFn: state.selectM3uStreamFn,
       logLevel: state.logLevel,
       selectAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
-      readerInterface: state.readerInterface
+      readerInterface: state.readerInterface,
+      onAudioTrack: state.onAudioTrack,
+      canSkipTracks: state.callbacks.canSkipTracksState
     });
     return null;
   }
@@ -13663,23 +14322,62 @@ var parseBlockFlags = (iterator, type) => {
 };
 
 // src/containers/webm/get-sample-from-block.ts
-var addAvcToTrackIfNecessary = ({
+var addAvcToTrackAndActivateTrackIfNecessary = async ({
   partialVideoSample,
   codec,
   structureState: structureState2,
   webmState,
-  trackNumber: trackNumber2
+  trackNumber: trackNumber2,
+  logLevel,
+  callbacks,
+  onVideoTrack
 }) => {
-  if (codec === "V_MPEG4/ISO/AVC" && getTracksFromMatroska({ structureState: structureState2, webmState }).missingInfo.length > 0) {
-    const parsed = parseAvc(partialVideoSample.data);
-    for (const parse of parsed) {
-      if (parse.type === "avc-profile") {
-        webmState.setAvcProfileForTrackNumber(trackNumber2, parse);
+  if (codec !== "V_MPEG4/ISO/AVC") {
+    return;
+  }
+  const missingTracks = getTracksFromMatroska({
+    structureState: structureState2,
+    webmState
+  }).missingInfo;
+  if (missingTracks.length === 0) {
+    return;
+  }
+  const parsed = parseAvc(partialVideoSample.data);
+  for (const parse of parsed) {
+    if (parse.type === "avc-profile") {
+      webmState.setAvcProfileForTrackNumber(trackNumber2, parse);
+      const track = missingTracks.find((t) => t.trackId === trackNumber2);
+      if (!track) {
+        throw new Error("Could not find track " + trackNumber2);
+      }
+      const resolvedTracks = getTracksFromMatroska({
+        structureState: structureState2,
+        webmState
+      }).resolved;
+      const resolvedTrack = resolvedTracks.find((t) => t.trackId === trackNumber2);
+      if (!resolvedTrack) {
+        throw new Error("Could not find track " + trackNumber2);
       }
+      await registerVideoTrack({
+        track: resolvedTrack,
+        container: "webm",
+        logLevel,
+        onVideoTrack,
+        registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+        tracks: callbacks.tracks
+      });
     }
   }
 };
-var getSampleFromBlock = (ebml, webmState, offset, structureState2) => {
+var getSampleFromBlock = async ({
+  ebml,
+  webmState,
+  offset,
+  structureState: structureState2,
+  callbacks,
+  logLevel,
+  onVideoTrack
+}) => {
   const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
   if (trackNumber2 === null) {
@@ -13717,12 +14415,15 @@ var getSampleFromBlock = (ebml, webmState, offset, structureState2) => {
         partialVideoSample
       };
     }
-    addAvcToTrackIfNecessary({
+    await addAvcToTrackAndActivateTrackIfNecessary({
       codec,
       partialVideoSample,
       structureState: structureState2,
       webmState,
-      trackNumber: trackNumber2
+      trackNumber: trackNumber2,
+      callbacks,
+      logLevel,
+      onVideoTrack
     });
     const sample = {
       ...partialVideoSample,
@@ -13882,21 +14583,31 @@ var postprocessEbml = async ({
       });
     }
     if (track && track.type === "video") {
-      await registerVideoTrack({
-        track,
-        container: "webm",
-        logLevel,
-        onVideoTrack,
-        registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
-        tracks: callbacks.tracks
-      });
+      if (track.codec !== NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS) {
+        await registerVideoTrack({
+          track,
+          container: "webm",
+          logLevel,
+          onVideoTrack,
+          registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+          tracks: callbacks.tracks
+        });
+      }
     }
   }
   if (ebml.type === "Timestamp") {
     webmState.setTimestampOffset(offset, ebml.value.value);
   }
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
-    const sample = getSampleFromBlock(ebml, webmState, offset, structureState2);
+    const sample = await getSampleFromBlock({
+      ebml,
+      webmState,
+      offset,
+      structureState: structureState2,
+      callbacks,
+      logLevel,
+      onVideoTrack
+    });
     if (sample.type === "video-sample") {
       await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
       return {
@@ -13927,7 +14638,15 @@ var postprocessEbml = async ({
       throw new Error("Expected block segment");
     }
     const hasReferenceBlock = ebml.value.find((c) => c.type === "ReferenceBlock");
-    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, webmState, offset, structureState2);
+    const sample = block2.value.length === 0 ? null : await getSampleFromBlock({
+      ebml: block2,
+      webmState,
+      offset,
+      structureState: structureState2,
+      callbacks,
+      logLevel,
+      onVideoTrack
+    });
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
         ...sample.partialVideoSample,
@@ -14128,9 +14847,9 @@ var initVideo = async ({ state }) => {
     });
     return;
   }
-  if (state.mp4HeaderSegment) {
+  if (state.m3uPlaylistContext?.mp4HeaderSegment) {
     Log.verbose(state.logLevel, "Detected ISO Base Media segment");
-    const moovAtom = getMoovFromFromIsoStructure(state.mp4HeaderSegment);
+    const moovAtom = getMoovFromFromIsoStructure(state.m3uPlaylistContext.mp4HeaderSegment);
     if (!moovAtom) {
       throw new Error("No moov box found");
     }
@@ -14353,19 +15072,33 @@ var parseLoop = async ({
       try {
         await triggerInfoEmit(state);
         await state.controller._internals.checkForAbortAndPause();
-        const skip = await runParseIteration({
+        const result = await runParseIteration({
           state
         });
-        if (skip !== null) {
-          state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
-          if (skip.skipTo === state.contentLength) {
-            state.iterator.discard(skip.skipTo - state.iterator.counter.getOffset());
+        if (result !== null && result.action === "fetch-more-data") {
+          Log.verbose(state.logLevel, `Need to fetch ${result.bytesNeeded} more bytes before we can continue`);
+          const startBytesRemaining = state.iterator.bytesRemaining();
+          while (true) {
+            const done = await fetchMoreData(state);
+            if (done) {
+              break;
+            }
+            if (state.iterator.bytesRemaining() - startBytesRemaining >= result.bytesNeeded) {
+              break;
+            }
+          }
+          continue;
+        }
+        if (result !== null && result.action === "skip") {
+          state.increaseSkippedBytes(result.skipTo - state.iterator.counter.getOffset());
+          if (result.skipTo === state.contentLength) {
+            state.iterator.discard(result.skipTo - state.iterator.counter.getOffset());
             Log.verbose(state.logLevel, "Skipped to end of file, not fetching.");
             break;
           }
           const seekStart = Date.now();
           await performSeek({
-            seekTo: skip.skipTo,
+            seekTo: result.skipTo,
             userInitiated: false,
             controller: state.controller,
             mediaSection: state.mediaSection,
@@ -14378,7 +15111,8 @@ var parseLoop = async ({
             readerInterface: state.readerInterface,
             fields: state.fields,
             src: state.src,
-            discardReadBytes: state.discardReadBytes
+            discardReadBytes: state.discardReadBytes,
+            prefetchCache: state.prefetchCache
           });
           state.timings.timeSeeking += Date.now() - seekStart;
         }
@@ -14485,6 +15219,9 @@ var setSeekingHints = ({
     setSeekingHintsForAac();
     return;
   }
+  if (hints.type === "m3u8-seeking-hints") {
+    return;
+  }
   throw new Error(`Unknown seeking hints type: ${hints}`);
 };
 
@@ -14640,12 +15377,16 @@ var getMfraAtom = async ({
   contentLength,
   readerInterface,
   controller,
-  parentSize
+  parentSize,
+  logLevel,
+  prefetchCache
 }) => {
   const result = await readerInterface.read({
     controller,
     range: [contentLength - parentSize, contentLength - 1],
-    src
+    src,
+    logLevel,
+    prefetchCache
   });
   const iterator = getArrayBufferIterator(new Uint8Array, parentSize);
   while (true) {
@@ -14665,12 +15406,16 @@ var getMfroAtom = async ({
   src,
   contentLength,
   readerInterface,
-  controller
+  controller,
+  logLevel,
+  prefetchCache
 }) => {
   const result = await readerInterface.read({
     controller,
     range: [contentLength - 16, contentLength - 1],
-    src
+    src,
+    logLevel,
+    prefetchCache
   });
   const { value } = await result.reader.reader.read();
   if (!value) {
@@ -14705,13 +15450,16 @@ var getMfraSeekingBox = async ({
   controller,
   readerInterface,
   src,
-  logLevel
+  logLevel,
+  prefetchCache
 }) => {
   const parentSize = await getMfroAtom({
     contentLength,
     controller,
     readerInterface,
-    src
+    src,
+    logLevel,
+    prefetchCache
   });
   if (!parentSize) {
     return null;
@@ -14721,7 +15469,9 @@ var getMfraSeekingBox = async ({
     controller,
     readerInterface,
     src,
-    parentSize
+    parentSize,
+    logLevel,
+    prefetchCache
   });
   mfraAtom.discard(8);
   return getIsoBaseMediaChildren({
@@ -14739,7 +15489,8 @@ var lazyMfraLoad = ({
   controller,
   readerInterface,
   src,
-  logLevel
+  logLevel,
+  prefetchCache
 }) => {
   let prom = null;
   let result = null;
@@ -14753,7 +15504,8 @@ var lazyMfraLoad = ({
       controller,
       readerInterface,
       src,
-      logLevel
+      logLevel,
+      prefetchCache
     }).then((boxes) => {
       Log.verbose(logLevel, "Lazily found mfra atom.");
       result = boxes;
@@ -14794,7 +15546,8 @@ var isoBaseMediaState = ({
   controller,
   readerInterface,
   src,
-  logLevel
+  logLevel,
+  prefetchCache
 }) => {
   return {
     flatSamples: cachedSamplePositionsState(),
@@ -14804,7 +15557,8 @@ var isoBaseMediaState = ({
       controller,
       readerInterface,
       src,
-      logLevel
+      logLevel,
+      prefetchCache
     }),
     moof: precomputedMoofState(),
     tfra: precomputedTfraState()
@@ -14821,6 +15575,7 @@ var keyframesState = () => {
     keyframes.push(keyframe);
   };
   const getKeyframes2 = () => {
+    keyframes.sort((a, b) => a.positionInBytes - b.positionInBytes);
     return keyframes;
   };
   const setFromSeekingHints = (keyframesFromHints) => {
@@ -14843,8 +15598,11 @@ var sampleSorter = ({
   const streamsWithTracks = [];
   const audioCallbacks = {};
   const videoCallbacks = {};
-  const latestSample = {};
+  let latestSample = {};
   return {
+    clearSamples: () => {
+      latestSample = {};
+    },
     addToStreamWithTrack: (src) => {
       streamsWithTracks.push(src);
     },
@@ -14917,6 +15675,8 @@ var m3uState = (logLevel) => {
   const hasEmittedAudioTrack = {};
   const hasEmittedDoneWithTracks = {};
   let hasFinishedManifest = false;
+  const seekToSecondsToProcess = {};
+  const nextSeekShouldSubtractChunks = {};
   let readyToIterateOverM3u = false;
   const allChunksProcessed = {};
   const m3uStreamRuns = {};
@@ -14978,6 +15738,11 @@ var m3uState = (logLevel) => {
     setAllChunksProcessed: (src) => {
       allChunksProcessed[src] = true;
     },
+    clearAllChunksProcessed: () => {
+      Object.keys(allChunksProcessed).forEach((key) => {
+        delete allChunksProcessed[key];
+      });
+    },
     getAllChunksProcessedForPlaylist,
     getAllChunksProcessedOverall: () => {
       if (!selectedMainPlaylist) {
@@ -15005,6 +15770,11 @@ var m3uState = (logLevel) => {
     getTrackDone: (playlistUrl) => {
       return tracksDone[playlistUrl];
     },
+    clearTracksDone: () => {
+      Object.keys(tracksDone).forEach((key) => {
+        delete tracksDone[key];
+      });
+    },
     getM3uStreamRun: (playlistUrl) => m3uStreamRuns[playlistUrl] ?? null,
     abortM3UStreamRuns: () => {
       const values = Object.values(m3uStreamRuns);
@@ -15023,7 +15793,15 @@ var m3uState = (logLevel) => {
     getSelectedPlaylists,
     sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist }),
     setMp4HeaderSegment,
-    getMp4HeaderSegment
+    getMp4HeaderSegment,
+    setSeekToSecondsToProcess: (playlistUrl, m3uSeek) => {
+      seekToSecondsToProcess[playlistUrl] = m3uSeek;
+    },
+    getSeekToSecondsToProcess: (playlistUrl) => seekToSecondsToProcess[playlistUrl] ?? null,
+    setNextSeekShouldSubtractChunks: (playlistUrl, chunks) => {
+      nextSeekShouldSubtractChunks[playlistUrl] = chunks;
+    },
+    getNextSeekShouldSubtractChunks: (playlistUrl) => nextSeekShouldSubtractChunks[playlistUrl] ?? 0
   };
 };
 
@@ -15072,12 +15850,15 @@ var fetchWebmCues = async ({
   readerInterface,
   controller,
   position,
-  logLevel
+  logLevel,
+  prefetchCache
 }) => {
   const result = await readerInterface.read({
     controller,
     range: position,
-    src
+    src,
+    logLevel,
+    prefetchCache
   });
   const { value } = await result.reader.reader.read();
   if (!value) {
@@ -15104,7 +15885,8 @@ var lazyCuesFetch = ({
   controller,
   logLevel,
   readerInterface,
-  src
+  src,
+  prefetchCache
 }) => {
   let prom = null;
   let sOffset = null;
@@ -15126,7 +15908,8 @@ var lazyCuesFetch = ({
       logLevel,
       position,
       readerInterface,
-      src
+      src,
+      prefetchCache
     }).then((cues) => {
       Log.verbose(logLevel, "Cues loaded");
       result = cues;
@@ -15188,7 +15971,8 @@ var webmState = ({
   controller,
   logLevel,
   readerInterface,
-  src
+  src,
+  prefetchCache
 }) => {
   const trackEntries = {};
   const onTrackEntrySegment = (trackEntry2) => {
@@ -15249,7 +16033,8 @@ var webmState = ({
     controller,
     logLevel,
     readerInterface,
-    src
+    src,
+    prefetchCache
   });
   const getTimeStampMapForSeekingHints = () => {
     return timestampMap;
@@ -15330,13 +16115,16 @@ var fetchIdx1 = async ({
   readerInterface,
   controller,
   position,
-  logLevel
+  logLevel,
+  prefetchCache
 }) => {
   Log.verbose(logLevel, "Making request to fetch idx1 from ", src, "position", position);
   const result = await readerInterface.read({
     controller,
     range: position,
-    src
+    src,
+    logLevel,
+    prefetchCache
   });
   const iterator = getArrayBufferIterator(new Uint8Array, Infinity);
   while (true) {
@@ -15367,7 +16155,8 @@ var lazyIdx1Fetch = ({
   controller,
   logLevel,
   readerInterface,
-  src
+  src,
+  prefetchCache
 }) => {
   let prom = null;
   let result = null;
@@ -15383,7 +16172,8 @@ var lazyIdx1Fetch = ({
       logLevel,
       position,
       readerInterface,
-      src
+      src,
+      prefetchCache
     }).then((entries) => {
       prom = null;
       result = entries;
@@ -15504,7 +16294,8 @@ var riffSpecificState = ({
   controller,
   logLevel,
   readerInterface,
-  src
+  src,
+  prefetchCache
 }) => {
   let avcProfile = null;
   let nextTrackIndex = 0;
@@ -15523,7 +16314,8 @@ var riffSpecificState = ({
     controller,
     logLevel,
     readerInterface,
-    src
+    src,
+    prefetchCache
   });
   const sampleCounter = riffSampleCounter();
   return {
@@ -15544,7 +16336,7 @@ var riffSpecificState = ({
 };
 
 // src/state/sample-callbacks.ts
-var sampleCallback = ({
+var callbacksState = ({
   controller,
   hasAudioTrackHandlers,
   hasVideoTrackHandlers,
@@ -15851,14 +16643,15 @@ var makeParserState = ({
   onDiscardedData,
   selectM3uStreamFn,
   selectM3uAssociatedPlaylistsFn,
-  mp4HeaderSegment,
+  m3uPlaylistContext,
   contentType,
   name,
   callbacks,
   fieldsInReturnValue,
   mimeType,
   initialReaderInstance,
-  makeSamplesStartAtZero
+  makeSamplesStartAtZero,
+  prefetchCache
 }) => {
   let skippedBytes = 0;
   const returnValue = {};
@@ -15890,22 +16683,35 @@ var makeParserState = ({
     callbacks
   });
   return {
-    riff: riffSpecificState({ controller, logLevel, readerInterface, src }),
+    riff: riffSpecificState({
+      controller,
+      logLevel,
+      readerInterface,
+      src,
+      prefetchCache
+    }),
     transportStream: transportStreamState(),
-    webm: webmState({ controller, logLevel, readerInterface, src }),
+    webm: webmState({
+      controller,
+      logLevel,
+      readerInterface,
+      src,
+      prefetchCache
+    }),
     iso: isoBaseMediaState({
       contentLength,
       controller,
       readerInterface,
       src,
-      logLevel
+      logLevel,
+      prefetchCache
     }),
     mp3,
     aac: aacState(),
     flac: flacState(),
     m3u: m3uState(logLevel),
     timings,
-    callbacks: sampleCallback({
+    callbacks: callbacksState({
       controller,
       hasAudioTrackHandlers,
       hasVideoTrackHandlers,
@@ -15943,7 +16749,7 @@ var makeParserState = ({
     discardReadBytes,
     selectM3uStreamFn,
     selectM3uAssociatedPlaylistsFn,
-    mp4HeaderSegment,
+    m3uPlaylistContext,
     contentType,
     name,
     returnValue,
@@ -15953,7 +16759,8 @@ var makeParserState = ({
     errored,
     currentReader: currentReaderState,
     seekInfiniteLoop,
-    makeSamplesStartAtZero
+    makeSamplesStartAtZero,
+    prefetchCache
   };
 };
 
@@ -16032,7 +16839,7 @@ var internalParseMedia = async function({
   apiName,
   selectM3uStream: selectM3uStreamFn,
   selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn,
-  mp4HeaderSegment,
+  m3uPlaylistContext,
   makeSamplesStartAtZero,
   seekingHints,
   ...more
@@ -16044,6 +16851,7 @@ var internalParseMedia = async function({
     apiName
   });
   Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src instanceof URL ? src.toString() : src instanceof File ? src.name : src.toString()}`);
+  const prefetchCache = new Map;
   const {
     reader: readerInstance,
     contentLength,
@@ -16051,7 +16859,13 @@ var internalParseMedia = async function({
     contentType,
     supportsContentRange,
     needsContentRange
-  } = await readerInterface.read({ src, range: null, controller });
+  } = await readerInterface.read({
+    src,
+    range: null,
+    controller,
+    logLevel,
+    prefetchCache
+  });
   if (contentLength === null) {
     throw new Error(`Cannot read media ${src} without a content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.`);
   }
@@ -16074,14 +16888,15 @@ var internalParseMedia = async function({
     onDiscardedData,
     selectM3uStreamFn,
     selectM3uAssociatedPlaylistsFn,
-    mp4HeaderSegment,
+    m3uPlaylistContext,
     contentType,
     name,
     callbacks: more,
     fieldsInReturnValue: _fieldsInReturnValue ?? {},
     mimeType: contentType,
     initialReaderInstance: readerInstance,
-    makeSamplesStartAtZero
+    makeSamplesStartAtZero,
+    prefetchCache
   });
   if (seekingHints) {
     setSeekingHints({ hints: seekingHints, state });
@@ -16091,7 +16906,7 @@ var internalParseMedia = async function({
     keyframesState: state.keyframes,
     webmState: state.webm,
     structureState: state.structure,
-    mp4HeaderSegment: state.mp4HeaderSegment,
+    m3uPlaylistContext: state.m3uPlaylistContext,
     mediaSectionState: state.mediaSection,
     isoState: state.iso,
     transportStream: state.transportStream,
@@ -16120,6 +16935,7 @@ var internalParseMedia = async function({
   state.iterator?.destroy();
   state.callbacks.tracks.ensureHasTracksAtEnd(state.fields);
   state.m3u.abortM3UStreamRuns();
+  prefetchCache.clear();
   if (state.errored) {
     throw state.errored;
   }
@@ -16137,7 +16953,7 @@ var forwardMediaParserControllerToWorker = (controller) => {
       return;
     }
     if (message.type === "request-seek") {
-      controller._experimentalSeek(message.payload);
+      controller.seek(message.payload);
       return;
     }
     if (message.type === "request-get-seeking-hints") {
@@ -16218,6 +17034,22 @@ var serializeError = ({
       seekingHints
     };
   }
+  if (error.name === "AbortError") {
+    return {
+      type: "response-error",
+      errorName: "AbortError",
+      errorMessage: error.message,
+      errorStack: error.stack ?? ""
+    };
+  }
+  if (error.name === "NotReadableError") {
+    return {
+      type: "response-error",
+      errorName: "NotReadableError",
+      errorMessage: error.message,
+      errorStack: error.stack ?? ""
+    };
+  }
   if (error.name !== "Error") {
     Log.warn(logLevel, `Original error was of type ${error.name} did not properly propagate`);
   }
@@ -16267,7 +17099,7 @@ var startParsing = async (message, reader) => {
     acknowledgeRemotionLicense,
     logLevel: userLogLevel,
     progressIntervalInMs,
-    mp4HeaderSegment,
+    m3uPlaylistContext,
     seekingHints,
     makeSamplesStartAtZero
   } = payload;
@@ -16503,7 +17335,7 @@ var startParsing = async (message, reader) => {
         }
         return res.value;
       } : defaultSelectM3uStreamFn,
-      mp4HeaderSegment: mp4HeaderSegment ?? null,
+      m3uPlaylistContext: m3uPlaylistContext ?? null,
       selectM3uAssociatedPlaylists: postM3uAssociatedPlaylistsSelection ? async (playlists) => {
         const res = await executeCallback({
           callbackType: "m3u-associated-playlists-selection",