@remotion/media-parser 4.0.284 → 4.0.286

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

@@ -361,7 +361,7 @@ var webFileReadContent = ({ src, range, controller }) => {
           }
         },
         contentLength: src.size,
-        name: src.name,
+        name: src instanceof File ? src.name : src.toString(),
         supportsContentRange: true,
         contentType: src.type,
         needsContentRange: true
@@ -1943,12 +1943,13 @@ var isTransportStream = (data) => {
   return data[0] === 71 && data[188] === 71;
 };
 var isMp3 = (data) => {
-  const mpegPattern = new Uint8Array([255, 243, 228, 100]);
+  const mpegPattern = new Uint8Array([255, 243]);
+  const mpegPattern2 = new Uint8Array([255, 251]);
   const id3v4Pattern = new Uint8Array([73, 68, 51, 4]);
   const id3v3Pattern = new Uint8Array([73, 68, 51, 3]);
   const id3v2Pattern = new Uint8Array([73, 68, 51, 2]);
   const subarray = data.subarray(0, 4);
-  return matchesPattern(mpegPattern)(subarray) || matchesPattern(id3v4Pattern)(subarray) || matchesPattern(id3v3Pattern)(subarray) || matchesPattern(id3v2Pattern)(subarray);
+  return matchesPattern(mpegPattern)(subarray) || matchesPattern(mpegPattern2)(subarray) || matchesPattern(id3v4Pattern)(subarray) || matchesPattern(id3v3Pattern)(subarray) || matchesPattern(id3v2Pattern)(subarray);
 };
 var isGif = (data) => {
   const gifPattern = new Uint8Array([71, 73, 70, 56]);
@@ -3326,8 +3327,15 @@ var findProgramAssociationTableOrThrow = (structure) => {
   }
   return box;
 };
-var findProgramMapTableOrThrow = (structure) => {
+var findProgramMapOrNull = (structure) => {
   const box = structure.boxes.find((b) => b.type === "transport-stream-pmt-box");
+  if (!box) {
+    return null;
+  }
+  return box;
+};
+var findProgramMapTableOrThrow = (structure) => {
+  const box = findProgramMapOrNull(structure);
   if (!box) {
     throw new Error("No PMT box found");
   }
@@ -3948,10 +3956,10 @@ var getTrack = ({
 
 // src/containers/webm/get-ready-tracks.ts
 var getTracksFromMatroska = ({
-  state
+  structureState,
+  webmState
 }) => {
-  const webmState = state.webm;
-  const structure = state.structure.getMatroskaStructure();
+  const structure = structureState.getMatroskaStructure();
   const mainSegment = getMainSegment(structure.boxes);
   if (!mainSegment) {
     throw new Error("No main segment");
@@ -3992,14 +4000,18 @@ var getTracksFromMatroska = ({
   }
   return { missingInfo, resolved: resolvedTracks };
 };
-var matroskaHasTracks = (state) => {
-  const structure = state.structure.getMatroskaStructure();
+var matroskaHasTracks = ({
+  structureState,
+  webmState
+}) => {
+  const structure = structureState.getMatroskaStructure();
   const mainSegment = getMainSegment(structure.boxes);
   if (!mainSegment) {
     return false;
   }
   return getTracksSegment(mainSegment) !== null && getTracksFromMatroska({
-    state
+    structureState,
+    webmState
   }).missingInfo.length === 0;
 };
 
@@ -4014,7 +4026,10 @@ var isoBaseMediaHasTracks = (state) => {
 var getHasTracks = (state) => {
   const structure = state.structure.getStructure();
   if (structure.type === "matroska") {
-    return matroskaHasTracks(state);
+    return matroskaHasTracks({
+      structureState: state.structure,
+      webmState: state.webm
+    });
   }
   if (structure.type === "iso-base-media") {
     return isoBaseMediaHasTracks(state);
@@ -4047,7 +4062,8 @@ var getCategorizedTracksFromMatroska = (state) => {
   const audioTracks = [];
   const otherTracks = [];
   const { resolved } = getTracksFromMatroska({
-    state
+    structureState: state.structure,
+    webmState: state.webm
   });
   for (const track of resolved) {
     if (track.type === "video") {
@@ -4270,6 +4286,9 @@ var getAudioCodecFromTrak = (trak) => {
 var isLpcmAudioCodec = (trak) => {
   return getAudioCodecFromTrak(trak)?.format === "lpcm";
 };
+var isIn24AudioCodec = (trak) => {
+  return getAudioCodecFromTrak(trak)?.format === "in24";
+};
 var getAudioCodecStringFromTrak = (trak) => {
   const codec = getAudioCodecFromTrak(trak);
   if (!codec) {
@@ -4281,6 +4300,12 @@ var getAudioCodecStringFromTrak = (trak) => {
       description: codec.description
     };
   }
+  if (codec.format === "in24") {
+    return {
+      codecString: "pcm-s24",
+      description: undefined
+    };
+  }
   const codecStringWithoutMp3Exception = [
     codec.format,
     codec.primarySpecificator ? codec.primarySpecificator.toString(16) : null,
@@ -4296,6 +4321,9 @@ var getAudioCodecFromAudioCodecInfo = (codec) => {
   if (codec.format === "twos") {
     return "pcm-s16";
   }
+  if (codec.format === "in24") {
+    return "pcm-s24";
+  }
   if (codec.format === "lpcm") {
     return "pcm-s16";
   }
@@ -4547,8 +4575,8 @@ var getSamplePositions = ({
   return samples;
 };
 
-// src/get-sample-positions-from-lpcm.ts
-var getSamplePositionsFromLpcm = (trakBox) => {
+// src/get-sample-positions-from-mp4.ts
+var getGroupedSamplesPositionsFromMp4 = (trakBox) => {
   const stscBox = getStscBox(trakBox);
   const stszBox = getStszBox(trakBox);
   const stcoBox = getStcoBox(trakBox);
@@ -4591,8 +4619,9 @@ var getSamplePositionsFromLpcm = (trakBox) => {
 var collectSamplePositionsFromTrak = (trakBox) => {
   const isLpcm = isLpcmAudioCodec(trakBox);
   const timescaleAndDuration = getTimescaleAndDuration(trakBox);
-  if (isLpcm) {
-    return getSamplePositionsFromLpcm(trakBox);
+  const isIn24 = isIn24AudioCodec(trakBox);
+  if (isLpcm || isIn24) {
+    return getGroupedSamplesPositionsFromMp4(trakBox);
   }
   const stszBox = getStszBox(trakBox);
   const stcoBox = getStcoBox(trakBox);
@@ -5390,9 +5419,16 @@ var mediaSectionState = () => {
   const mediaSections = [];
   const addMediaSection = (section) => {
     const overlaps = mediaSections.some((existingSection) => section.start < existingSection.start + existingSection.size && section.start + section.size > existingSection.start);
-    if (!overlaps) {
-      mediaSections.push(section);
+    if (overlaps) {
+      return;
+    }
+    for (let i = mediaSections.length - 1;i >= 0; i--) {
+      const existingSection = mediaSections[i];
+      if (section.start <= existingSection.start && section.start + section.size >= existingSection.start + existingSection.size) {
+        mediaSections.splice(i, 1);
+      }
     }
+    mediaSections.push(section);
   };
   const getMediaSections = () => {
     return mediaSections;
@@ -5608,33 +5644,6 @@ var getSeekingByteFromIsoBaseMedia = async ({
   };
 };
 
-// src/containers/iso-base-media/get-seeking-info-from-mp4.ts
-var getSeekingInfoFromMp4 = ({
-  structureState,
-  isoState,
-  mp4HeaderSegment,
-  mediaSectionState: mediaSectionState2
-}) => {
-  const structure = structureState.getIsoStructure();
-  const moovAtom = getMoovBoxFromState({
-    isoState,
-    mp4HeaderSegment,
-    structureState
-  });
-  const moofBoxes = getMoofBoxes(structure.boxes);
-  const tfraBoxes = getTfraBoxes(structure);
-  if (!moovAtom) {
-    return null;
-  }
-  return {
-    type: "iso-base-media-seeking-info",
-    moovBox: moovAtom,
-    moofBoxes,
-    tfraBoxes,
-    mediaSections: mediaSectionState2.getMediaSections()
-  };
-};
-
 // src/containers/wav/get-seeking-byte.ts
 var WAVE_SAMPLES_PER_SECOND = 25;
 var getSeekingByteFromWav = ({
@@ -5651,482 +5660,1204 @@ var getSeekingByteFromWav = ({
   });
 };
 
-// src/containers/wav/get-seeking-info.ts
-var getSeekingInfoFromWav = ({
-  structure,
-  mediaSectionState: mediaSectionState2
+// src/containers/webm/seek/get-seeking-byte.ts
+var toSeconds = (timeInTimescale, track) => {
+  return timeInTimescale / track.timescale * 1000;
+};
+var findBiggestCueBeforeTime = ({
+  cues,
+  time,
+  track
 }) => {
-  const fmtBox = structure.boxes.find((box) => box.type === "wav-fmt");
-  if (!fmtBox) {
-    return null;
+  let biggestCueBeforeTime;
+  for (const cue of cues) {
+    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+      biggestCueBeforeTime = cue;
+    }
   }
-  const mediaSection = mediaSectionState2.getMediaSections();
-  if (mediaSection.length !== 1) {
-    return null;
+  return biggestCueBeforeTime;
+};
+var findKeyframeBeforeTime2 = ({
+  keyframes,
+  time
+}) => {
+  let keyframeBeforeTime;
+  for (const keyframe of keyframes) {
+    if (keyframe.decodingTimeInSeconds < time && (!keyframeBeforeTime || keyframe.decodingTimeInSeconds > keyframeBeforeTime.decodingTimeInSeconds)) {
+      keyframeBeforeTime = keyframe;
+    }
   }
-  return {
-    type: "wav-seeking-info",
-    sampleRate: fmtBox.sampleRate,
-    blockAlign: fmtBox.blockAlign,
-    mediaSections: mediaSection[0]
-  };
+  return keyframeBeforeTime?.positionInBytes ?? null;
 };
-
-// src/get-seeking-info.ts
-var getSeekingInfo = ({
-  structureState,
-  mp4HeaderSegment,
-  mediaSectionState: mediaSectionState2,
-  isoState
+var getByteFromCues = ({
+  cuesResponse,
+  time,
+  info,
+  logLevel
 }) => {
-  const structure = structureState.getStructureOrNull();
-  if (!structure) {
+  if (!cuesResponse) {
+    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
     return null;
   }
-  if (structure.type === "iso-base-media") {
-    return getSeekingInfoFromMp4({
-      structureState,
-      isoState,
-      mp4HeaderSegment,
-      mediaSectionState: mediaSectionState2
-    });
-  }
-  if (structure.type === "wav") {
-    return getSeekingInfoFromWav({
-      structure,
-      mediaSectionState: mediaSectionState2
-    });
+  const { cues, segmentOffset } = cuesResponse;
+  Log.trace(logLevel, "Has Matroska cues. Will use them to perform a seek.");
+  const biggestCueBeforeTime = findBiggestCueBeforeTime({
+    cues,
+    time,
+    track: info.track
+  });
+  if (!biggestCueBeforeTime) {
+    return null;
   }
-  throw new Error(`Seeking is not supported for this format: ${structure.type}`);
+  return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
 };
-var getSeekingByte = ({
-  info,
+var getSeekingByteFromMatroska = async ({
   time,
+  webmState,
+  info,
   logLevel,
-  currentPosition,
-  isoState
+  mediaSection,
+  keyframes
 }) => {
-  if (info.type === "iso-base-media-seeking-info") {
-    return getSeekingByteFromIsoBaseMedia({
-      info,
-      time,
-      logLevel,
-      currentPosition,
-      isoState
-    });
+  if (!info.track) {
+    Log.trace(logLevel, "No video track found, cannot seek yet");
+    return {
+      type: "valid-but-must-wait"
+    };
   }
-  if (info.type === "wav-seeking-info") {
-    return getSeekingByteFromWav({
-      info,
-      time
-    });
+  const cuesResponse = await webmState.cues.getLoadedCues();
+  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
+    keyframes: keyframes.getKeyframes(),
+    time
+  });
+  const byteFromCues = getByteFromCues({
+    cuesResponse,
+    time,
+    info,
+    logLevel
+  });
+  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
+  const seekPossibilities = [
+    byteFromCues,
+    byteFromObservedKeyframe,
+    byteFromFirstMediaSection
+  ].filter((n) => n !== null);
+  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
+  if (byteToSeekTo === null) {
+    return {
+      type: "invalid"
+    };
   }
-  throw new Error(`Unknown seeking info type: ${info}`);
+  mediaSection.addMediaSection({
+    start: byteToSeekTo,
+    size: 1
+  });
+  return {
+    type: "do-seek",
+    byte: byteToSeekTo
+  };
 };
 
-// src/seek-backwards.ts
-var seekBackwards = async ({
-  iterator,
-  seekTo,
-  readerInterface,
-  src,
-  controller,
-  logLevel,
-  currentReader
+// src/convert-audio-or-video-sample.ts
+var TARGET_TIMESCALE = 1e6;
+var fixFloat = (value) => {
+  if (value % 1 < 0.0000001) {
+    return Math.floor(value);
+  }
+  if (value % 1 > 0.9999999) {
+    return Math.ceil(value);
+  }
+  return value;
+};
+var convertAudioOrVideoSampleToWebCodecsTimestamps = ({
+  sample,
+  timescale
 }) => {
-  const howManyBytesNotYetDiscarded = iterator.counter.getDiscardedOffset();
-  const howManyBytesWeCanGoBack = iterator.counter.getOffset() - howManyBytesNotYetDiscarded;
-  if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
-    iterator.skipTo(seekTo);
-    return;
+  if (timescale === TARGET_TIMESCALE) {
+    return sample;
   }
-  const time = Date.now();
-  Log.verbose(logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
-  const { reader: newReader } = await readerInterface.read({
-    src,
-    range: seekTo,
-    controller
-  });
-  iterator.replaceData(new Uint8Array([]), seekTo);
-  Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
-  currentReader.setCurrent(newReader);
+  const { cts, dts, timestamp } = sample;
+  return {
+    cts: fixFloat(cts * (TARGET_TIMESCALE / timescale)),
+    dts: fixFloat(dts * (TARGET_TIMESCALE / timescale)),
+    timestamp: fixFloat(timestamp * (TARGET_TIMESCALE / timescale)),
+    duration: sample.duration === undefined ? undefined : fixFloat(sample.duration * (TARGET_TIMESCALE / timescale)),
+    data: sample.data,
+    trackId: sample.trackId,
+    type: sample.type,
+    offset: sample.offset,
+    timescale: TARGET_TIMESCALE
+  };
 };
 
-// src/state/need-samples-for-fields.ts
-var fieldsNeedSamplesMap = {
-  slowDurationInSeconds: true,
-  slowFps: true,
-  slowKeyframes: true,
-  slowNumberOfFrames: true,
-  audioCodec: false,
-  container: false,
-  dimensions: false,
-  durationInSeconds: false,
-  fps: false,
-  internalStats: false,
-  isHdr: false,
-  name: false,
-  rotation: false,
-  size: false,
-  structure: false,
-  tracks: false,
-  unrotatedDimensions: false,
-  videoCodec: false,
-  metadata: false,
-  location: false,
-  mimeType: false,
-  keyframes: false,
-  images: false,
-  numberOfAudioChannels: false,
-  sampleRate: false,
-  slowAudioBitrate: true,
-  slowVideoBitrate: true,
-  m3uStreams: false
-};
-var needsToIterateOverSamples = ({
-  fields,
-  emittedFields
+// src/emit-audio-sample.ts
+var emitAudioSample = async ({
+  trackId,
+  audioSample,
+  callbacks
 }) => {
-  const keys = Object.keys(fields ?? {});
-  const selectedKeys = keys.filter((k) => fields[k]);
-  return selectedKeys.some((k) => fieldsNeedSamplesMap[k] && !emittedFields[k]);
+  await callbacks.onAudioSample(trackId, audioSample);
 };
-
-// src/disallow-forward-seek-if-samples-are-needed.ts
-var disallowForwardSeekIfSamplesAreNeeded = ({
-  seekTo,
-  previousPosition,
-  fields
+var emitVideoSample = async ({
+  trackId,
+  videoSample,
+  callbacks
 }) => {
-  const fieldsNeedingSamples = Object.entries(fields).filter(([, value]) => value).map(([key]) => key).filter((key) => fieldsNeedSamplesMap[key]);
-  if (fieldsNeedingSamples.length > 0) {
-    throw new Error(`Forward seeking is not allowed when the following fields are requested from parseMedia(): ${fieldsNeedingSamples.join(", ")}. Seek was from 0x${previousPosition.toString(16)} to 0x${seekTo.toString(16)}. Either don't seek forward, or don't request these fields.`);
-  }
+  await callbacks.onVideoSample(trackId, videoSample);
 };
 
-// src/seek-forwards.ts
-var seekForward = async ({
-  seekTo,
-  userInitiated,
-  iterator,
-  fields,
-  logLevel,
-  currentReader,
-  readerInterface,
-  src,
-  controller,
-  discardReadBytes
+// src/register-track.ts
+var registerVideoTrack = async ({
+  track,
+  container,
+  logLevel,
+  onVideoTrack,
+  registerVideoSampleCallback,
+  tracks: tracks2
 }) => {
-  if (userInitiated) {
-    disallowForwardSeekIfSamplesAreNeeded({
-      fields,
-      seekTo,
-      previousPosition: iterator.counter.getOffset()
-    });
+  if (tracks2.getTracks().find((t) => t.trackId === track.trackId)) {
+    Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
+    return null;
   }
-  const alreadyHasBuffer = iterator.bytesRemaining() >= seekTo - iterator.counter.getOffset();
-  Log.verbose(logLevel, `Performing seek from ${iterator.counter.getOffset()} to ${seekTo}`);
-  if (alreadyHasBuffer) {
-    iterator.skipTo(seekTo);
-    Log.verbose(logLevel, `Already read ahead enough, skipping forward`);
-    return;
+  if (track.type !== "video") {
+    throw new Error("Expected video track");
   }
-  const time = Date.now();
-  Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
-  const { reader: newReader } = await readerInterface.read({
-    src,
-    range: seekTo,
-    controller
+  tracks2.addTrack(track);
+  if (!onVideoTrack) {
+    return null;
+  }
+  const callback = await onVideoTrack({
+    track,
+    container
   });
-  iterator.skipTo(seekTo);
-  await discardReadBytes(true);
-  Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
-  currentReader.setCurrent(newReader);
+  await registerVideoSampleCallback(track.trackId, callback ?? null);
+  return callback;
 };
-
-// src/perform-seek.ts
-var performSeek = async ({
-  seekTo,
-  userInitiated,
-  controller,
-  mediaSection,
-  iterator,
-  seekInfiniteLoop,
+var registerAudioTrack = async ({
+  track,
+  container,
+  tracks: tracks2,
   logLevel,
-  mode,
-  contentLength,
-  currentReader,
-  readerInterface,
-  src,
-  discardReadBytes,
-  fields
+  onAudioTrack,
+  registerAudioSampleCallback
 }) => {
-  const byteInMediaSection = isByteInMediaSection({
-    position: seekTo,
-    mediaSections: mediaSection.getMediaSections()
-  });
-  if (byteInMediaSection !== "in-section" && userInitiated) {
-    const sections = mediaSection.getMediaSections();
-    const sectionStrings = sections.map((section) => {
-      return `start: ${section.start}, end: ${section.size + section.start}`;
-    });
-    throw new Error(`Cannot seek to a byte that is not in the video section. Seeking to: ${seekTo}, sections: ${sectionStrings.join(" | ")}`);
-  }
-  seekInfiniteLoop.registerSeek(seekTo);
-  if (seekTo <= iterator.counter.getOffset() && mode === "download") {
-    throw new Error(`Seeking backwards is not supported in parseAndDownloadMedia() mode. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
-  }
-  if (seekTo > contentLength) {
-    throw new Error(`Cannot seek beyond the end of the file: ${seekTo} > ${contentLength}`);
+  if (tracks2.getTracks().find((t) => t.trackId === track.trackId)) {
+    Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
+    return null;
   }
-  if (mode === "download") {
-    Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because in download mode`);
-    iterator.discard(seekTo - iterator.counter.getOffset());
-    return;
+  if (track.type !== "audio") {
+    throw new Error("Expected audio track");
   }
-  await controller._internals.checkForAbortAndPause();
-  const alreadyAtByte = iterator.counter.getOffset() === seekTo;
-  if (alreadyAtByte) {
-    Log.verbose(logLevel, `Already at the desired position, seeking done`);
-    controller._internals.performedSeeksSignal.markLastSeekAsUserInitiated();
-    return;
+  tracks2.addTrack(track);
+  if (!onAudioTrack) {
+    return null;
   }
-  const skippingForward = seekTo > iterator.counter.getOffset();
-  controller._internals.performedSeeksSignal.recordSeek({
-    from: iterator.counter.getOffset(),
-    to: seekTo,
-    type: userInitiated ? "user-initiated" : "internal"
+  const callback = await onAudioTrack({
+    track,
+    container
   });
-  if (skippingForward) {
-    await seekForward({
-      seekTo,
-      userInitiated,
-      iterator,
-      fields,
-      logLevel,
-      currentReader,
-      readerInterface,
-      src,
-      controller,
-      discardReadBytes
-    });
-  } else {
-    await seekBackwards({
-      controller,
-      seekTo,
-      iterator,
-      logLevel,
-      currentReader,
-      readerInterface,
-      src
-    });
-  }
-  await controller._internals.checkForAbortAndPause();
+  await registerAudioSampleCallback(track.trackId, callback ?? null);
+  return callback;
 };
-
-// src/work-on-seek-request.ts
-var turnSeekIntoByte = async ({
-  seek: seek2,
-  mediaSectionState: mediaSectionState2,
-  logLevel,
-  iterator,
-  structureState,
-  mp4HeaderSegment,
-  isoState
+var registerVideoTrackWhenProfileIsAvailable = ({
+  state,
+  track,
+  container
 }) => {
-  const mediaSections = mediaSectionState2.getMediaSections();
-  if (mediaSections.length === 0) {
-    Log.trace(logLevel, "No video sections defined, cannot seek yet");
-    return {
-      type: "valid-but-must-wait"
-    };
-  }
-  if (seek2.type === "keyframe-before-time-in-seconds") {
-    const seekingInfo = getSeekingInfo({
-      structureState,
-      mp4HeaderSegment,
-      mediaSectionState: mediaSectionState2,
-      isoState
-    });
-    if (!seekingInfo) {
-      Log.trace(logLevel, "No seeking info, cannot seek yet");
-      return {
-        type: "valid-but-must-wait"
-      };
-    }
-    const seekingByte = await getSeekingByte({
-      info: seekingInfo,
-      time: seek2.time,
-      logLevel,
-      currentPosition: iterator.counter.getOffset(),
-      isoState
+  state.riff.registerOnAvcProfileCallback(async (profile) => {
+    await registerVideoTrack({
+      track: addAvcProfileToTrack(track, profile),
+      container,
+      logLevel: state.logLevel,
+      onVideoTrack: state.onVideoTrack,
+      registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
+      tracks: state.callbacks.tracks
     });
-    return seekingByte;
-  }
-  if (seek2.type === "byte") {
+  });
+};
+
+// src/containers/avc/interpret-sps.ts
+var getDimensionsFromSps = (sps) => {
+  const height = sps.pic_height_in_map_units_minus1;
+  const width = sps.pic_width_in_mbs_minus1;
+  return {
+    height: (height + 1) * 16 - (sps.frame_crop_bottom_offset ?? 0) * 2 - (sps.frame_crop_top_offset ?? 0) * 2,
+    width: (width + 1) * 16 - (sps.frame_crop_right_offset ?? 0) * 2 - (sps.frame_crop_left_offset ?? 0) * 2
+  };
+};
+var getSampleAspectRatioFromSps = (sps) => {
+  if (sps.vui_parameters?.sar_height && sps.vui_parameters.sar_width) {
     return {
-      type: "do-seek",
-      byte: seek2.byte
+      width: sps.vui_parameters.sar_width,
+      height: sps.vui_parameters.sar_height
     };
   }
-  throw new Error(`Cannot process seek request for ${seek2}: ${JSON.stringify(seek2)}`);
+  return {
+    width: 1,
+    height: 1
+  };
 };
-var getWorkOnSeekRequestOptions = (state) => {
+var getVideoColorFromSps = (sps) => {
+  const matrixCoefficients2 = sps.vui_parameters?.matrix_coefficients;
+  const transferCharacteristics2 = sps.vui_parameters?.transfer_characteristics;
+  const colorPrimaries = sps.vui_parameters?.colour_primaries;
   return {
-    logLevel: state.logLevel,
-    controller: state.controller,
-    isoState: state.iso,
-    iterator: state.iterator,
-    structureState: state.structure,
-    src: state.src,
-    contentLength: state.contentLength,
-    readerInterface: state.readerInterface,
-    mediaSection: state.mediaSection,
-    mp4HeaderSegment: state.mp4HeaderSegment,
-    mode: state.mode,
-    seekInfiniteLoop: state.seekInfiniteLoop,
-    currentReader: state.currentReader,
-    discardReadBytes: state.discardReadBytes,
-    fields: state.fields
+    matrixCoefficients: matrixCoefficients2 ? getMatrixCoefficientsFromIndex(matrixCoefficients2) : null,
+    transferCharacteristics: transferCharacteristics2 ? getTransferCharacteristicsFromIndex(transferCharacteristics2) : null,
+    primaries: colorPrimaries ? getPrimariesFromIndex(colorPrimaries) : null,
+    fullRange: sps.vui_parameters?.video_full_range_flag ?? null
   };
 };
-var workOnSeekRequest = async (options) => {
-  const {
-    logLevel,
-    controller,
-    mediaSection,
-    mp4HeaderSegment,
-    isoState,
-    iterator,
-    structureState,
-    src,
-    contentLength,
-    readerInterface,
-    mode,
-    seekInfiniteLoop,
-    currentReader,
-    discardReadBytes,
-    fields
-  } = options;
-  const seek2 = controller._internals.seekSignal.getSeek();
-  if (!seek2) {
-    return;
-  }
-  Log.trace(logLevel, `Has seek request: ${JSON.stringify(seek2)}`);
-  const resolution = await turnSeekIntoByte({
-    seek: seek2,
-    mediaSectionState: mediaSection,
-    logLevel,
-    iterator,
-    structureState,
-    mp4HeaderSegment,
-    isoState
-  });
-  Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
-  if (resolution.type === "intermediary-seek") {
-    await performSeek({
-      seekTo: resolution.byte,
-      userInitiated: false,
-      controller,
-      mediaSection,
-      iterator,
-      logLevel,
-      mode,
-      contentLength,
-      seekInfiniteLoop,
-      currentReader,
-      readerInterface,
-      src,
-      discardReadBytes,
-      fields
-    });
-    return;
+
+// src/containers/avc/key.ts
+var getKeyFrameOrDeltaFromAvcInfo = (infos) => {
+  const keyOrDelta = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
+  if (!keyOrDelta) {
+    throw new Error("expected avc to contain info about key or delta");
   }
-  if (resolution.type === "do-seek") {
-    await performSeek({
-      seekTo: resolution.byte,
-      userInitiated: true,
-      controller,
-      mediaSection,
-      iterator,
-      logLevel,
-      mode,
-      contentLength,
-      seekInfiniteLoop,
-      currentReader,
-      readerInterface,
-      src,
-      discardReadBytes,
-      fields
-    });
-    const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek2);
-    if (hasChanged) {
-      Log.trace(logLevel, `Seek request has changed while seeking, seeking again`);
-      await workOnSeekRequest(options);
+  return keyOrDelta.type === "keyframe" ? "key" : "delta";
+};
+
+// src/containers/avc/parse-avc.ts
+var Extended_SAR = 255;
+var readVuiParameters = (iterator) => {
+  let sar_width = null;
+  let sar_height = null;
+  let overscan_appropriate_flag = null;
+  let video_format = null;
+  let video_full_range_flag = null;
+  let colour_primaries = null;
+  let transfer_characteristics = null;
+  let matrix_coefficients = null;
+  let chroma_sample_loc_type_top_field = null;
+  let chroma_sample_loc_type_bottom_field = null;
+  const aspect_ratio_info_present_flag = iterator.getBits(1);
+  if (aspect_ratio_info_present_flag) {
+    const aspect_ratio_idc = iterator.getBits(8);
+    if (aspect_ratio_idc === Extended_SAR) {
+      sar_width = iterator.getBits(16);
+      sar_height = iterator.getBits(16);
     }
-    return;
   }
-  if (resolution.type === "invalid") {
-    throw new Error(`The seek request ${JSON.stringify(seek2)} cannot be processed`);
+  const overscan_info_present_flag = iterator.getBits(1);
+  if (overscan_info_present_flag) {
+    overscan_appropriate_flag = iterator.getBits(1);
   }
-  if (resolution.type === "valid-but-must-wait") {
-    Log.trace(logLevel, "Seek request is valid but cannot be processed yet");
+  const video_signal_type_present_flag = iterator.getBits(1);
+  if (video_signal_type_present_flag) {
+    video_format = iterator.getBits(3);
+    video_full_range_flag = Boolean(iterator.getBits(1));
+    const colour_description_present_flag = iterator.getBits(1);
+    if (colour_description_present_flag) {
+      colour_primaries = iterator.getBits(8);
+      transfer_characteristics = iterator.getBits(8);
+      matrix_coefficients = iterator.getBits(8);
+    }
+  }
+  const chroma_loc_info_present_flag = iterator.getBits(1);
+  if (chroma_loc_info_present_flag) {
+    chroma_sample_loc_type_top_field = iterator.readExpGolomb();
+    chroma_sample_loc_type_bottom_field = iterator.readExpGolomb();
   }
+  return {
+    sar_width,
+    sar_height,
+    overscan_appropriate_flag,
+    chroma_sample_loc_type_bottom_field,
+    chroma_sample_loc_type_top_field,
+    colour_primaries,
+    matrix_coefficients,
+    transfer_characteristics,
+    video_format,
+    video_full_range_flag
+  };
 };
-
-// src/emit-available-info.ts
-var emitAvailableInfo = async ({
-  hasInfo,
-  state
-}) => {
-  const keys = Object.keys(hasInfo);
-  const {
-    emittedFields,
-    fieldsInReturnValue,
-    returnValue,
-    name,
-    callbackFunctions
-  } = state;
-  for (const key of keys) {
-    await workOnSeekRequest(getWorkOnSeekRequestOptions(state));
-    if (key === "structure") {
-      if (hasInfo.structure && !emittedFields.structure) {
-        await callbackFunctions.onStructure?.(state.structure.getStructure());
-        if (fieldsInReturnValue.structure) {
-          returnValue.structure = state.structure.getStructure();
-        }
-        emittedFields.structure = true;
-      }
-      continue;
+var readSps = (iterator) => {
+  const profile = iterator.getUint8();
+  const compatibility = iterator.getUint8();
+  const level = iterator.getUint8();
+  iterator.startReadingBits();
+  const seq_parameter_set_id = iterator.readExpGolomb();
+  let separate_colour_plane_flag = null;
+  let bit_depth_luma_minus8 = null;
+  let bit_depth_chroma_minus8 = null;
+  let qpprime_y_zero_transform_bypass_flag = null;
+  let log2_max_frame_num_minus4 = null;
+  let log2_max_pic_order_cnt_lsb_minus4 = null;
+  let max_num_ref_frames = null;
+  let gaps_in_frame_num_value_allowed_flag = null;
+  let mb_adaptive_frame_field_flag = null;
+  let direct_8x8_inference_flag = null;
+  let frame_crop_left_offset = null;
+  let frame_crop_right_offset = null;
+  let frame_crop_top_offset = null;
+  let frame_crop_bottom_offset = null;
+  let vui_parameters = null;
+  if (profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128 || profile === 138 || profile === 139 || profile === 134 || profile === 135) {
+    const chromaFormat = iterator.readExpGolomb();
+    if (chromaFormat === 3) {
+      separate_colour_plane_flag = iterator.getBits(1);
     }
-    if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds) {
-        if (!emittedFields.durationInSeconds) {
-          const durationInSeconds = getDuration(state);
-          await callbackFunctions.onDurationInSeconds?.(durationInSeconds);
-          if (fieldsInReturnValue.durationInSeconds) {
-            returnValue.durationInSeconds = durationInSeconds;
+    bit_depth_luma_minus8 = iterator.readExpGolomb();
+    bit_depth_chroma_minus8 = iterator.readExpGolomb();
+    qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
+    const seq_scaling_matrix_present_flag = iterator.getBits(1);
+    const seq_scaling_list_present_flag = [];
+    if (seq_scaling_matrix_present_flag) {
+      for (let i = 0;i < (chromaFormat !== 3 ? 8 : 12); i++) {
+        seq_scaling_list_present_flag[i] = iterator.getBits(1);
+        if (seq_scaling_list_present_flag[i]) {
+          if (i < 6) {
+            throw new Error("Not implemented");
+          } else {
+            throw new Error("Not implemented");
           }
-          emittedFields.durationInSeconds = true;
         }
       }
-      continue;
     }
-    if (key === "slowDurationInSeconds") {
-      if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds) {
-        const slowDurationInSeconds = getDuration(state) ?? state.slowDurationAndFps.getSlowDurationInSeconds();
-        await callbackFunctions.onSlowDurationInSeconds?.(slowDurationInSeconds);
-        if (fieldsInReturnValue.slowDurationInSeconds) {
-          returnValue.slowDurationInSeconds = slowDurationInSeconds;
-        }
-        emittedFields.slowDurationInSeconds = true;
-      }
+  }
+  log2_max_frame_num_minus4 = iterator.readExpGolomb();
+  const pic_order_cnt_type = iterator.readExpGolomb();
+  if (pic_order_cnt_type === 0) {
+    log2_max_pic_order_cnt_lsb_minus4 = iterator.readExpGolomb();
+  } else if (pic_order_cnt_type === 1) {
+    throw new Error("pic_order_cnt_type = 1 not implemented");
+  }
+  max_num_ref_frames = iterator.readExpGolomb();
+  gaps_in_frame_num_value_allowed_flag = iterator.getBits(1);
+  const pic_width_in_mbs_minus1 = iterator.readExpGolomb();
+  const pic_height_in_map_units_minus1 = iterator.readExpGolomb();
+  const frame_mbs_only_flag = iterator.getBits(1);
+  if (!frame_mbs_only_flag) {
+    mb_adaptive_frame_field_flag = iterator.getBits(1);
+  }
+  direct_8x8_inference_flag = iterator.getBits(1);
+  const frame_cropping_flag = iterator.getBits(1);
+  if (frame_cropping_flag) {
+    frame_crop_left_offset = iterator.readExpGolomb();
+    frame_crop_right_offset = iterator.readExpGolomb();
+    frame_crop_top_offset = iterator.readExpGolomb();
+    frame_crop_bottom_offset = iterator.readExpGolomb();
+  }
+  const vui_parameters_present_flag = iterator.getBits(1);
+  if (vui_parameters_present_flag) {
+    vui_parameters = readVuiParameters(iterator);
+  }
+  iterator.stopReadingBits();
+  return {
+    profile,
+    compatibility,
+    level,
+    bit_depth_chroma_minus8,
+    bit_depth_luma_minus8,
+    gaps_in_frame_num_value_allowed_flag,
+    log2_max_frame_num_minus4,
+    log2_max_pic_order_cnt_lsb_minus4,
+    max_num_ref_frames,
+    pic_height_in_map_units_minus1,
+    pic_width_in_mbs_minus1,
+    qpprime_y_zero_transform_bypass_flag,
+    separate_colour_plane_flag,
+    seq_parameter_set_id,
+    direct_8x8_inference_flag,
+    frame_crop_bottom_offset,
+    frame_crop_left_offset,
+    frame_crop_right_offset,
+    frame_crop_top_offset,
+    mb_adaptive_frame_field_flag,
+    vui_parameters
+  };
+};
+var findEnd = (buffer) => {
+  let zeroesInARow = 0;
+  for (let i = 0;i < buffer.length; i++) {
+    const val = buffer[i];
+    if (val === 0) {
+      zeroesInARow++;
       continue;
     }
-    if (key === "fps") {
-      if (hasInfo.fps) {
-        if (!emittedFields.fps) {
-          const fps = getFps(state);
+    if (zeroesInARow >= 2 && val === 1) {
+      return i - zeroesInARow;
+    }
+    zeroesInARow = 0;
+  }
+  return null;
+};
+var inspect = (buffer) => {
+  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
+  iterator.startReadingBits();
+  iterator.getBits(1);
+  iterator.getBits(2);
+  const type = iterator.getBits(5);
+  iterator.stopReadingBits();
+  if (type === 7) {
+    const end = findEnd(buffer);
+    const data = readSps(iterator);
+    const sps = buffer.slice(0, end === null ? Infinity : end);
+    return {
+      spsData: data,
+      sps,
+      type: "avc-profile"
+    };
+  }
+  if (type === 5) {
+    return {
+      type: "keyframe"
+    };
+  }
+  if (type === 8) {
+    const end = findEnd(buffer);
+    const pps = buffer.slice(0, end === null ? Infinity : end);
+    return {
+      type: "avc-pps",
+      pps
+    };
+  }
+  if (type === 1) {
+    return {
+      type: "delta-frame"
+    };
+  }
+  iterator.destroy();
+  return null;
+};
+var parseAvc = (buffer) => {
+  let zeroesInARow = 0;
+  const infos = [];
+  for (let i = 0;i < buffer.length; i++) {
+    const val = buffer[i];
+    if (val === 0) {
+      zeroesInARow++;
+      continue;
+    }
+    if (zeroesInARow >= 2 && val === 1) {
+      zeroesInARow = 0;
+      const info = inspect(buffer.slice(i + 1, i + 100));
+      if (info) {
+        infos.push(info);
+        if (info.type === "keyframe" || info.type === "delta-frame") {
+          break;
+        }
+      }
+    }
+    if (val !== 1) {
+      zeroesInARow = 0;
+    }
+  }
+  return infos;
+};
+
+// src/containers/avc/sps-and-pps.ts
+var getSpsAndPps = (infos) => {
+  const avcProfile = infos.find((i) => i.type === "avc-profile");
+  const ppsProfile = infos.find((i) => i.type === "avc-pps");
+  if (!avcProfile || !ppsProfile) {
+    throw new Error("Expected avcProfile and ppsProfile");
+  }
+  return { pps: ppsProfile, sps: avcProfile };
+};
+
+// src/containers/transport-stream/handle-avc-packet.ts
+var MPEG_TIMESCALE = 90000;
+var handleAvcPacket = async ({
+  streamBuffer,
+  programId,
+  offset,
+  sampleCallbacks,
+  logLevel,
+  onVideoTrack,
+  transportStream,
+  makeSamplesStartAtZero
+}) => {
+  const avc = parseAvc(streamBuffer.getBuffer());
+  const isTrackRegistered = sampleCallbacks.tracks.getTracks().find((t) => {
+    return t.trackId === programId;
+  });
+  if (!isTrackRegistered) {
+    const spsAndPps = getSpsAndPps(avc);
+    const dimensions = getDimensionsFromSps(spsAndPps.sps.spsData);
+    const sampleAspectRatio = getSampleAspectRatioFromSps(spsAndPps.sps.spsData);
+    const startOffset = makeSamplesStartAtZero ? Math.min(streamBuffer.pesHeader.pts, streamBuffer.pesHeader.dts ?? Infinity) : 0;
+    transportStream.startOffset.setOffset(programId, startOffset);
+    const track = {
+      m3uStreamFormat: null,
+      rotation: 0,
+      trackId: programId,
+      type: "video",
+      timescale: MPEG_TIMESCALE,
+      codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
+      codecPrivate: createSpsPpsData(spsAndPps),
+      fps: null,
+      codedWidth: dimensions.width,
+      codedHeight: dimensions.height,
+      height: dimensions.height,
+      width: dimensions.width,
+      displayAspectWidth: dimensions.width,
+      displayAspectHeight: dimensions.height,
+      trakBox: null,
+      codecWithoutConfig: "h264",
+      description: undefined,
+      sampleAspectRatio: {
+        denominator: sampleAspectRatio.height,
+        numerator: sampleAspectRatio.width
+      },
+      color: getVideoColorFromSps(spsAndPps.sps.spsData)
+    };
+    await registerVideoTrack({
+      track,
+      container: "transport-stream",
+      logLevel,
+      onVideoTrack,
+      registerVideoSampleCallback: sampleCallbacks.registerVideoSampleCallback,
+      tracks: sampleCallbacks.tracks
+    });
+  }
+  const type = getKeyFrameOrDeltaFromAvcInfo(avc);
+  const sample = {
+    cts: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
+    dts: (streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts) - transportStream.startOffset.getOffset(programId),
+    timestamp: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
+    duration: undefined,
+    data: streamBuffer.getBuffer(),
+    trackId: programId,
+    type,
+    offset,
+    timescale: MPEG_TIMESCALE
+  };
+  if (type === "key") {
+    transportStream.observedPesHeaders.markPtsAsKeyframe(streamBuffer.pesHeader.pts);
+  }
+  await emitVideoSample({
+    trackId: programId,
+    videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
+      sample,
+      timescale: MPEG_TIMESCALE
+    }),
+    callbacks: sampleCallbacks
+  });
+  transportStream.lastEmittedSample.setLastEmittedSample(sample);
+};
+
+// src/state/transport-stream/observed-pes-header.ts
+var makeObservedPesHeader = () => {
+  const pesHeaders = [];
+  const confirmedAsKeyframe = [];
+  const state = {
+    pesHeaders,
+    addPesHeader: (pesHeader) => {
+      if (pesHeaders.find((p) => p.offset === pesHeader.offset)) {
+        return;
+      }
+      pesHeaders.push(pesHeader);
+    },
+    markPtsAsKeyframe: (pts) => {
+      confirmedAsKeyframe.push(pts);
+    },
+    getPesKeyframeHeaders: () => {
+      return pesHeaders.filter((p) => confirmedAsKeyframe.includes(p.pts));
+    }
+  };
+  return state;
+};
+var getLastKeyFrameBeforeTimeInSeconds = ({
+  observedPesHeaders,
+  timeInSeconds,
+  ptsStartOffset
+}) => {
+  return observedPesHeaders.findLast((k) => (k.pts - ptsStartOffset) / MPEG_TIMESCALE <= timeInSeconds);
+};
+
+// src/get-seeking-byte.ts
+var getSeekingByte = ({
+  info,
+  time,
+  logLevel,
+  currentPosition,
+  isoState,
+  transportStream,
+  webmState,
+  mediaSection,
+  keyframes
+}) => {
+  if (info.type === "iso-base-media-seeking-info") {
+    return getSeekingByteFromIsoBaseMedia({
+      info,
+      time,
+      logLevel,
+      currentPosition,
+      isoState
+    });
+  }
+  if (info.type === "wav-seeking-info") {
+    return getSeekingByteFromWav({
+      info,
+      time
+    });
+  }
+  if (info.type === "webm-seeking-info") {
+    return getSeekingByteFromMatroska({
+      info,
+      time,
+      webmState,
+      logLevel,
+      mediaSection,
+      keyframes
+    });
+  }
+  if (info.type === "transport-stream-seeking-info") {
+    const lastKeyframeBeforeTimeInSeconds = getLastKeyFrameBeforeTimeInSeconds({
+      observedPesHeaders: info.observedPesHeaders,
+      timeInSeconds: time,
+      ptsStartOffset: info.ptsStartOffset
+    });
+    const byte = lastKeyframeBeforeTimeInSeconds?.offset ?? 0;
+    transportStream.resetBeforeSeek();
+    return Promise.resolve({
+      type: "do-seek",
+      byte
+    });
+  }
+  throw new Error(`Unknown seeking info type: ${info}`);
+};
+
+// src/containers/iso-base-media/get-seeking-info-from-mp4.ts
+var getSeekingInfoFromMp4 = ({
+  structureState,
+  isoState,
+  mp4HeaderSegment,
+  mediaSectionState: mediaSectionState2
+}) => {
+  const structure = structureState.getIsoStructure();
+  const moovAtom = getMoovBoxFromState({
+    isoState,
+    mp4HeaderSegment,
+    structureState
+  });
+  const moofBoxes = getMoofBoxes(structure.boxes);
+  const tfraBoxes = getTfraBoxes(structure);
+  if (!moovAtom) {
+    return null;
+  }
+  return {
+    type: "iso-base-media-seeking-info",
+    moovBox: moovAtom,
+    moofBoxes,
+    tfraBoxes,
+    mediaSections: mediaSectionState2.getMediaSections()
+  };
+};
+
+// src/containers/transport-stream/get-seeking-info.ts
+var getSeekingInfoFromTransportStream = (transportStream, tracksState) => {
+  const firstVideoTrack = tracksState.getTracks().find((t) => t.type === "video");
+  if (!firstVideoTrack) {
+    throw new Error("No video track found");
+  }
+  return {
+    type: "transport-stream-seeking-info",
+    observedPesHeaders: transportStream.observedPesHeaders.getPesKeyframeHeaders(),
+    ptsStartOffset: transportStream.startOffset.getOffset(firstVideoTrack.trackId)
+  };
+};
+
+// src/containers/wav/get-seeking-info.ts
+var getSeekingInfoFromWav = ({
+  structure,
+  mediaSectionState: mediaSectionState2
+}) => {
+  const fmtBox = structure.boxes.find((box) => box.type === "wav-fmt");
+  if (!fmtBox) {
+    return null;
+  }
+  const mediaSection = mediaSectionState2.getMediaSections();
+  if (mediaSection.length !== 1) {
+    return null;
+  }
+  return {
+    type: "wav-seeking-info",
+    sampleRate: fmtBox.sampleRate,
+    blockAlign: fmtBox.blockAlign,
+    mediaSections: mediaSection[0]
+  };
+};
+
+// src/containers/webm/seek/get-seeking-info.ts
+var getSeekingInfoFromMatroska = (tracksState) => {
+  const tracks2 = tracksState.getTracks();
+  const firstVideoTrack = tracks2.find((track) => track.type === "video");
+  return {
+    type: "webm-seeking-info",
+    track: firstVideoTrack ? {
+      timescale: firstVideoTrack.timescale,
+      trackId: firstVideoTrack.trackId
+    } : null
+  };
+};
+
+// src/get-seeking-info.ts
+var getSeekingInfo = ({
+  structureState,
+  mp4HeaderSegment,
+  mediaSectionState: mediaSectionState2,
+  isoState,
+  transportStream,
+  tracksState
+}) => {
+  const structure = structureState.getStructureOrNull();
+  if (!structure) {
+    return null;
+  }
+  if (structure.type === "iso-base-media") {
+    return getSeekingInfoFromMp4({
+      structureState,
+      isoState,
+      mp4HeaderSegment,
+      mediaSectionState: mediaSectionState2
+    });
+  }
+  if (structure.type === "wav") {
+    return getSeekingInfoFromWav({
+      structure,
+      mediaSectionState: mediaSectionState2
+    });
+  }
+  if (structure.type === "matroska") {
+    return getSeekingInfoFromMatroska(tracksState);
+  }
+  if (structure.type === "transport-stream") {
+    return getSeekingInfoFromTransportStream(transportStream, tracksState);
+  }
+  throw new Error(`Seeking is not supported for this format: ${structure.type}`);
+};
+
+// src/seek-backwards.ts
+var seekBackwards = async ({
+  iterator,
+  seekTo,
+  readerInterface,
+  src,
+  controller,
+  logLevel,
+  currentReader
+}) => {
+  const howManyBytesWeCanGoBack = iterator.counter.getDiscardedOffset();
+  if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+    iterator.skipTo(seekTo);
+    return;
+  }
+  const time = Date.now();
+  Log.verbose(logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available.`);
+  const { reader: newReader } = await readerInterface.read({
+    src,
+    range: seekTo,
+    controller
+  });
+  iterator.replaceData(new Uint8Array([]), seekTo);
+  Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+  currentReader.setCurrent(newReader);
+};
+
+// src/state/need-samples-for-fields.ts
+var fieldsNeedSamplesMap = {
+  slowDurationInSeconds: true,
+  slowFps: true,
+  slowKeyframes: true,
+  slowNumberOfFrames: true,
+  audioCodec: false,
+  container: false,
+  dimensions: false,
+  durationInSeconds: false,
+  fps: false,
+  internalStats: false,
+  isHdr: false,
+  name: false,
+  rotation: false,
+  size: false,
+  structure: false,
+  tracks: false,
+  unrotatedDimensions: false,
+  videoCodec: false,
+  metadata: false,
+  location: false,
+  mimeType: false,
+  keyframes: false,
+  images: false,
+  numberOfAudioChannels: false,
+  sampleRate: false,
+  slowAudioBitrate: true,
+  slowVideoBitrate: true,
+  m3uStreams: false
+};
+var needsToIterateOverSamples = ({
+  fields,
+  emittedFields
+}) => {
+  const keys = Object.keys(fields ?? {});
+  const selectedKeys = keys.filter((k) => fields[k]);
+  return selectedKeys.some((k) => fieldsNeedSamplesMap[k] && !emittedFields[k]);
+};
+
+// src/disallow-forward-seek-if-samples-are-needed.ts
+var disallowForwardSeekIfSamplesAreNeeded = ({
+  seekTo,
+  previousPosition,
+  fields
+}) => {
+  const fieldsNeedingSamples = Object.entries(fields).filter(([, value]) => value).map(([key]) => key).filter((key) => fieldsNeedSamplesMap[key]);
+  if (fieldsNeedingSamples.length > 0) {
+    throw new Error(`Forward seeking is not allowed when the following fields are requested from parseMedia(): ${fieldsNeedingSamples.join(", ")}. Seek was from 0x${previousPosition.toString(16)} to 0x${seekTo.toString(16)}. Either don't seek forward, or don't request these fields.`);
+  }
+};
+
+// src/seek-forwards.ts
+var seekForward = async ({
+  seekTo,
+  userInitiated,
+  iterator,
+  fields,
+  logLevel,
+  currentReader,
+  readerInterface,
+  src,
+  controller,
+  discardReadBytes
+}) => {
+  if (userInitiated) {
+    disallowForwardSeekIfSamplesAreNeeded({
+      fields,
+      seekTo,
+      previousPosition: iterator.counter.getOffset()
+    });
+  }
+  const alreadyHasBuffer = iterator.bytesRemaining() >= seekTo - iterator.counter.getOffset();
+  Log.verbose(logLevel, `Performing seek from ${iterator.counter.getOffset()} to ${seekTo}`);
+  if (alreadyHasBuffer) {
+    iterator.skipTo(seekTo);
+    Log.verbose(logLevel, `Already read ahead enough, skipping forward`);
+    return;
+  }
+  const time = Date.now();
+  Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+  const { reader: newReader } = await readerInterface.read({
+    src,
+    range: seekTo,
+    controller
+  });
+  iterator.skipTo(seekTo);
+  await discardReadBytes(true);
+  Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+  currentReader.setCurrent(newReader);
+};
+
+// src/perform-seek.ts
+var performSeek = async ({
+  seekTo,
+  userInitiated,
+  controller,
+  mediaSection,
+  iterator,
+  seekInfiniteLoop,
+  logLevel,
+  mode,
+  contentLength,
+  currentReader,
+  readerInterface,
+  src,
+  discardReadBytes,
+  fields
+}) => {
+  const byteInMediaSection = isByteInMediaSection({
+    position: seekTo,
+    mediaSections: mediaSection.getMediaSections()
+  });
+  if (byteInMediaSection !== "in-section" && userInitiated) {
+    const sections = mediaSection.getMediaSections();
+    const sectionStrings = sections.map((section) => {
+      return `start: ${section.start}, end: ${section.size + section.start}`;
+    });
+    throw new Error(`Cannot seek to a byte that is not in the video section. Seeking to: ${seekTo}, sections: ${sectionStrings.join(" | ")}`);
+  }
+  seekInfiniteLoop.registerSeek(seekTo);
+  if (seekTo <= iterator.counter.getOffset() && mode === "download") {
+    throw new Error(`Seeking backwards is not supported in parseAndDownloadMedia() mode. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
+  }
+  if (seekTo > contentLength) {
+    throw new Error(`Cannot seek beyond the end of the file: ${seekTo} > ${contentLength}`);
+  }
+  if (mode === "download") {
+    Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because in download mode`);
+    iterator.discard(seekTo - iterator.counter.getOffset());
+    return;
+  }
+  await controller._internals.checkForAbortAndPause();
+  const alreadyAtByte = iterator.counter.getOffset() === seekTo;
+  if (alreadyAtByte) {
+    Log.verbose(logLevel, `Already at the desired position, seeking done`);
+    controller._internals.performedSeeksSignal.markLastSeekAsUserInitiated();
+    return;
+  }
+  const skippingForward = seekTo > iterator.counter.getOffset();
+  controller._internals.performedSeeksSignal.recordSeek({
+    from: iterator.counter.getOffset(),
+    to: seekTo,
+    type: userInitiated ? "user-initiated" : "internal"
+  });
+  if (skippingForward) {
+    await seekForward({
+      seekTo,
+      userInitiated,
+      iterator,
+      fields,
+      logLevel,
+      currentReader,
+      readerInterface,
+      src,
+      controller,
+      discardReadBytes
+    });
+  } else {
+    await seekBackwards({
+      controller,
+      seekTo,
+      iterator,
+      logLevel,
+      currentReader,
+      readerInterface,
+      src
+    });
+  }
+  await controller._internals.checkForAbortAndPause();
+};
+
+// src/work-on-seek-request.ts
+var turnSeekIntoByte = async ({
+  seek: seek2,
+  mediaSectionState: mediaSectionState2,
+  logLevel,
+  iterator,
+  structureState,
+  mp4HeaderSegment,
+  isoState,
+  transportStream,
+  tracksState,
+  webmState,
+  keyframes
+}) => {
+  const mediaSections = mediaSectionState2.getMediaSections();
+  if (mediaSections.length === 0) {
+    Log.trace(logLevel, "No media sections defined, cannot seek yet");
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  if (seek2.type === "keyframe-before-time") {
+    if (seek2.timeInSeconds < 0) {
+      throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek2)}`);
+    }
+    const seekingInfo = getSeekingInfo({
+      structureState,
+      mp4HeaderSegment,
+      mediaSectionState: mediaSectionState2,
+      isoState,
+      transportStream,
+      tracksState
+    });
+    if (!seekingInfo) {
+      Log.trace(logLevel, "No seeking info, cannot seek yet");
+      return {
+        type: "valid-but-must-wait"
+      };
+    }
+    const seekingByte = await getSeekingByte({
+      info: seekingInfo,
+      time: seek2.timeInSeconds,
+      logLevel,
+      currentPosition: iterator.counter.getOffset(),
+      isoState,
+      transportStream,
+      webmState,
+      mediaSection: mediaSectionState2,
+      keyframes
+    });
+    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) => {
+  return {
+    logLevel: state.logLevel,
+    controller: state.controller,
+    isoState: state.iso,
+    iterator: state.iterator,
+    structureState: state.structure,
+    src: state.src,
+    contentLength: state.contentLength,
+    readerInterface: state.readerInterface,
+    mediaSection: state.mediaSection,
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mode: state.mode,
+    seekInfiniteLoop: state.seekInfiniteLoop,
+    currentReader: state.currentReader,
+    discardReadBytes: state.discardReadBytes,
+    fields: state.fields,
+    transportStream: state.transportStream,
+    tracksState: state.callbacks.tracks,
+    webmState: state.webm,
+    keyframes: state.keyframes
+  };
+};
+var workOnSeekRequest = async (options) => {
+  const {
+    logLevel,
+    controller,
+    mediaSection,
+    mp4HeaderSegment,
+    isoState,
+    iterator,
+    structureState,
+    src,
+    contentLength,
+    readerInterface,
+    mode,
+    seekInfiniteLoop,
+    currentReader,
+    discardReadBytes,
+    fields,
+    transportStream,
+    tracksState,
+    webmState,
+    keyframes
+  } = options;
+  const seek2 = controller._internals.seekSignal.getSeek();
+  if (!seek2) {
+    return;
+  }
+  Log.trace(logLevel, `Has seek request: ${JSON.stringify(seek2)}`);
+  const resolution = await turnSeekIntoByte({
+    seek: seek2,
+    mediaSectionState: mediaSection,
+    logLevel,
+    iterator,
+    structureState,
+    mp4HeaderSegment,
+    isoState,
+    transportStream,
+    tracksState,
+    webmState,
+    keyframes
+  });
+  Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
+  if (resolution.type === "intermediary-seek") {
+    await performSeek({
+      seekTo: resolution.byte,
+      userInitiated: false,
+      controller,
+      mediaSection,
+      iterator,
+      logLevel,
+      mode,
+      contentLength,
+      seekInfiniteLoop,
+      currentReader,
+      readerInterface,
+      src,
+      discardReadBytes,
+      fields
+    });
+    return;
+  }
+  if (resolution.type === "do-seek") {
+    await performSeek({
+      seekTo: resolution.byte,
+      userInitiated: true,
+      controller,
+      mediaSection,
+      iterator,
+      logLevel,
+      mode,
+      contentLength,
+      seekInfiniteLoop,
+      currentReader,
+      readerInterface,
+      src,
+      discardReadBytes,
+      fields
+    });
+    const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek2);
+    if (hasChanged) {
+      Log.trace(logLevel, `Seek request has changed while seeking, seeking again`);
+      await workOnSeekRequest(options);
+    }
+    return;
+  }
+  if (resolution.type === "invalid") {
+    throw new Error(`The seek request ${JSON.stringify(seek2)} cannot be processed`);
+  }
+  if (resolution.type === "valid-but-must-wait") {
+    Log.trace(logLevel, "Seek request is valid but cannot be processed yet");
+  }
+};
+
+// src/emit-available-info.ts
+var emitAvailableInfo = async ({
+  hasInfo,
+  state
+}) => {
+  const keys = Object.keys(hasInfo);
+  const {
+    emittedFields,
+    fieldsInReturnValue,
+    returnValue,
+    name,
+    callbackFunctions
+  } = state;
+  for (const key of keys) {
+    await workOnSeekRequest(getWorkOnSeekRequestOptions(state));
+    if (key === "structure") {
+      if (hasInfo.structure && !emittedFields.structure) {
+        await callbackFunctions.onStructure?.(state.structure.getStructure());
+        if (fieldsInReturnValue.structure) {
+          returnValue.structure = state.structure.getStructure();
+        }
+        emittedFields.structure = true;
+      }
+      continue;
+    }
+    if (key === "durationInSeconds") {
+      if (hasInfo.durationInSeconds) {
+        if (!emittedFields.durationInSeconds) {
+          const durationInSeconds = getDuration(state);
+          await callbackFunctions.onDurationInSeconds?.(durationInSeconds);
+          if (fieldsInReturnValue.durationInSeconds) {
+            returnValue.durationInSeconds = durationInSeconds;
+          }
+          emittedFields.durationInSeconds = true;
+        }
+      }
+      continue;
+    }
+    if (key === "slowDurationInSeconds") {
+      if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds) {
+        const slowDurationInSeconds = getDuration(state) ?? state.slowDurationAndFps.getSlowDurationInSeconds();
+        await callbackFunctions.onSlowDurationInSeconds?.(slowDurationInSeconds);
+        if (fieldsInReturnValue.slowDurationInSeconds) {
+          returnValue.slowDurationInSeconds = slowDurationInSeconds;
+        }
+        emittedFields.slowDurationInSeconds = true;
+      }
+      continue;
+    }
+    if (key === "fps") {
+      if (hasInfo.fps) {
+        if (!emittedFields.fps) {
+          const fps = getFps(state);
           await callbackFunctions.onFps?.(fps);
           if (fieldsInReturnValue.fps) {
             returnValue.fps = fps;
@@ -6544,175 +7275,44 @@ var triggerInfoEmit = async (state) => {
   });
   await emitAvailableInfo({
     hasInfo: availableInfo,
-    state
-  });
-};
-
-// src/check-if-done.ts
-var checkIfDone = async (state) => {
-  const startCheck = Date.now();
-  const hasAll = hasAllInfo({
-    state
-  });
-  state.timings.timeCheckingIfDone += Date.now() - startCheck;
-  if (hasAll && state.mode === "query") {
-    Log.verbose(state.logLevel, "Got all info, skipping to the end.");
-    state.increaseSkippedBytes(state.contentLength - state.iterator.counter.getOffset());
-    return true;
-  }
-  if (state.iterator.counter.getOffset() === state.contentLength) {
-    if (state.structure.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
-      return false;
-    }
-    Log.verbose(state.logLevel, "Reached end of file");
-    await state.discardReadBytes(true);
-    return true;
-  }
-  if (state.iterator.counter.getOffset() + state.iterator.bytesRemaining() === state.contentLength && state.errored) {
-    Log.verbose(state.logLevel, "Reached end of file and errorred");
-    return true;
-  }
-  return false;
-};
-
-// src/make-progress-object.ts
-var makeProgressObject = (state) => {
-  return {
-    bytes: state.iterator.counter.getOffset(),
-    percentage: state.contentLength ? state.iterator.counter.getOffset() / state.contentLength : null,
-    totalBytes: state.contentLength
-  };
-};
-
-// src/convert-audio-or-video-sample.ts
-var TARGET_TIMESCALE = 1e6;
-var fixFloat = (value) => {
-  if (value % 1 < 0.0000001) {
-    return Math.floor(value);
-  }
-  if (value % 1 > 0.9999999) {
-    return Math.ceil(value);
-  }
-  return value;
-};
-var convertAudioOrVideoSampleToWebCodecsTimestamps = ({
-  sample,
-  timescale
-}) => {
-  if (timescale === TARGET_TIMESCALE) {
-    return sample;
-  }
-  const { cts, dts, timestamp } = sample;
-  return {
-    cts: fixFloat(cts * (TARGET_TIMESCALE / timescale)),
-    dts: fixFloat(dts * (TARGET_TIMESCALE / timescale)),
-    timestamp: fixFloat(timestamp * (TARGET_TIMESCALE / timescale)),
-    duration: sample.duration === undefined ? undefined : fixFloat(sample.duration * (TARGET_TIMESCALE / timescale)),
-    data: sample.data,
-    trackId: sample.trackId,
-    type: sample.type,
-    offset: sample.offset,
-    timescale: TARGET_TIMESCALE
-  };
-};
-
-// src/emit-audio-sample.ts
-var emitAudioSample = async ({
-  trackId,
-  audioSample,
-  workOnSeekRequestOptions,
-  callbacks
-}) => {
-  await callbacks.onAudioSample(trackId, audioSample);
-  await workOnSeekRequest(workOnSeekRequestOptions);
-};
-var emitVideoSample = async ({
-  trackId,
-  videoSample,
-  workOnSeekRequestOptions,
-  callbacks
-}) => {
-  await callbacks.onVideoSample(trackId, videoSample);
-  await workOnSeekRequest(workOnSeekRequestOptions);
-};
-
-// src/register-track.ts
-var registerVideoTrack = async ({
-  track,
-  container,
-  logLevel,
-  workOnSeekRequestOptions,
-  onVideoTrack,
-  registerVideoSampleCallback,
-  tracks: tracks2
-}) => {
-  if (tracks2.getTracks().find((t) => t.trackId === track.trackId)) {
-    Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
-    return null;
-  }
-  if (track.type !== "video") {
-    throw new Error("Expected video track");
-  }
-  tracks2.addTrack(track);
-  if (!onVideoTrack) {
-    return null;
-  }
-  const callback = await onVideoTrack({
-    track,
-    container
+    state
   });
-  await registerVideoSampleCallback(track.trackId, callback ?? null);
-  if (workOnSeekRequestOptions) {
-    await workOnSeekRequest(workOnSeekRequestOptions);
-  }
-  return callback;
 };
-var registerAudioTrack = async ({
-  workOnSeekRequestOptions,
-  track,
-  container,
-  tracks: tracks2,
-  logLevel,
-  onAudioTrack,
-  registerAudioSampleCallback
-}) => {
-  if (tracks2.getTracks().find((t) => t.trackId === track.trackId)) {
-    Log.trace(logLevel, `Track ${track.trackId} already registered, skipping`);
-    return null;
-  }
-  if (track.type !== "audio") {
-    throw new Error("Expected audio track");
+
+// src/check-if-done.ts
+var checkIfDone = async (state) => {
+  const startCheck = Date.now();
+  const hasAll = hasAllInfo({
+    state
+  });
+  state.timings.timeCheckingIfDone += Date.now() - startCheck;
+  if (hasAll && state.mode === "query") {
+    Log.verbose(state.logLevel, "Got all info, skipping to the end.");
+    state.increaseSkippedBytes(state.contentLength - state.iterator.counter.getOffset());
+    return true;
   }
-  tracks2.addTrack(track);
-  if (!onAudioTrack) {
-    return null;
+  if (state.iterator.counter.getOffset() === state.contentLength) {
+    if (state.structure.getStructure().type === "m3u" && !state.m3u.getAllChunksProcessedOverall()) {
+      return false;
+    }
+    Log.verbose(state.logLevel, "Reached end of file");
+    await state.discardReadBytes(true);
+    return true;
   }
-  const callback = await onAudioTrack({
-    track,
-    container
-  });
-  await registerAudioSampleCallback(track.trackId, callback ?? null);
-  if (workOnSeekRequestOptions) {
-    await workOnSeekRequest(workOnSeekRequestOptions);
+  if (state.iterator.counter.getOffset() + state.iterator.bytesRemaining() === state.contentLength && state.errored) {
+    Log.verbose(state.logLevel, "Reached end of file and errorred");
+    return true;
   }
-  return callback;
+  return false;
 };
-var registerVideoTrackWhenProfileIsAvailable = ({
-  state,
-  track,
-  container
-}) => {
-  state.riff.registerOnAvcProfileCallback(async (profile) => {
-    await registerVideoTrack({
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-      track: addAvcProfileToTrack(track, profile),
-      container,
-      logLevel: state.logLevel,
-      onVideoTrack: state.onVideoTrack,
-      registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-      tracks: state.callbacks.tracks
-    });
-  });
+
+// src/make-progress-object.ts
+var makeProgressObject = (state) => {
+  return {
+    bytes: state.iterator.counter.getOffset(),
+    percentage: state.contentLength ? state.iterator.counter.getOffset() / state.contentLength : null,
+    totalBytes: state.contentLength
+  };
 };
 
 // src/containers/aac/parse-aac.ts
@@ -6759,7 +7359,6 @@ var parseAac = async (state) => {
   const data = iterator.getSlice(frameLength);
   if (state.callbacks.tracks.getTracks().length === 0) {
     await registerAudioTrack({
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       container: "aac",
       track: {
         codec: mapAudioObjectTypeToCodecString(audioObjectType),
@@ -6799,7 +7398,6 @@ var parseAac = async (state) => {
       },
       timescale: 1
     }),
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
     callbacks: state.callbacks
   });
   return Promise.resolve(null);
@@ -7007,7 +7605,6 @@ var emitSample = async ({
       },
       timescale: 1
     }),
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
     callbacks: state.callbacks
   });
   iterator.destroy();
@@ -7157,7 +7754,6 @@ var parseStreamInfo = async ({
   state.structure.getFlacStructure().boxes.push(flacStreamInfo);
   await registerAudioTrack({
     container: "flac",
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
     track: {
       codec: "flac",
       type: "audio",
@@ -9108,7 +9704,7 @@ var processBox = async ({
     if (!onlyIfMoovAtomExpected) {
       throw new Error("State is required");
     }
-    const { workOnSeekRequestOptions, tracks: tracks2, onAudioTrack, onVideoTrack } = onlyIfMoovAtomExpected;
+    const { tracks: tracks2, onAudioTrack, onVideoTrack } = onlyIfMoovAtomExpected;
     const box = await parseTrak({
       size: boxSize,
       offsetAtStart: fileOffset,
@@ -9118,7 +9714,6 @@ var processBox = async ({
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack && transformedTrack.type === "video") {
       await registerVideoTrack({
-        workOnSeekRequestOptions,
         track: transformedTrack,
         container: "mp4",
         logLevel,
@@ -9129,7 +9724,6 @@ var processBox = async ({
     }
     if (transformedTrack && transformedTrack.type === "audio") {
       await registerAudioTrack({
-        workOnSeekRequestOptions,
         track: transformedTrack,
         container: "mp4",
         registerAudioSampleCallback: onlyIfMoovAtomExpected.registerAudioSampleCallback,
@@ -9237,7 +9831,6 @@ var getMoovAtom = async ({
   });
   const onAudioTrack = state.onAudioTrack ? async ({ track, container }) => {
     await registerAudioTrack({
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       track,
       container,
       logLevel: state.logLevel,
@@ -9249,7 +9842,6 @@ var getMoovAtom = async ({
   } : null;
   const onVideoTrack = state.onVideoTrack ? async ({ track, container }) => {
     await registerVideoTrack({
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       track,
       container,
       logLevel: state.logLevel,
@@ -9284,7 +9876,6 @@ var getMoovAtom = async ({
       onlyIfMoovAtomExpected: {
         tracks: tracksState,
         isoState: null,
-        workOnSeekRequestOptions: null,
         onAudioTrack,
         onVideoTrack,
         registerVideoSampleCallback: () => Promise.resolve(),
@@ -9372,7 +9963,6 @@ var parseMdatSection = async (state) => {
         },
         timescale: samplesWithIndex.track.timescale
       }),
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       callbacks: state.callbacks
     });
   }
@@ -9399,7 +9989,6 @@ var parseMdatSection = async (state) => {
         },
         timescale: samplesWithIndex.track.timescale
       }),
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       callbacks: state.callbacks
     });
   }
@@ -9419,7 +10008,6 @@ var parseIsoBaseMedia = async (state) => {
     onlyIfMoovAtomExpected: {
       tracks: state.callbacks.tracks,
       isoState: state.iso,
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       onAudioTrack: state.onAudioTrack,
       onVideoTrack: state.onVideoTrack,
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -9829,7 +10417,8 @@ var parseMedia = (options) => {
     onDiscardedData: null,
     onError: () => ({ action: "fail" }),
     acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
-    apiName: "parseMedia()"
+    apiName: "parseMedia()",
+    makeSamplesStartAtZero: options.makeSamplesStartAtZero ?? true
   });
 };
 
@@ -9950,7 +10539,8 @@ var iteratorOverSegmentFiles = async ({
           return callbackOrFalse;
         },
         reader: readerInterface,
-        mp4HeaderSegment
+        mp4HeaderSegment,
+        makeSamplesStartAtZero: false
       });
       if (chunk.isHeader) {
         if (data.structure.type !== "iso-base-media") {
@@ -10022,7 +10612,6 @@ var runOverM3u = async ({
         }
         const onAudioSample = await registerAudioTrack({
           container: "m3u8",
-          workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
           track: {
             ...track,
             trackId
@@ -10049,7 +10638,6 @@ var runOverM3u = async ({
         }
         const onVideoSample = await registerVideoTrack({
           container: "m3u8",
-          workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
           track: {
             ...track,
             trackId
@@ -10429,7 +11017,6 @@ var parseMpegHeader = async ({
       state.mp3Info.setMp3Info(info);
       await registerAudioTrack({
         container: "mp3",
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
         track: {
           type: "audio",
           codec: "mp3",
@@ -10479,7 +11066,6 @@ var parseMpegHeader = async ({
         trackId: 0,
         type: "key"
       },
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       callbacks: state.callbacks
     });
   }
@@ -10637,419 +11223,180 @@ var parseStrfVideo = ({
   const compression = iterator.getByteString(4, false);
   const sizeImage = iterator.getUint32Le();
   const xPelsPerMeter = iterator.getInt32Le();
-  const yPelsPerMeter = iterator.getInt32Le();
-  const clrUsed = iterator.getUint32Le();
-  const clrImportant = iterator.getUint32Le();
-  box.expectNoMoreBytes();
-  return {
-    type: "strf-box-video",
-    biSize,
-    bitCount,
-    clrImportant,
-    clrUsed,
-    compression,
-    height,
-    planes,
-    sizeImage,
-    width,
-    xPelsPerMeter,
-    yPelsPerMeter
-  };
-};
-var parseStrf = ({
-  iterator,
-  size,
-  fccType
-}) => {
-  if (fccType === "vids") {
-    return parseStrfVideo({ iterator, size });
-  }
-  if (fccType === "auds") {
-    return parseStrfAudio({ iterator, size });
-  }
-  throw new Error(`Unsupported fccType: ${fccType}`);
-};
-
-// src/containers/riff/parse-strh.ts
-var parseStrh = ({
-  iterator,
-  size
-}) => {
-  const box = iterator.startBox(size);
-  const fccType = iterator.getByteString(4, false);
-  if (fccType !== "vids" && fccType !== "auds") {
-    throw new Error("Expected AVI handler to be vids / auds");
-  }
-  const handler = fccType === "vids" ? iterator.getByteString(4, false) : iterator.getUint32Le();
-  if (typeof handler === "string" && handler !== "H264") {
-    throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
-  }
-  if (fccType === "auds" && handler !== 1) {
-    throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
-  }
-  const flags = iterator.getUint32Le();
-  const priority = iterator.getUint16Le();
-  const language2 = iterator.getUint16Le();
-  const initialFrames = iterator.getUint32Le();
-  const scale = iterator.getUint32Le();
-  const rate = iterator.getUint32Le();
-  const start = iterator.getUint32Le();
-  const length = iterator.getUint32Le();
-  const suggestedBufferSize = iterator.getUint32Le();
-  const quality = iterator.getUint32Le();
-  const sampleSize = iterator.getUint32Le();
-  box.discardRest();
-  const ckId = iterator.getByteString(4, false);
-  const ckSize = iterator.getUint32Le();
-  if (ckId !== "strf") {
-    throw new Error(`Expected strf, got ${JSON.stringify(ckId)}`);
-  }
-  if (iterator.bytesRemaining() < ckSize) {
-    throw new Error("Expected strf to be complete");
-  }
-  const strf = parseStrf({ iterator, size: ckSize, fccType });
-  return {
-    type: "strh-box",
-    fccType,
-    handler,
-    flags,
-    priority,
-    initialFrames,
-    length,
-    quality,
-    rate,
-    sampleSize,
-    scale,
-    start,
-    suggestedBufferSize,
-    language: language2,
-    strf
-  };
-};
-
-// src/containers/riff/parse-riff-box.ts
-var parseRiffBox = ({
-  size,
-  id,
-  state
-}) => {
-  const { iterator } = state;
-  if (id === "LIST") {
-    return parseListBox({ size, state });
-  }
-  if (id === "ISFT") {
-    return Promise.resolve(parseIsft({ iterator, size }));
-  }
-  if (id === "avih") {
-    return Promise.resolve(parseAvih({ iterator, size }));
-  }
-  if (id === "strh") {
-    return Promise.resolve(parseStrh({ iterator, size }));
-  }
-  iterator.discard(size);
-  const box = {
-    type: "riff-box",
-    size,
-    id
-  };
-  return Promise.resolve(box);
-};
-
-// src/containers/riff/expect-riff-box.ts
-var expectRiffBox = async (state) => {
-  const { iterator } = state;
-  if (state.iterator.bytesRemaining() < 16) {
-    return null;
-  }
-  const checkpoint = iterator.startCheckpoint();
-  const ckId = iterator.getByteString(4, false);
-  const ckSize = iterator.getUint32Le();
-  if (isMoviAtom(iterator, ckId)) {
-    iterator.discard(4);
-    state.mediaSection.addMediaSection({
-      start: iterator.counter.getOffset(),
-      size: ckSize - 4
-    });
-    return null;
-  }
-  if (iterator.bytesRemaining() < ckSize) {
-    checkpoint.returnToCheckpoint();
-    return null;
-  }
-  const box = await parseRiffBox({
-    id: ckId,
-    size: ckSize,
-    state
-  });
-  if (box.type === "strh-box") {
-    if (box.strf.type === "strf-box-audio" && state.onAudioTrack) {
-      const audioTrack = makeAviAudioTrack({
-        index: state.riff.getNextTrackIndex(),
-        strf: box.strf
-      });
-      await registerAudioTrack({
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-        track: audioTrack,
-        container: "avi",
-        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-        tracks: state.callbacks.tracks,
-        logLevel: state.logLevel,
-        onAudioTrack: state.onAudioTrack
-      });
-    }
-    if (state.onVideoTrack && box.strf.type === "strf-box-video") {
-      const videoTrack = makeAviVideoTrack({
-        strh: box,
-        index: state.riff.getNextTrackIndex(),
-        strf: box.strf
-      });
-      registerVideoTrackWhenProfileIsAvailable({
-        state,
-        track: videoTrack,
-        container: "avi"
-      });
-    }
-    state.riff.incrementNextTrackIndex();
-  }
-  return box;
-};
-
-// src/containers/avc/key.ts
-var getKeyFrameOrDeltaFromAvcInfo = (infos) => {
-  const keyOrDelta = infos.find((i) => i.type === "keyframe" || i.type === "delta-frame");
-  if (!keyOrDelta) {
-    throw new Error("expected avc to contain info about key or delta");
-  }
-  return keyOrDelta.type === "keyframe" ? "key" : "delta";
+  const yPelsPerMeter = iterator.getInt32Le();
+  const clrUsed = iterator.getUint32Le();
+  const clrImportant = iterator.getUint32Le();
+  box.expectNoMoreBytes();
+  return {
+    type: "strf-box-video",
+    biSize,
+    bitCount,
+    clrImportant,
+    clrUsed,
+    compression,
+    height,
+    planes,
+    sizeImage,
+    width,
+    xPelsPerMeter,
+    yPelsPerMeter
+  };
 };
-
-// src/containers/avc/parse-avc.ts
-var Extended_SAR = 255;
-var readVuiParameters = (iterator) => {
-  let sar_width = null;
-  let sar_height = null;
-  let overscan_appropriate_flag = null;
-  let video_format = null;
-  let video_full_range_flag = null;
-  let colour_primaries = null;
-  let transfer_characteristics = null;
-  let matrix_coefficients = null;
-  let chroma_sample_loc_type_top_field = null;
-  let chroma_sample_loc_type_bottom_field = null;
-  const aspect_ratio_info_present_flag = iterator.getBits(1);
-  if (aspect_ratio_info_present_flag) {
-    const aspect_ratio_idc = iterator.getBits(8);
-    if (aspect_ratio_idc === Extended_SAR) {
-      sar_width = iterator.getBits(16);
-      sar_height = iterator.getBits(16);
-    }
-  }
-  const overscan_info_present_flag = iterator.getBits(1);
-  if (overscan_info_present_flag) {
-    overscan_appropriate_flag = iterator.getBits(1);
-  }
-  const video_signal_type_present_flag = iterator.getBits(1);
-  if (video_signal_type_present_flag) {
-    video_format = iterator.getBits(3);
-    video_full_range_flag = Boolean(iterator.getBits(1));
-    const colour_description_present_flag = iterator.getBits(1);
-    if (colour_description_present_flag) {
-      colour_primaries = iterator.getBits(8);
-      transfer_characteristics = iterator.getBits(8);
-      matrix_coefficients = iterator.getBits(8);
-    }
+var parseStrf = ({
+  iterator,
+  size,
+  fccType
+}) => {
+  if (fccType === "vids") {
+    return parseStrfVideo({ iterator, size });
   }
-  const chroma_loc_info_present_flag = iterator.getBits(1);
-  if (chroma_loc_info_present_flag) {
-    chroma_sample_loc_type_top_field = iterator.readExpGolomb();
-    chroma_sample_loc_type_bottom_field = iterator.readExpGolomb();
+  if (fccType === "auds") {
+    return parseStrfAudio({ iterator, size });
   }
-  return {
-    sar_width,
-    sar_height,
-    overscan_appropriate_flag,
-    chroma_sample_loc_type_bottom_field,
-    chroma_sample_loc_type_top_field,
-    colour_primaries,
-    matrix_coefficients,
-    transfer_characteristics,
-    video_format,
-    video_full_range_flag
-  };
+  throw new Error(`Unsupported fccType: ${fccType}`);
 };
-var readSps = (iterator) => {
-  const profile = iterator.getUint8();
-  const compatibility = iterator.getUint8();
-  const level = iterator.getUint8();
-  iterator.startReadingBits();
-  const seq_parameter_set_id = iterator.readExpGolomb();
-  let separate_colour_plane_flag = null;
-  let bit_depth_luma_minus8 = null;
-  let bit_depth_chroma_minus8 = null;
-  let qpprime_y_zero_transform_bypass_flag = null;
-  let log2_max_frame_num_minus4 = null;
-  let log2_max_pic_order_cnt_lsb_minus4 = null;
-  let max_num_ref_frames = null;
-  let gaps_in_frame_num_value_allowed_flag = null;
-  let mb_adaptive_frame_field_flag = null;
-  let direct_8x8_inference_flag = null;
-  let frame_crop_left_offset = null;
-  let frame_crop_right_offset = null;
-  let frame_crop_top_offset = null;
-  let frame_crop_bottom_offset = null;
-  let vui_parameters = null;
-  if (profile === 100 || profile === 110 || profile === 122 || profile === 244 || profile === 44 || profile === 83 || profile === 86 || profile === 118 || profile === 128 || profile === 138 || profile === 139 || profile === 134 || profile === 135) {
-    const chromaFormat = iterator.readExpGolomb();
-    if (chromaFormat === 3) {
-      separate_colour_plane_flag = iterator.getBits(1);
-    }
-    bit_depth_luma_minus8 = iterator.readExpGolomb();
-    bit_depth_chroma_minus8 = iterator.readExpGolomb();
-    qpprime_y_zero_transform_bypass_flag = iterator.getBits(1);
-    const seq_scaling_matrix_present_flag = iterator.getBits(1);
-    const seq_scaling_list_present_flag = [];
-    if (seq_scaling_matrix_present_flag) {
-      for (let i = 0;i < (chromaFormat !== 3 ? 8 : 12); i++) {
-        seq_scaling_list_present_flag[i] = iterator.getBits(1);
-        if (seq_scaling_list_present_flag[i]) {
-          if (i < 6) {
-            throw new Error("Not implemented");
-          } else {
-            throw new Error("Not implemented");
-          }
-        }
-      }
-    }
+
+// src/containers/riff/parse-strh.ts
+var parseStrh = ({
+  iterator,
+  size
+}) => {
+  const box = iterator.startBox(size);
+  const fccType = iterator.getByteString(4, false);
+  if (fccType !== "vids" && fccType !== "auds") {
+    throw new Error("Expected AVI handler to be vids / auds");
   }
-  log2_max_frame_num_minus4 = iterator.readExpGolomb();
-  const pic_order_cnt_type = iterator.readExpGolomb();
-  if (pic_order_cnt_type === 0) {
-    log2_max_pic_order_cnt_lsb_minus4 = iterator.readExpGolomb();
-  } else if (pic_order_cnt_type === 1) {
-    throw new Error("pic_order_cnt_type = 1 not implemented");
+  const handler = fccType === "vids" ? iterator.getByteString(4, false) : iterator.getUint32Le();
+  if (typeof handler === "string" && handler !== "H264") {
+    throw new Error(`Only H264 is supported as a stream type in .avi, got ${handler}`);
   }
-  max_num_ref_frames = iterator.readExpGolomb();
-  gaps_in_frame_num_value_allowed_flag = iterator.getBits(1);
-  const pic_width_in_mbs_minus1 = iterator.readExpGolomb();
-  const pic_height_in_map_units_minus1 = iterator.readExpGolomb();
-  const frame_mbs_only_flag = iterator.getBits(1);
-  if (!frame_mbs_only_flag) {
-    mb_adaptive_frame_field_flag = iterator.getBits(1);
+  if (fccType === "auds" && handler !== 1) {
+    throw new Error(`Only "1" is supported as a stream type in .avi, got ${handler}`);
   }
-  direct_8x8_inference_flag = iterator.getBits(1);
-  const frame_cropping_flag = iterator.getBits(1);
-  if (frame_cropping_flag) {
-    frame_crop_left_offset = iterator.readExpGolomb();
-    frame_crop_right_offset = iterator.readExpGolomb();
-    frame_crop_top_offset = iterator.readExpGolomb();
-    frame_crop_bottom_offset = iterator.readExpGolomb();
+  const flags = iterator.getUint32Le();
+  const priority = iterator.getUint16Le();
+  const language2 = iterator.getUint16Le();
+  const initialFrames = iterator.getUint32Le();
+  const scale = iterator.getUint32Le();
+  const rate = iterator.getUint32Le();
+  const start = iterator.getUint32Le();
+  const length = iterator.getUint32Le();
+  const suggestedBufferSize = iterator.getUint32Le();
+  const quality = iterator.getUint32Le();
+  const sampleSize = iterator.getUint32Le();
+  box.discardRest();
+  const ckId = iterator.getByteString(4, false);
+  const ckSize = iterator.getUint32Le();
+  if (ckId !== "strf") {
+    throw new Error(`Expected strf, got ${JSON.stringify(ckId)}`);
   }
-  const vui_parameters_present_flag = iterator.getBits(1);
-  if (vui_parameters_present_flag) {
-    vui_parameters = readVuiParameters(iterator);
+  if (iterator.bytesRemaining() < ckSize) {
+    throw new Error("Expected strf to be complete");
   }
-  iterator.stopReadingBits();
+  const strf = parseStrf({ iterator, size: ckSize, fccType });
   return {
-    profile,
-    compatibility,
-    level,
-    bit_depth_chroma_minus8,
-    bit_depth_luma_minus8,
-    gaps_in_frame_num_value_allowed_flag,
-    log2_max_frame_num_minus4,
-    log2_max_pic_order_cnt_lsb_minus4,
-    max_num_ref_frames,
-    pic_height_in_map_units_minus1,
-    pic_width_in_mbs_minus1,
-    qpprime_y_zero_transform_bypass_flag,
-    separate_colour_plane_flag,
-    seq_parameter_set_id,
-    direct_8x8_inference_flag,
-    frame_crop_bottom_offset,
-    frame_crop_left_offset,
-    frame_crop_right_offset,
-    frame_crop_top_offset,
-    mb_adaptive_frame_field_flag,
-    vui_parameters
+    type: "strh-box",
+    fccType,
+    handler,
+    flags,
+    priority,
+    initialFrames,
+    length,
+    quality,
+    rate,
+    sampleSize,
+    scale,
+    start,
+    suggestedBufferSize,
+    language: language2,
+    strf
   };
 };
-var findEnd = (buffer) => {
-  let zeroesInARow = 0;
-  for (let i = 0;i < buffer.length; i++) {
-    const val = buffer[i];
-    if (val === 0) {
-      zeroesInARow++;
-      continue;
-    }
-    if (zeroesInARow >= 2 && val === 1) {
-      return i - zeroesInARow;
-    }
-    zeroesInARow = 0;
-  }
-  return null;
-};
-var inspect = (buffer) => {
-  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
-  iterator.startReadingBits();
-  iterator.getBits(1);
-  iterator.getBits(2);
-  const type = iterator.getBits(5);
-  iterator.stopReadingBits();
-  if (type === 7) {
-    const end = findEnd(buffer);
-    const data = readSps(iterator);
-    const sps = buffer.slice(0, end === null ? Infinity : end);
-    return {
-      spsData: data,
-      sps,
-      type: "avc-profile"
-    };
+
+// src/containers/riff/parse-riff-box.ts
+var parseRiffBox = ({
+  size,
+  id,
+  state
+}) => {
+  const { iterator } = state;
+  if (id === "LIST") {
+    return parseListBox({ size, state });
   }
-  if (type === 5) {
-    return {
-      type: "keyframe"
-    };
+  if (id === "ISFT") {
+    return Promise.resolve(parseIsft({ iterator, size }));
   }
-  if (type === 8) {
-    const end = findEnd(buffer);
-    const pps = buffer.slice(0, end === null ? Infinity : end);
-    return {
-      type: "avc-pps",
-      pps
-    };
+  if (id === "avih") {
+    return Promise.resolve(parseAvih({ iterator, size }));
   }
-  if (type === 1) {
-    return {
-      type: "delta-frame"
-    };
+  if (id === "strh") {
+    return Promise.resolve(parseStrh({ iterator, size }));
   }
-  iterator.destroy();
-  return null;
+  iterator.discard(size);
+  const box = {
+    type: "riff-box",
+    size,
+    id
+  };
+  return Promise.resolve(box);
 };
-var parseAvc = (buffer) => {
-  let zeroesInARow = 0;
-  const infos = [];
-  for (let i = 0;i < buffer.length; i++) {
-    const val = buffer[i];
-    if (val === 0) {
-      zeroesInARow++;
-      continue;
-    }
-    if (zeroesInARow >= 2 && val === 1) {
-      zeroesInARow = 0;
-      const info = inspect(buffer.slice(i + 1, i + 100));
-      if (info) {
-        infos.push(info);
-        if (info.type === "keyframe" || info.type === "delta-frame") {
-          break;
-        }
-      }
+
+// src/containers/riff/expect-riff-box.ts
+var expectRiffBox = async (state) => {
+  const { iterator } = state;
+  if (state.iterator.bytesRemaining() < 16) {
+    return null;
+  }
+  const checkpoint = iterator.startCheckpoint();
+  const ckId = iterator.getByteString(4, false);
+  const ckSize = iterator.getUint32Le();
+  if (isMoviAtom(iterator, ckId)) {
+    iterator.discard(4);
+    state.mediaSection.addMediaSection({
+      start: iterator.counter.getOffset(),
+      size: ckSize - 4
+    });
+    return null;
+  }
+  if (iterator.bytesRemaining() < ckSize) {
+    checkpoint.returnToCheckpoint();
+    return null;
+  }
+  const box = await parseRiffBox({
+    id: ckId,
+    size: ckSize,
+    state
+  });
+  if (box.type === "strh-box") {
+    if (box.strf.type === "strf-box-audio" && state.onAudioTrack) {
+      const audioTrack = makeAviAudioTrack({
+        index: state.riff.getNextTrackIndex(),
+        strf: box.strf
+      });
+      await registerAudioTrack({
+        track: audioTrack,
+        container: "avi",
+        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+        tracks: state.callbacks.tracks,
+        logLevel: state.logLevel,
+        onAudioTrack: state.onAudioTrack
+      });
     }
-    if (val !== 1) {
-      zeroesInARow = 0;
+    if (state.onVideoTrack && box.strf.type === "strf-box-video") {
+      const videoTrack = makeAviVideoTrack({
+        strh: box,
+        index: state.riff.getNextTrackIndex(),
+        strf: box.strf
+      });
+      registerVideoTrackWhenProfileIsAvailable({
+        state,
+        track: videoTrack,
+        container: "avi"
+      });
     }
+    state.riff.incrementNextTrackIndex();
   }
-  return infos;
+  return box;
 };
 
 // src/containers/riff/parse-movi.ts
@@ -11105,7 +11452,6 @@ var handleChunk = async ({
         },
         timescale: 1
       }),
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       callbacks: state.callbacks
     });
     return;
@@ -11135,7 +11481,6 @@ var handleChunk = async ({
         },
         timescale: 1
       }),
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
       callbacks: state.callbacks
     });
   }
@@ -11296,7 +11641,10 @@ var parseSdt = (iterator) => {
 };
 
 // src/containers/transport-stream/parse-pes.ts
-var parsePes = (iterator) => {
+var parsePes = ({
+  iterator,
+  offset
+}) => {
   const ident = iterator.getUint24();
   if (ident !== 1) {
     throw new Error(`Unexpected PES packet start code: ${ident.toString(16)}`);
@@ -11328,7 +11676,7 @@ var parsePes = (iterator) => {
   iterator.getBits(1);
   iterator.getBits(1);
   const pesHeaderLength = iterator.getBits(8);
-  const offset = iterator.counter.getOffset();
+  const offsetAfterHeader = iterator.counter.getOffset();
   let pts = null;
   if (!ptsPresent) {
     throw new Error(`PTS is required`);
@@ -11359,12 +11707,13 @@ var parsePes = (iterator) => {
     dts = dts1 << 30 | dts2 << 15 | dts3;
   }
   iterator.stopReadingBits();
-  iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offset));
+  iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offsetAfterHeader));
   const packet = {
     dts,
     pts,
     streamId,
-    priority
+    priority,
+    offset
   };
   return packet;
 };
@@ -11434,64 +11783,19 @@ var parsePmt = (iterator) => {
   return tables;
 };
 
-// src/containers/transport-stream/adts-header.ts
-var readAdtsHeader = (buffer) => {
-  if (buffer.byteLength < 9) {
-    return null;
-  }
-  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
-  iterator.startReadingBits();
-  const bits = iterator.getBits(12);
-  if (bits !== 4095) {
-    throw new Error("Invalid ADTS header ");
-  }
-  const id = iterator.getBits(1);
-  if (id !== 0) {
-    throw new Error("Only supporting MPEG-4 for .ts");
-  }
-  const layer = iterator.getBits(2);
-  if (layer !== 0) {
-    throw new Error("Only supporting layer 0 for .ts");
-  }
-  const protectionAbsent = iterator.getBits(1);
-  const audioObjectType = iterator.getBits(2);
-  const samplingFrequencyIndex = iterator.getBits(4);
-  const sampleRate = getSampleRateFromSampleFrequencyIndex(samplingFrequencyIndex);
-  iterator.getBits(1);
-  const channelConfiguration = iterator.getBits(3);
-  const codecPrivate2 = createAacCodecPrivate({
-    audioObjectType,
-    sampleRate,
-    channelConfiguration,
-    codecPrivate: null
-  });
-  iterator.getBits(1);
-  iterator.getBits(1);
-  iterator.getBits(1);
-  iterator.getBits(1);
-  const frameLength = iterator.getBits(13);
-  iterator.getBits(11);
-  iterator.getBits(2);
-  if (!protectionAbsent) {
-    iterator.getBits(16);
-  }
-  iterator.stopReadingBits();
-  iterator.destroy();
-  return {
-    frameLength,
-    codecPrivate: codecPrivate2,
-    channelConfiguration,
-    sampleRate,
-    audioObjectType
-  };
-};
-
 // src/containers/transport-stream/find-separator.ts
-function findNthSubarrayIndex(array, subarray, n) {
+function findNthSubarrayIndex({
+  array,
+  subarray,
+  n,
+  startIndex,
+  startCount
+}) {
   const subarrayLength = subarray.length;
   const arrayLength = array.length;
-  let count = 0;
-  for (let i = 0;i <= arrayLength - subarrayLength; i++) {
+  let count = startCount;
+  let i = startIndex;
+  for (i;i <= arrayLength - subarrayLength; i++) {
     let match = true;
     for (let j = 0;j < subarrayLength; j++) {
       if (array[i + j] !== subarray[j]) {
@@ -11502,144 +11806,87 @@ function findNthSubarrayIndex(array, subarray, n) {
     if (match) {
       count++;
       if (count === n) {
-        return i;
+        return { type: "found", index: i };
       }
     }
   }
-  return -1;
+  return { type: "not-found", index: i, count };
 }
 
-// src/containers/avc/interpret-sps.ts
-var getDimensionsFromSps = (sps) => {
-  const height = sps.pic_height_in_map_units_minus1;
-  const width = sps.pic_width_in_mbs_minus1;
-  return {
-    height: (height + 1) * 16 - (sps.frame_crop_bottom_offset ?? 0) * 2 - (sps.frame_crop_top_offset ?? 0) * 2,
-    width: (width + 1) * 16 - (sps.frame_crop_right_offset ?? 0) * 2 - (sps.frame_crop_left_offset ?? 0) * 2
-  };
-};
-var getSampleAspectRatioFromSps = (sps) => {
-  if (sps.vui_parameters?.sar_height && sps.vui_parameters.sar_width) {
-    return {
-      width: sps.vui_parameters.sar_width,
-      height: sps.vui_parameters.sar_height
-    };
-  }
-  return {
-    width: 1,
-    height: 1
-  };
-};
-var getVideoColorFromSps = (sps) => {
-  const matrixCoefficients2 = sps.vui_parameters?.matrix_coefficients;
-  const transferCharacteristics2 = sps.vui_parameters?.transfer_characteristics;
-  const colorPrimaries = sps.vui_parameters?.colour_primaries;
-  return {
-    matrixCoefficients: matrixCoefficients2 ? getMatrixCoefficientsFromIndex(matrixCoefficients2) : null,
-    transferCharacteristics: transferCharacteristics2 ? getTransferCharacteristicsFromIndex(transferCharacteristics2) : null,
-    primaries: colorPrimaries ? getPrimariesFromIndex(colorPrimaries) : null,
-    fullRange: sps.vui_parameters?.video_full_range_flag ?? null
-  };
-};
-
-// src/containers/avc/sps-and-pps.ts
-var getSpsAndPps = (infos) => {
-  const avcProfile = infos.find((i) => i.type === "avc-profile");
-  const ppsProfile = infos.find((i) => i.type === "avc-pps");
-  if (!avcProfile || !ppsProfile) {
-    throw new Error("Expected avcProfile and ppsProfile");
-  }
-  return { pps: ppsProfile, sps: avcProfile };
-};
-
-// src/containers/transport-stream/handle-avc-packet.ts
-var MPEG_TIMESCALE = 90000;
-var handleAvcPacket = async ({
-  streamBuffer,
-  programId,
-  state,
-  offset
-}) => {
-  const avc = parseAvc(streamBuffer.buffer);
-  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
-    return t.trackId === programId;
-  });
-  if (!isTrackRegistered) {
-    const spsAndPps = getSpsAndPps(avc);
-    const dimensions = getDimensionsFromSps(spsAndPps.sps.spsData);
-    const sampleAspectRatio = getSampleAspectRatioFromSps(spsAndPps.sps.spsData);
-    const track = {
-      m3uStreamFormat: null,
-      rotation: 0,
-      trackId: programId,
-      type: "video",
-      timescale: MPEG_TIMESCALE,
-      codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
-      codecPrivate: createSpsPpsData(spsAndPps),
-      fps: null,
-      codedWidth: dimensions.width,
-      codedHeight: dimensions.height,
-      height: dimensions.height,
-      width: dimensions.width,
-      displayAspectWidth: dimensions.width,
-      displayAspectHeight: dimensions.height,
-      trakBox: null,
-      codecWithoutConfig: "h264",
-      description: undefined,
-      sampleAspectRatio: {
-        denominator: sampleAspectRatio.height,
-        numerator: sampleAspectRatio.width
-      },
-      color: getVideoColorFromSps(spsAndPps.sps.spsData)
-    };
-    await registerVideoTrack({
-      track,
-      container: "transport-stream",
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-      logLevel: state.logLevel,
-      onVideoTrack: state.onVideoTrack,
-      registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-      tracks: state.callbacks.tracks
-    });
+// src/containers/transport-stream/adts-header.ts
+var readAdtsHeader = (buffer) => {
+  if (buffer.byteLength < 9) {
+    return null;
   }
-  const sample = {
-    cts: streamBuffer.pesHeader.pts,
-    dts: streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts,
-    timestamp: streamBuffer.pesHeader.pts,
-    duration: undefined,
-    data: new Uint8Array(streamBuffer.buffer),
-    trackId: programId,
-    type: getKeyFrameOrDeltaFromAvcInfo(avc),
-    offset,
-    timescale: MPEG_TIMESCALE
-  };
-  await emitVideoSample({
-    trackId: programId,
-    videoSample: convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample,
-      timescale: MPEG_TIMESCALE
-    }),
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-    callbacks: state.callbacks
+  const iterator = getArrayBufferIterator(buffer, buffer.byteLength);
+  iterator.startReadingBits();
+  const bits = iterator.getBits(12);
+  if (bits !== 4095) {
+    throw new Error("Invalid ADTS header ");
+  }
+  const id = iterator.getBits(1);
+  if (id !== 0) {
+    throw new Error("Only supporting MPEG-4 for .ts");
+  }
+  const layer = iterator.getBits(2);
+  if (layer !== 0) {
+    throw new Error("Only supporting layer 0 for .ts");
+  }
+  const protectionAbsent = iterator.getBits(1);
+  const audioObjectType = iterator.getBits(2);
+  const samplingFrequencyIndex = iterator.getBits(4);
+  const sampleRate = getSampleRateFromSampleFrequencyIndex(samplingFrequencyIndex);
+  iterator.getBits(1);
+  const channelConfiguration = iterator.getBits(3);
+  const codecPrivate2 = createAacCodecPrivate({
+    audioObjectType,
+    sampleRate,
+    channelConfiguration,
+    codecPrivate: null
   });
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  const frameLength = iterator.getBits(13);
+  iterator.getBits(11);
+  iterator.getBits(2);
+  if (!protectionAbsent) {
+    iterator.getBits(16);
+  }
+  iterator.stopReadingBits();
+  iterator.destroy();
+  return {
+    frameLength,
+    codecPrivate: codecPrivate2,
+    channelConfiguration,
+    sampleRate,
+    audioObjectType
+  };
 };
 
 // src/containers/transport-stream/handle-aac-packet.ts
 var handleAacPacket = async ({
   streamBuffer,
-  state,
   programId,
-  offset
+  offset,
+  sampleCallbacks,
+  logLevel,
+  onAudioTrack,
+  transportStream,
+  makeSamplesStartAtZero
 }) => {
-  const adtsHeader = readAdtsHeader(streamBuffer.buffer);
+  const adtsHeader = readAdtsHeader(streamBuffer.getBuffer());
   if (!adtsHeader) {
     throw new Error("Invalid ADTS header - too short");
   }
   const { channelConfiguration, codecPrivate: codecPrivate2, sampleRate, audioObjectType } = adtsHeader;
-  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
+  const isTrackRegistered = sampleCallbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
   if (!isTrackRegistered) {
+    const startOffset = makeSamplesStartAtZero ? Math.min(streamBuffer.pesHeader.pts, streamBuffer.pesHeader.dts ?? Infinity) : 0;
+    transportStream.startOffset.setOffset(programId, startOffset);
     const track = {
       type: "audio",
       codecPrivate: codecPrivate2,
@@ -11655,19 +11902,18 @@ var handleAacPacket = async ({
     await registerAudioTrack({
       track,
       container: "transport-stream",
-      workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-      registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-      tracks: state.callbacks.tracks,
-      logLevel: state.logLevel,
-      onAudioTrack: state.onAudioTrack
+      registerAudioSampleCallback: sampleCallbacks.registerAudioSampleCallback,
+      tracks: sampleCallbacks.tracks,
+      logLevel,
+      onAudioTrack
     });
   }
   const sample = {
-    cts: streamBuffer.pesHeader.pts,
-    dts: streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts,
-    timestamp: streamBuffer.pesHeader.pts,
+    cts: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
+    dts: (streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts) - transportStream.startOffset.getOffset(programId),
+    timestamp: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
     duration: undefined,
-    data: new Uint8Array(streamBuffer.buffer),
+    data: streamBuffer.getBuffer(),
     trackId: programId,
     type: "key",
     offset,
@@ -11679,196 +11925,162 @@ var handleAacPacket = async ({
       sample,
       timescale: MPEG_TIMESCALE
     }),
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-    callbacks: state.callbacks
+    callbacks: sampleCallbacks
   });
+  transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
 // src/containers/transport-stream/process-stream-buffers.ts
+var makeTransportStreamPacketBuffer = ({
+  buffers,
+  pesHeader,
+  offset
+}) => {
+  let currentBuf = buffers ? [buffers] : [];
+  let subarrayIndex = null;
+  const getBuffer = () => {
+    if (currentBuf.length === 0) {
+      return new Uint8Array;
+    }
+    if (currentBuf.length === 1) {
+      return currentBuf[0];
+    }
+    currentBuf = [combineUint8Arrays(currentBuf)];
+    return currentBuf[0];
+  };
+  let fastFind = null;
+  return {
+    pesHeader,
+    offset,
+    getBuffer,
+    addBuffer: (buffer) => {
+      currentBuf.push(buffer);
+      subarrayIndex = null;
+    },
+    get2ndSubArrayIndex: () => {
+      if (subarrayIndex === null) {
+        const result = findNthSubarrayIndex({
+          array: getBuffer(),
+          subarray: new Uint8Array([0, 0, 1, 9]),
+          n: 2,
+          startIndex: fastFind?.index ?? 0,
+          startCount: fastFind?.count ?? 0
+        });
+        if (result.type === "found") {
+          subarrayIndex = result.index;
+          fastFind = null;
+        } else {
+          fastFind = result;
+          return -1;
+        }
+      }
+      return subarrayIndex;
+    }
+  };
+};
 var processStreamBuffer = async ({
   streamBuffer,
-  state,
   programId,
-  structure
+  structure,
+  sampleCallbacks,
+  logLevel,
+  onAudioTrack,
+  onVideoTrack,
+  transportStream,
+  makeSamplesStartAtZero
 }) => {
   const stream = getStreamForId(structure, programId);
   if (!stream) {
     throw new Error("No stream found");
   }
+  if (stream.streamType === 2) {
+    throw new Error("H.262 video stream not supported");
+  }
   if (stream.streamType === 27) {
     await handleAvcPacket({
       programId,
       streamBuffer,
-      state,
-      offset: streamBuffer.offset
+      sampleCallbacks,
+      logLevel,
+      onVideoTrack,
+      offset: streamBuffer.offset,
+      transportStream,
+      makeSamplesStartAtZero
     });
   } else if (stream.streamType === 15) {
     await handleAacPacket({
       streamBuffer,
-      state,
       programId,
-      offset: streamBuffer.offset
+      offset: streamBuffer.offset,
+      sampleCallbacks,
+      logLevel,
+      onAudioTrack,
+      transportStream,
+      makeSamplesStartAtZero
     });
   }
-  if (!state.callbacks.tracks.hasAllTracks()) {
-    const tracksRegistered = state.callbacks.tracks.getTracks().length;
+  if (!sampleCallbacks.tracks.hasAllTracks()) {
+    const tracksRegistered = sampleCallbacks.tracks.getTracks().length;
     const { streams } = findProgramMapTableOrThrow(structure);
     if (filterStreamsBySupportedTypes(streams).length === tracksRegistered) {
-      state.callbacks.tracks.setIsDone(state.logLevel);
+      sampleCallbacks.tracks.setIsDone(logLevel);
     }
   }
 };
 var processFinalStreamBuffers = async ({
-  state,
-  structure
+  structure,
+  sampleCallbacks,
+  logLevel,
+  onAudioTrack,
+  onVideoTrack,
+  transportStream,
+  makeSamplesStartAtZero
 }) => {
-  for (const [programId, buffer] of state.transportStream.streamBuffers) {
-    if (buffer.buffer.byteLength > 0) {
+  for (const [programId, buffer] of transportStream.streamBuffers) {
+    if (buffer.getBuffer().byteLength > 0) {
       await processStreamBuffer({
         streamBuffer: buffer,
-        state,
         programId,
-        structure
+        structure,
+        sampleCallbacks,
+        logLevel,
+        onAudioTrack,
+        onVideoTrack,
+        transportStream,
+        makeSamplesStartAtZero
       });
-      state.transportStream.streamBuffers.delete(programId);
+      transportStream.streamBuffers.delete(programId);
     }
   }
 };
 
 // src/containers/transport-stream/parse-stream-packet.ts
-var parseAdtsStream = async ({
-  transportStreamEntry,
-  state,
-  structure,
-  offset
-}) => {
-  const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-  while (true) {
-    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-    if (!streamBuffer) {
-      throw new Error("Stream buffer not found");
-    }
-    const expectedLength = readAdtsHeader(streamBuffer.buffer)?.frameLength ?? null;
-    if (expectedLength === null) {
-      break;
-    }
-    if (expectedLength > streamBuffer.buffer.length) {
-      break;
-    }
-    await processStreamBuffer({
-      streamBuffer: {
-        buffer: streamBuffer.buffer.slice(0, expectedLength),
-        offset,
-        pesHeader: streamBuffer.pesHeader
-      },
-      programId: transportStreamEntry.pid,
-      state,
-      structure
-    });
-    const rest = streamBuffer.buffer.slice(expectedLength);
-    streamBuffers.set(transportStreamEntry.pid, {
-      buffer: rest,
-      pesHeader: nextPesHeader.getNextPesHeader(),
-      offset
-    });
-  }
-};
-var parseAvcStream = async ({
-  programId,
-  state,
-  structure,
-  streamBuffer
-}) => {
-  const indexOfSeparator = findNthSubarrayIndex(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
-  if (indexOfSeparator === -1 || indexOfSeparator === 0) {
-    return null;
-  }
-  const packet = streamBuffer.buffer.slice(0, indexOfSeparator);
-  const rest = streamBuffer.buffer.slice(indexOfSeparator);
-  await processStreamBuffer({
-    state,
-    streamBuffer: {
-      offset: streamBuffer.offset,
-      pesHeader: streamBuffer.pesHeader,
-      buffer: packet
-    },
-    programId,
-    structure
-  });
-  return rest;
-};
-var parseStream = async ({
+var parseStream = ({
   transportStreamEntry,
-  state,
   programId,
-  structure
+  iterator,
+  transportStream
 }) => {
-  const { iterator } = state;
-  let restOfPacket = getRestOfPacket(iterator);
+  const restOfPacket = getRestOfPacket(iterator);
   const offset = iterator.counter.getOffset();
-  if (transportStreamEntry.streamType === 27) {
-    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-    while (true) {
-      if (!streamBuffers.has(transportStreamEntry.pid)) {
-        streamBuffers.set(programId, {
-          pesHeader: nextPesHeader.getNextPesHeader(),
-          buffer: new Uint8Array([]),
-          offset
-        });
-      }
-      const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-      streamBuffer.buffer = combineUint8Arrays([
-        streamBuffer.buffer,
-        restOfPacket
-      ]);
-      const rest = await parseAvcStream({
-        state,
-        programId,
-        structure,
-        streamBuffer: streamBuffers.get(transportStreamEntry.pid)
-      });
-      if (rest !== null) {
-        streamBuffers.delete(transportStreamEntry.pid);
-        if (rest.length === 0) {
-          break;
-        }
-        restOfPacket = rest;
-      } else {
-        break;
-      }
-    }
-    return;
-  }
-  if (transportStreamEntry.streamType === 15) {
-    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-    if (!streamBuffer) {
-      streamBuffers.set(transportStreamEntry.pid, {
-        buffer: restOfPacket,
-        pesHeader: nextPesHeader.getNextPesHeader(),
-        offset
-      });
-    } else {
-      streamBuffer.buffer = combineUint8Arrays([
-        streamBuffer.buffer,
-        restOfPacket
-      ]);
-    }
-    return parseAdtsStream({
-      transportStreamEntry,
-      state,
-      structure,
+  const { streamBuffers, nextPesHeaderStore: nextPesHeader } = transportStream;
+  if (!streamBuffers.has(transportStreamEntry.pid)) {
+    streamBuffers.set(programId, makeTransportStreamPacketBuffer({
+      pesHeader: nextPesHeader.getNextPesHeader(),
+      buffers: null,
       offset
-    });
+    }));
   }
-  throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
+  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+  streamBuffer.addBuffer(restOfPacket);
 };
 
 // src/containers/transport-stream/parse-packet.ts
-var parsePacket = async ({
-  parserState
+var parsePacket = ({
+  iterator,
+  structure,
+  transportStream
 }) => {
-  const { iterator } = parserState;
   const offset = iterator.counter.getOffset();
   const syncByte = iterator.getUint8();
   if (syncByte !== 71) {
@@ -11905,58 +12117,230 @@ var parsePacket = async ({
   }
   const read = iterator.counter.getOffset() - offset;
   if (read === 188) {
-    return Promise.resolve(null);
+    return null;
   }
-  const structure = parserState.structure.getTsStructure();
   const pat = structure.boxes.find((b) => b.type === "transport-stream-pmt-box");
   const isPes = payloadUnitStartIndicator && pat?.streams.find((e) => e.pid === programId);
   if (isPes) {
-    const packetPes = parsePes(iterator);
-    parserState.transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
+    const packetPes = parsePes({ iterator, offset });
+    transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
+    transportStream.observedPesHeaders.addPesHeader(packetPes);
   } else if (payloadUnitStartIndicator === 1) {
     iterator.getUint8();
   }
   if (programId === 0) {
-    return Promise.resolve(parsePat(iterator));
+    return parsePat(iterator);
   }
   if (programId === 17) {
-    return Promise.resolve(parseSdt(iterator));
+    return parseSdt(iterator);
   }
   const program = programId === 17 ? null : getProgramForId(structure, programId);
   if (program) {
     const pmt = parsePmt(iterator);
-    return Promise.resolve(pmt);
+    return pmt;
   }
-  const stream = getStreamForId(structure, programId);
-  if (stream) {
-    await parseStream({
-      transportStreamEntry: stream,
-      state: parserState,
-      programId,
-      structure
+  const transportStreamEntry = getStreamForId(structure, programId);
+  if (transportStreamEntry) {
+    parseStream({
+      transportStreamEntry,
+      iterator,
+      transportStream,
+      programId
     });
-    return Promise.resolve(null);
+    return null;
+  }
+  throw new Error("Unknown packet identifier");
+};
+
+// src/containers/transport-stream/process-audio.ts
+var canProcessAudio = ({
+  streamBuffer
+}) => {
+  const expectedLength = readAdtsHeader(streamBuffer.getBuffer())?.frameLength ?? null;
+  if (expectedLength === null) {
+    return false;
+  }
+  if (expectedLength > streamBuffer.getBuffer().length) {
+    return false;
+  }
+  return true;
+};
+var processAudio = async ({
+  transportStreamEntry,
+  structure,
+  offset,
+  sampleCallbacks,
+  logLevel,
+  onAudioTrack,
+  onVideoTrack,
+  transportStream,
+  makeSamplesStartAtZero
+}) => {
+  const { streamBuffers, nextPesHeaderStore: nextPesHeader } = transportStream;
+  const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+  if (!streamBuffer) {
+    throw new Error("Stream buffer not found");
+  }
+  const expectedLength = readAdtsHeader(streamBuffer.getBuffer())?.frameLength ?? null;
+  if (expectedLength === null) {
+    throw new Error("Expected length is null");
+  }
+  if (expectedLength > streamBuffer.getBuffer().length) {
+    throw new Error("Expected length is greater than stream buffer length");
+  }
+  await processStreamBuffer({
+    streamBuffer: makeTransportStreamPacketBuffer({
+      buffers: streamBuffer.getBuffer().slice(0, expectedLength),
+      offset,
+      pesHeader: streamBuffer.pesHeader
+    }),
+    programId: transportStreamEntry.pid,
+    structure,
+    sampleCallbacks,
+    logLevel,
+    onAudioTrack,
+    onVideoTrack,
+    transportStream,
+    makeSamplesStartAtZero
+  });
+  const rest = streamBuffer.getBuffer().slice(expectedLength);
+  streamBuffers.set(transportStreamEntry.pid, makeTransportStreamPacketBuffer({
+    buffers: rest,
+    pesHeader: nextPesHeader.getNextPesHeader(),
+    offset
+  }));
+};
+
+// src/containers/transport-stream/process-video.ts
+var canProcessVideo = ({
+  streamBuffer
+}) => {
+  const indexOfSeparator = streamBuffer.get2ndSubArrayIndex();
+  if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+    return false;
+  }
+  return true;
+};
+var processVideo = async ({
+  programId,
+  structure,
+  streamBuffer,
+  sampleCallbacks,
+  logLevel,
+  onAudioTrack,
+  onVideoTrack,
+  transportStream,
+  makeSamplesStartAtZero
+}) => {
+  const indexOfSeparator = streamBuffer.get2ndSubArrayIndex();
+  if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+    throw new Error("cannot process avc stream");
+  }
+  const buf = streamBuffer.getBuffer();
+  const packet = buf.slice(0, indexOfSeparator);
+  const rest = buf.slice(indexOfSeparator);
+  await processStreamBuffer({
+    streamBuffer: makeTransportStreamPacketBuffer({
+      offset: streamBuffer.offset,
+      pesHeader: streamBuffer.pesHeader,
+      buffers: packet
+    }),
+    programId,
+    structure,
+    sampleCallbacks,
+    logLevel,
+    onAudioTrack,
+    onVideoTrack,
+    transportStream,
+    makeSamplesStartAtZero
+  });
+  return rest;
+};
+
+// src/containers/transport-stream/process-sample-if-possible.ts
+var processSampleIfPossible = async (state) => {
+  const programMap = findProgramMapOrNull(state.structure.getTsStructure());
+  if (!programMap) {
+    return;
+  }
+  let processed = false;
+  for (const stream of programMap.streams) {
+    const streamBuffer = state.transportStream.streamBuffers.get(stream.pid);
+    if (!streamBuffer) {
+      continue;
+    }
+    if (stream.streamType === 27) {
+      if (canProcessVideo({ streamBuffer })) {
+        const rest = await processVideo({
+          programId: stream.pid,
+          structure: state.structure.getTsStructure(),
+          streamBuffer,
+          sampleCallbacks: state.callbacks,
+          logLevel: state.logLevel,
+          onAudioTrack: state.onAudioTrack,
+          onVideoTrack: state.onVideoTrack,
+          transportStream: state.transportStream,
+          makeSamplesStartAtZero: state.makeSamplesStartAtZero
+        });
+        state.transportStream.streamBuffers.delete(stream.pid);
+        state.transportStream.streamBuffers.set(stream.pid, makeTransportStreamPacketBuffer({
+          pesHeader: state.transportStream.nextPesHeaderStore.getNextPesHeader(),
+          buffers: rest,
+          offset: state.iterator.counter.getOffset()
+        }));
+        processed = true;
+        break;
+      }
+    }
+    if (stream.streamType === 15) {
+      if (canProcessAudio({ streamBuffer })) {
+        await processAudio({
+          structure: state.structure.getTsStructure(),
+          offset: state.iterator.counter.getOffset(),
+          sampleCallbacks: state.callbacks,
+          logLevel: state.logLevel,
+          onAudioTrack: state.onAudioTrack,
+          onVideoTrack: state.onVideoTrack,
+          transportStream: state.transportStream,
+          makeSamplesStartAtZero: state.makeSamplesStartAtZero,
+          transportStreamEntry: stream
+        });
+        processed = true;
+        break;
+      }
+    }
   }
-  throw new Error("Unknown packet identifier");
+  return processed;
 };
 
 // src/containers/transport-stream/parse-transport-stream.ts
 var parseTransportStream = async (state) => {
   const structure = state.structure.getTsStructure();
+  const processed = await processSampleIfPossible(state);
+  if (processed) {
+    return Promise.resolve(null);
+  }
   const { iterator } = state;
   if (iterator.bytesRemaining() < 188) {
     return Promise.resolve(null);
   }
-  const packet = await parsePacket({
-    parserState: state
+  const packet = parsePacket({
+    iterator,
+    structure,
+    transportStream: state.transportStream
   });
   if (packet) {
     structure.boxes.push(packet);
   }
   if (iterator.bytesRemaining() === 0) {
     await processFinalStreamBuffers({
-      state,
-      structure
+      transportStream: state.transportStream,
+      structure,
+      sampleCallbacks: state.callbacks,
+      logLevel: state.logLevel,
+      onAudioTrack: state.onAudioTrack,
+      onVideoTrack: state.onVideoTrack,
+      makeSamplesStartAtZero: state.makeSamplesStartAtZero
     });
   }
   return Promise.resolve(null);
@@ -12014,7 +12398,6 @@ var parseFmt = async ({
   };
   state.structure.getWavStructure().boxes.push(wavHeader);
   await registerAudioTrack({
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
     track: {
       type: "audio",
       codec: format,
@@ -12139,7 +12522,6 @@ var parseMediaSection2 = async ({
       },
       timescale: 1
     }),
-    workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
     callbacks: state.callbacks
   });
   return null;
@@ -12172,6 +12554,35 @@ var parseWav = (state) => {
   throw new Error(`Unknown WAV box type ${type}`);
 };
 
+// src/containers/webm/get-byte-for-cues.ts
+var getByteForSeek = ({
+  seekHeadSegment,
+  offset
+}) => {
+  const value = seekHeadSegment.value.map((v) => {
+    if (v.type !== "Seek") {
+      return null;
+    }
+    const seekId2 = v.value.find((_v) => {
+      return _v.type === "SeekID" && _v.value === matroskaElements.Cues;
+    });
+    if (!seekId2) {
+      return null;
+    }
+    const seekPosition2 = v.value.find((_v) => {
+      return _v.type === "SeekPosition";
+    });
+    if (!seekPosition2) {
+      return false;
+    }
+    return seekPosition2.value;
+  }).filter(truthy);
+  if (value.length === 0) {
+    return null;
+  }
+  return value[0].value + offset;
+};
+
 // src/containers/webm/segments/block-simple-block-flags.ts
 var parseBlockFlags = (iterator, type) => {
   if (type === matroskaElements.Block) {
@@ -12208,19 +12619,20 @@ var parseBlockFlags = (iterator, type) => {
 var addAvcToTrackIfNecessary = ({
   partialVideoSample,
   codec,
-  state,
+  structureState: structureState2,
+  webmState,
   trackNumber: trackNumber2
 }) => {
-  if (codec === "V_MPEG4/ISO/AVC" && getTracksFromMatroska({ state }).missingInfo.length > 0) {
+  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") {
-        state.webm.setAvcProfileForTrackNumber(trackNumber2, parse);
+        webmState.setAvcProfileForTrackNumber(trackNumber2, parse);
       }
     }
   }
 };
-var getSampleFromBlock = (ebml, state, offset) => {
+var getSampleFromBlock = (ebml, webmState, offset, structureState2) => {
   const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
   if (trackNumber2 === null) {
@@ -12228,9 +12640,9 @@ var getSampleFromBlock = (ebml, state, offset) => {
   }
   const timecodeRelativeToCluster = iterator.getInt16();
   const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
-  const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber2);
-  const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
-  const timescale = state.webm.getTimescale();
+  const { codec, trackTimescale } = webmState.getTrackInfoByNumber(trackNumber2);
+  const clusterOffset = webmState.getTimestampOffsetForByteOffset(offset);
+  const timescale = webmState.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
@@ -12261,7 +12673,8 @@ var getSampleFromBlock = (ebml, state, offset) => {
     addAvcToTrackIfNecessary({
       codec,
       partialVideoSample,
-      state,
+      structureState: structureState2,
+      webmState,
       trackNumber: trackNumber2
     });
     const sample = {
@@ -12299,8 +12712,7 @@ var getSampleFromBlock = (ebml, state, offset) => {
 };
 
 // src/containers/webm/parse-ebml.ts
-var parseEbml = async (state) => {
-  const { iterator } = state;
+var parseEbml = async (iterator, statesForProcessing) => {
   const hex = iterator.getMatroskaSegmentId();
   if (hex === null) {
     throw new Error("Not enough bytes left to parse EBML - this should not happen");
@@ -12369,12 +12781,12 @@ var parseEbml = async (state) => {
         break;
       }
       const offset = iterator.counter.getOffset();
-      const value = await parseEbml(state);
-      const remapped = await postprocessEbml({
+      const value = await parseEbml(iterator, statesForProcessing);
+      const remapped = statesForProcessing ? await postprocessEbml({
         offset,
         ebml: value,
-        state
-      });
+        statesForProcessing
+      }) : value;
       children.push(remapped);
       const offsetNow = iterator.counter.getOffset();
       if (offsetNow - startOffset > size) {
@@ -12391,54 +12803,58 @@ var parseEbml = async (state) => {
 var postprocessEbml = async ({
   offset,
   ebml,
-  state
+  statesForProcessing: {
+    webmState,
+    callbacks,
+    logLevel,
+    onAudioTrack,
+    onVideoTrack,
+    structureState: structureState2
+  }
 }) => {
   if (ebml.type === "TimestampScale") {
-    state.webm.setTimescale(ebml.value.value);
+    webmState.setTimescale(ebml.value.value);
   }
   if (ebml.type === "Tracks") {
-    state.callbacks.tracks.setIsDone(state.logLevel);
+    callbacks.tracks.setIsDone(logLevel);
   }
   if (ebml.type === "TrackEntry") {
-    state.webm.onTrackEntrySegment(ebml);
+    webmState.onTrackEntrySegment(ebml);
     const track = getTrack({
       track: ebml,
-      timescale: state.webm.getTimescale()
+      timescale: webmState.getTimescale()
     });
     if (track && track.type === "audio") {
       await registerAudioTrack({
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
         track,
         container: "webm",
-        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-        tracks: state.callbacks.tracks,
-        logLevel: state.logLevel,
-        onAudioTrack: state.onAudioTrack
+        registerAudioSampleCallback: callbacks.registerAudioSampleCallback,
+        tracks: callbacks.tracks,
+        logLevel,
+        onAudioTrack
       });
     }
     if (track && track.type === "video") {
       await registerVideoTrack({
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
         track,
         container: "webm",
-        logLevel: state.logLevel,
-        onVideoTrack: state.onVideoTrack,
-        registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-        tracks: state.callbacks.tracks
+        logLevel,
+        onVideoTrack,
+        registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+        tracks: callbacks.tracks
       });
     }
   }
   if (ebml.type === "Timestamp") {
-    state.webm.setTimestampOffset(offset, ebml.value.value);
+    webmState.setTimestampOffset(offset, ebml.value.value);
   }
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
-    const sample = getSampleFromBlock(ebml, state, offset);
+    const sample = getSampleFromBlock(ebml, webmState, offset, structureState2);
     if (sample.type === "video-sample") {
       await emitVideoSample({
         trackId: sample.videoSample.trackId,
         videoSample: sample.videoSample,
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-        callbacks: state.callbacks
+        callbacks
       });
       return {
         type: "Block",
@@ -12450,8 +12866,7 @@ var postprocessEbml = async ({
       await emitAudioSample({
         trackId: sample.audioSample.trackId,
         audioSample: sample.audioSample,
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-        callbacks: state.callbacks
+        callbacks
       });
       return {
         type: "Block",
@@ -12473,7 +12888,7 @@ 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, state, offset);
+    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, webmState, offset, structureState2);
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
         ...sample.partialVideoSample,
@@ -12482,8 +12897,7 @@ var postprocessEbml = async ({
       await emitVideoSample({
         trackId: sample.partialVideoSample.trackId,
         videoSample: completeFrame,
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
-        callbacks: state.callbacks
+        callbacks
       });
     }
     return {
@@ -12497,10 +12911,12 @@ var postprocessEbml = async ({
 
 // src/containers/webm/segments.ts
 var expectSegment = async ({
-  state,
-  isInsideSegment
+  statesForProcessing,
+  isInsideSegment,
+  iterator,
+  logLevel,
+  mediaSectionState: mediaSectionState2
 }) => {
-  const { iterator } = state;
   if (iterator.bytesRemaining() === 0) {
     throw new Error("has no bytes");
   }
@@ -12519,9 +12935,12 @@ var expectSegment = async ({
     return null;
   }
   const bytesRemainingNow = iterator.bytesRemaining();
-  Log.trace(state.logLevel, "Segment ID:", ebmlMap[segmentId]?.name, "Size:" + size, bytesRemainingNow);
+  Log.trace(logLevel, "Segment ID:", ebmlMap[segmentId]?.name, "Size:" + size, bytesRemainingNow);
   if (segmentId === matroskaElements.Segment) {
-    state.webm.addSegment({
+    if (!statesForProcessing) {
+      throw new Error("States for processing are required");
+    }
+    statesForProcessing.webmState.addSegment({
       start: offset,
       size
     });
@@ -12536,7 +12955,16 @@ var expectSegment = async ({
     if (isInsideSegment === null) {
       throw new Error("Expected to be inside segment");
     }
-    state.webm.addCluster({
+    if (!statesForProcessing) {
+      throw new Error("States for processing are required");
+    }
+    if (mediaSectionState2) {
+      mediaSectionState2.addMediaSection({
+        start: offset,
+        size
+      });
+    }
+    statesForProcessing.webmState.addCluster({
       start: offset,
       size,
       segment: isInsideSegment.index
@@ -12555,37 +12983,75 @@ var expectSegment = async ({
   const segment = await parseSegment({
     segmentId,
     length: size,
-    state,
-    headerReadSoFar: iterator.counter.getOffset() - offset
+    headerReadSoFar: iterator.counter.getOffset() - offset,
+    statesForProcessing,
+    iterator
   });
   return segment;
 };
 var parseSegment = async ({
   segmentId,
   length,
-  state,
-  headerReadSoFar
+  iterator,
+  headerReadSoFar,
+  statesForProcessing
 }) => {
   if (length < 0) {
     throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
   }
-  state.iterator.counter.decrement(headerReadSoFar);
-  const offset = state.iterator.counter.getOffset();
-  const ebml = await parseEbml(state);
-  const remapped = await postprocessEbml({ offset, ebml, state });
+  iterator.counter.decrement(headerReadSoFar);
+  const offset = iterator.counter.getOffset();
+  const ebml = await parseEbml(iterator, statesForProcessing);
+  if (!statesForProcessing) {
+    return ebml;
+  }
+  const remapped = await postprocessEbml({
+    offset,
+    ebml,
+    statesForProcessing
+  });
   return remapped;
 };
 
+// src/containers/webm/state-for-processing.ts
+var selectStatesForProcessing = ({
+  callbacks,
+  logLevel,
+  onAudioTrack,
+  onVideoTrack,
+  structure,
+  webm
+}) => {
+  return {
+    webmState: webm,
+    callbacks,
+    logLevel,
+    onAudioTrack,
+    onVideoTrack,
+    structureState: structure
+  };
+};
+
 // src/containers/webm/parse-webm-header.ts
 var parseWebm = async (state) => {
   const structure = state.structure.getMatroskaStructure();
   const { iterator } = state;
+  const offset = iterator.counter.getOffset();
   const isInsideSegment = state.webm.isInsideSegment(iterator);
-  const isInsideCluster = state.webm.isInsideCluster(iterator);
+  const isInsideCluster = state.webm.isInsideCluster(offset);
   const results = await expectSegment({
-    state,
-    isInsideSegment
+    iterator,
+    logLevel: state.logLevel,
+    statesForProcessing: selectStatesForProcessing(state),
+    isInsideSegment,
+    mediaSectionState: state.mediaSection
   });
+  if (results?.type === "SeekHead") {
+    const position = getByteForSeek({ seekHeadSegment: results, offset });
+    if (position !== null) {
+      state.webm.cues.triggerLoad(position, offset);
+    }
+  }
   if (results === null) {
     return null;
   }
@@ -12636,7 +13102,6 @@ var initVideo = async ({ state }) => {
     const tracks2 = getTracksFromMoovBox(moovAtom);
     for (const track of tracks2.videoTracks) {
       await registerVideoTrack({
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
         track,
         container: "mp4",
         logLevel: state.logLevel,
@@ -12647,7 +13112,6 @@ var initVideo = async ({ state }) => {
     }
     for (const track of tracks2.audioTracks) {
       await registerAudioTrack({
-        workOnSeekRequestOptions: getWorkOnSeekRequestOptions(state),
         track,
         container: "mp4",
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -12681,6 +13145,10 @@ var initVideo = async ({ state }) => {
   }
   if (fileType.type === "transport-stream") {
     Log.verbose(state.logLevel, "Detected MPEG-2 Transport Stream");
+    state.mediaSection.addMediaSection({
+      start: 0,
+      size: contentLength
+    });
     state.structure.setStructure({
       boxes: [],
       type: "transport-stream"
@@ -12849,12 +13317,10 @@ var parseLoop = async ({
       }
       try {
         await triggerInfoEmit(state);
-        const start = Date.now();
         await state.controller._internals.checkForAbortAndPause();
         const skip = await runParseIteration({
           state
         });
-        state.timings.timeIterating += Date.now() - start;
         if (skip !== null) {
           state.increaseSkippedBytes(skip.skipTo - state.iterator.counter.getOffset());
           if (skip.skipTo === state.contentLength) {
@@ -12902,7 +13368,6 @@ var parseLoop = async ({
       iterationWithThisOffset++;
     } else {
       iterationWithThisOffset = 0;
-      state.seekInfiniteLoop.reset();
     }
   }
 };
@@ -13223,6 +13688,9 @@ var keyframesState = () => {
   const keyframes = [];
   return {
     addKeyframe: (keyframe) => {
+      if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+        return;
+      }
       keyframes.push(keyframe);
     },
     getKeyframes: () => {
@@ -13374,52 +13842,291 @@ var m3uState = (logLevel) => {
     setAllChunksProcessed: (src) => {
       allChunksProcessed[src] = true;
     },
-    getAllChunksProcessedForPlaylist,
-    getAllChunksProcessedOverall: () => {
-      if (!selectedMainPlaylist) {
-        return false;
+    getAllChunksProcessedForPlaylist,
+    getAllChunksProcessedOverall: () => {
+      if (!selectedMainPlaylist) {
+        return false;
+      }
+      const selectedPlaylists = getSelectedPlaylists();
+      return selectedPlaylists.every((url) => allChunksProcessed[url]);
+    },
+    setHasFinishedManifest: () => {
+      hasFinishedManifest = true;
+    },
+    hasFinishedManifest: () => hasFinishedManifest,
+    setM3uStreamRun: (playlistUrl, run) => {
+      if (!run) {
+        delete m3uStreamRuns[playlistUrl];
+        return;
+      }
+      m3uStreamRuns[playlistUrl] = run;
+    },
+    setTracksDone: (playlistUrl) => {
+      tracksDone[playlistUrl] = true;
+      const selectedPlaylists = getSelectedPlaylists();
+      return selectedPlaylists.every((url) => tracksDone[url]);
+    },
+    getTrackDone: (playlistUrl) => {
+      return tracksDone[playlistUrl];
+    },
+    getM3uStreamRun: (playlistUrl) => m3uStreamRuns[playlistUrl] ?? null,
+    abortM3UStreamRuns: () => {
+      const values = Object.values(m3uStreamRuns);
+      if (values.length === 0) {
+        return;
+      }
+      Log.trace(logLevel, `Aborting ${values.length} M3U stream runs`);
+      values.forEach((run) => {
+        run.abort();
+      });
+    },
+    setAssociatedPlaylists: (playlists) => {
+      associatedPlaylists = playlists;
+    },
+    getAssociatedPlaylists: () => associatedPlaylists,
+    getSelectedPlaylists,
+    sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist }),
+    setMp4HeaderSegment,
+    getMp4HeaderSegment
+  };
+};
+
+// src/containers/webm/seek/format-cues.ts
+var formatCues = (cues) => {
+  const matroskaCues = [];
+  for (const cue of cues) {
+    if (cue.type === "Crc32") {
+      continue;
+    }
+    if (cue.type !== "CuePoint") {
+      throw new Error("Expected CuePoint");
+    }
+    const cueTime = cue.value.find((_cue) => _cue.type === "CueTime");
+    if (!cueTime) {
+      throw new Error("Expected CueTime");
+    }
+    const cueTrackPositions = cue.value.find((c) => c.type === "CueTrackPositions");
+    if (!cueTrackPositions) {
+      throw new Error("Expected CueTrackPositions");
+    }
+    const cueTimeValue = cueTime.value.value;
+    const cueTrack = cueTrackPositions.value.find((_c) => _c.type === "CueTrack");
+    if (!cueTrack) {
+      throw new Error("Expected CueTrack");
+    }
+    const cueClusterPosition = cueTrackPositions.value.find((_c) => _c.type === "CueClusterPosition");
+    if (!cueClusterPosition) {
+      throw new Error("Expected CueClusterPosition");
+    }
+    const cueRelativePosition = cueTrackPositions.value.find((_c) => _c.type === "CueRelativePosition");
+    const matroskaCue = {
+      trackId: cueTrack.value.value,
+      timeInTimescale: cueTimeValue,
+      clusterPositionInSegment: cueClusterPosition.value.value,
+      relativePosition: cueRelativePosition?.value.value ?? 0
+    };
+    matroskaCues.push(matroskaCue);
+  }
+  return matroskaCues;
+};
+
+// src/containers/webm/seek/fetch-web-cues.ts
+var fetchWebmCues = async ({
+  src,
+  readerInterface,
+  controller,
+  position,
+  logLevel
+}) => {
+  const result = await readerInterface.read({
+    controller,
+    range: position,
+    src
+  });
+  const { value } = await result.reader.reader.read();
+  if (!value) {
+    return null;
+  }
+  result.reader.abort();
+  const iterator = getArrayBufferIterator(value, value.length);
+  const segment = await expectSegment({
+    iterator,
+    logLevel,
+    statesForProcessing: null,
+    isInsideSegment: null,
+    mediaSectionState: null
+  });
+  iterator.destroy();
+  if (!segment?.value) {
+    return null;
+  }
+  return formatCues(segment.value);
+};
+
+// src/state/matroska/lazy-cues-fetch.ts
+var lazyCuesFetch = ({
+  controller,
+  logLevel,
+  readerInterface,
+  src
+}) => {
+  let prom = null;
+  let sOffset = null;
+  const triggerLoad = (position, segmentOffset) => {
+    if (prom) {
+      return prom;
+    }
+    if (sOffset && sOffset !== segmentOffset) {
+      throw new Error("Segment offset mismatch");
+    }
+    sOffset = segmentOffset;
+    Log.verbose(logLevel, "Cues box found, trying to lazy load cues");
+    prom = fetchWebmCues({
+      controller,
+      logLevel,
+      position,
+      readerInterface,
+      src
+    }).then((cues) => {
+      Log.verbose(logLevel, "Cues loaded");
+      return cues;
+    });
+    return prom;
+  };
+  const getLoadedCues = async () => {
+    if (!prom) {
+      return null;
+    }
+    const cues = await prom;
+    if (!cues) {
+      return null;
+    }
+    if (!sOffset) {
+      throw new Error("Segment offset not set");
+    }
+    return {
+      cues,
+      segmentOffset: sOffset
+    };
+  };
+  return {
+    triggerLoad,
+    getLoadedCues
+  };
+};
+
+// src/state/matroska/webm.ts
+var webmState = ({
+  controller,
+  logLevel,
+  readerInterface,
+  src
+}) => {
+  const trackEntries = {};
+  const onTrackEntrySegment = (trackEntry2) => {
+    const trackId = getTrackId(trackEntry2);
+    if (!trackId) {
+      throw new Error("Expected track id");
+    }
+    if (trackEntries[trackId]) {
+      return;
+    }
+    const codec = getTrackCodec(trackEntry2);
+    if (!codec) {
+      throw new Error("Expected codec");
+    }
+    const trackTimescale = getTrackTimestampScale(trackEntry2);
+    trackEntries[trackId] = {
+      codec: codec.value,
+      trackTimescale: trackTimescale?.value ?? null
+    };
+  };
+  const timestampMap = new Map;
+  const getTimestampOffsetForByteOffset = (byteOffset) => {
+    const entries = Array.from(timestampMap.entries());
+    const sortedByByteOffset = entries.sort((a, b) => {
+      return a[0] - b[0];
+    }).reverse();
+    for (const [offset, timestamp] of sortedByByteOffset) {
+      if (offset >= byteOffset) {
+        continue;
+      }
+      return timestamp;
+    }
+    return timestampMap.get(byteOffset);
+  };
+  const setTimestampOffset = (byteOffset, timestamp) => {
+    timestampMap.set(byteOffset, timestamp);
+  };
+  let timescale = null;
+  const setTimescale = (newTimescale) => {
+    timescale = newTimescale;
+  };
+  const getTimescale = () => {
+    if (timescale === null) {
+      return 1e6;
+    }
+    return timescale;
+  };
+  const segments = [];
+  const clusters = [];
+  const avcProfilesMap = {};
+  const setAvcProfileForTrackNumber = (trackNumber2, avcProfile) => {
+    avcProfilesMap[trackNumber2] = avcProfile;
+  };
+  const getAvcProfileForTrackNumber = (trackNumber2) => {
+    return avcProfilesMap[trackNumber2] ?? null;
+  };
+  const cues = lazyCuesFetch({
+    controller,
+    logLevel,
+    readerInterface,
+    src
+  });
+  return {
+    cues,
+    onTrackEntrySegment,
+    getTrackInfoByNumber: (id) => trackEntries[id],
+    setTimestampOffset,
+    getTimestampOffsetForByteOffset,
+    getTimescale,
+    setTimescale,
+    addSegment: (seg) => {
+      const segment = {
+        ...seg,
+        index: segments.length
+      };
+      segments.push(segment);
+    },
+    addCluster: (cluster) => {
+      const exists = clusters.some((existingCluster) => existingCluster.start === cluster.start);
+      if (!exists) {
+        clusters.push(cluster);
       }
-      const selectedPlaylists = getSelectedPlaylists();
-      return selectedPlaylists.every((url) => allChunksProcessed[url]);
     },
-    setHasFinishedManifest: () => {
-      hasFinishedManifest = true;
+    getFirstCluster: () => {
+      return clusters.find((cluster) => cluster.segment === 0);
     },
-    hasFinishedManifest: () => hasFinishedManifest,
-    setM3uStreamRun: (playlistUrl, run) => {
-      if (!run) {
-        delete m3uStreamRuns[playlistUrl];
-        return;
+    isInsideSegment: (iterator) => {
+      const offset = iterator.counter.getOffset();
+      const insideClusters = segments.filter((cluster) => {
+        return offset >= cluster.start && offset <= cluster.start + cluster.size;
+      });
+      if (insideClusters.length > 1) {
+        throw new Error("Expected to only be inside 1 cluster");
       }
-      m3uStreamRuns[playlistUrl] = run;
-    },
-    setTracksDone: (playlistUrl) => {
-      tracksDone[playlistUrl] = true;
-      const selectedPlaylists = getSelectedPlaylists();
-      return selectedPlaylists.every((url) => tracksDone[url]);
-    },
-    getTrackDone: (playlistUrl) => {
-      return tracksDone[playlistUrl];
+      return insideClusters[0] ?? null;
     },
-    getM3uStreamRun: (playlistUrl) => m3uStreamRuns[playlistUrl] ?? null,
-    abortM3UStreamRuns: () => {
-      const values = Object.values(m3uStreamRuns);
-      if (values.length === 0) {
-        return;
+    isInsideCluster: (offset) => {
+      for (const cluster of clusters) {
+        if (offset >= cluster.start && offset <= cluster.start + cluster.size) {
+          return cluster;
+        }
       }
-      Log.trace(logLevel, `Aborting ${values.length} M3U stream runs`);
-      values.forEach((run) => {
-        run.abort();
-      });
-    },
-    setAssociatedPlaylists: (playlists) => {
-      associatedPlaylists = playlists;
+      return null;
     },
-    getAssociatedPlaylists: () => associatedPlaylists,
-    getSelectedPlaylists,
-    sampleSorter: sampleSorter({ logLevel, getAllChunksProcessedForPlaylist }),
-    setMp4HeaderSegment,
-    getMp4HeaderSegment
+    setAvcProfileForTrackNumber,
+    getAvcProfileForTrackNumber
   };
 };
 
@@ -13550,19 +14257,19 @@ var sampleCallback = ({
           }
         }
       }
+      if (videoSample.type === "key") {
+        keyframes.addKeyframe({
+          trackId,
+          decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+          positionInBytes: videoSample.offset,
+          presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+          sizeInBytes: videoSample.data.length
+        });
+      }
       if (needsToIterateOverSamples({
         fields,
         emittedFields
       })) {
-        if (fields.slowKeyframes && videoSample.type === "key") {
-          keyframes.addKeyframe({
-            trackId,
-            decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
-            positionInBytes: videoSample.offset,
-            presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
-            sizeInBytes: videoSample.data.length
-          });
-        }
         slowDurationAndFpsState.addVideoSample(videoSample);
       }
     },
@@ -13586,28 +14293,8 @@ var sampleCallback = ({
   };
 };
 
-// src/state/seek-infinite-loop.ts
-var seekInfiniteLoopDetectionState = () => {
-  let lastSeek = null;
-  return {
-    registerSeek: (byte) => {
-      if (!lastSeek || lastSeek.byte !== byte) {
-        lastSeek = { byte, numberOfTimes: 1 };
-        return;
-      }
-      lastSeek.numberOfTimes++;
-      if (lastSeek.numberOfTimes >= 10) {
-        throw new Error(`Seeking infinite loop detected: Seeked to byte 0x${byte.toString(16)} ${lastSeek.numberOfTimes} times in a row with no position change in the file. Check your usage of .seek().`);
-      }
-    },
-    reset: () => {
-      lastSeek = null;
-    }
-  };
-};
-
-// src/state/slow-duration-fps.ts
-var slowDurationAndFpsState = () => {
+// src/state/samples-observed/slow-duration-fps.ts
+var samplesObservedState = () => {
   let smallestVideoSample;
   let largestVideoSample;
   let smallestAudioSample;
@@ -13636,51 +14323,85 @@ var slowDurationAndFpsState = () => {
     }
     return Math.max(videoDuration ?? 0, audioDuration ?? 0);
   };
+  const addVideoSample = (videoSample) => {
+    videoSamples.set(videoSample.cts, videoSample.data.byteLength);
+    const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+    if (largestVideoSample === undefined || presentationTimeInSeconds > largestVideoSample) {
+      largestVideoSample = presentationTimeInSeconds;
+    }
+    if (smallestVideoSample === undefined || presentationTimeInSeconds < smallestVideoSample) {
+      smallestVideoSample = presentationTimeInSeconds;
+    }
+  };
+  const addAudioSample = (audioSample) => {
+    audioSamples.set(audioSample.cts, audioSample.data.byteLength);
+    const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
+    if (largestAudioSample === undefined || presentationTimeInSeconds > largestAudioSample) {
+      largestAudioSample = presentationTimeInSeconds;
+    }
+    if (smallestAudioSample === undefined || presentationTimeInSeconds < smallestAudioSample) {
+      smallestAudioSample = presentationTimeInSeconds;
+    }
+  };
+  const getFps2 = () => {
+    const videoDuration = getSlowVideoDurationInSeconds() ?? 0;
+    if (videoDuration === 0) {
+      return 0;
+    }
+    return videoSamples.size / videoDuration;
+  };
+  const getSlowNumberOfFrames = () => videoSamples.size;
+  const getAudioBitrate = () => {
+    const audioDuration = getSlowDurationInSeconds();
+    if (audioDuration === 0 || audioSamples.size === 0) {
+      return null;
+    }
+    const audioSizesInBytes = Array.from(audioSamples.values()).reduce((acc, size) => acc + size, 0);
+    return audioSizesInBytes * 8 / audioDuration;
+  };
+  const getVideoBitrate = () => {
+    const videoDuration = getSlowDurationInSeconds();
+    if (videoDuration === 0 || videoSamples.size === 0) {
+      return null;
+    }
+    const videoSizesInBytes = Array.from(videoSamples.values()).reduce((acc, size) => acc + size, 0);
+    return videoSizesInBytes * 8 / videoDuration;
+  };
   return {
-    addVideoSample: (videoSample) => {
-      videoSamples.set(videoSample.cts, videoSample.data.byteLength);
-      const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
-      if (largestVideoSample === undefined || presentationTimeInSeconds > largestVideoSample) {
-        largestVideoSample = presentationTimeInSeconds;
-      }
-      if (smallestVideoSample === undefined || presentationTimeInSeconds < smallestVideoSample) {
-        smallestVideoSample = presentationTimeInSeconds;
-      }
-    },
-    addAudioSample: (audioSample) => {
-      audioSamples.set(audioSample.cts, audioSample.data.byteLength);
-      const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
-      if (largestAudioSample === undefined || presentationTimeInSeconds > largestAudioSample) {
-        largestAudioSample = presentationTimeInSeconds;
-      }
-      if (smallestAudioSample === undefined || presentationTimeInSeconds < smallestAudioSample) {
-        smallestAudioSample = presentationTimeInSeconds;
-      }
-    },
+    addVideoSample,
+    addAudioSample,
     getSlowDurationInSeconds,
-    getFps: () => {
-      const videoDuration = getSlowVideoDurationInSeconds() ?? 0;
-      if (videoDuration === 0) {
-        return 0;
+    getFps: getFps2,
+    getSlowNumberOfFrames,
+    getAudioBitrate,
+    getVideoBitrate
+  };
+};
+
+// src/state/seek-infinite-loop.ts
+var seekInfiniteLoopDetectionState = () => {
+  let lastSeek = null;
+  let firstSeekTime = null;
+  return {
+    registerSeek: (byte) => {
+      const now = Date.now();
+      if (!lastSeek || lastSeek.byte !== byte) {
+        lastSeek = { byte, numberOfTimes: 1 };
+        firstSeekTime = now;
+        return;
       }
-      return videoSamples.size / videoDuration;
-    },
-    getSlowNumberOfFrames: () => videoSamples.size,
-    getAudioBitrate: () => {
-      const audioDuration = getSlowDurationInSeconds();
-      if (audioDuration === 0 || audioSamples.size === 0) {
-        return null;
+      lastSeek.numberOfTimes++;
+      if (lastSeek.numberOfTimes >= 10 && firstSeekTime && now - firstSeekTime <= 2000) {
+        throw new Error(`Seeking infinite loop detected: Seeked to byte 0x${byte.toString(16)} ${lastSeek.numberOfTimes} times in a row in the last 2 seconds. Check your usage of .seek().`);
       }
-      const audioSizesInBytes = Array.from(audioSamples.values()).reduce((acc, size) => acc + size, 0);
-      return audioSizesInBytes * 8 / audioDuration;
-    },
-    getVideoBitrate: () => {
-      const videoDuration = getSlowDurationInSeconds();
-      if (videoDuration === 0 || videoSamples.size === 0) {
-        return null;
+      if (now - firstSeekTime > 2000) {
+        lastSeek = { byte, numberOfTimes: 1 };
+        firstSeekTime = now;
       }
-      const videoSizesInBytes = Array.from(videoSamples.values()).reduce((acc, size) => acc + size, 0);
-      return videoSizesInBytes * 8 / videoDuration;
+    },
+    reset: () => {
+      lastSeek = null;
+      firstSeekTime = null;
     }
   };
 };
@@ -13696,7 +14417,21 @@ var timingsState = () => {
   };
 };
 
-// src/containers/transport-stream/next-pes-header-store.ts
+// src/state/transport-stream/last-emitted-sample.ts
+var lastEmittedSampleState = () => {
+  let lastEmittedSample = null;
+  return {
+    setLastEmittedSample: (sample) => {
+      lastEmittedSample = sample;
+    },
+    getLastEmittedSample: () => lastEmittedSample,
+    resetLastEmittedSample: () => {
+      lastEmittedSample = null;
+    }
+  };
+};
+
+// src/state/transport-stream/next-pes-header-store.ts
 var makeNextPesHeaderStore = () => {
   let nextPesHeader = null;
   return {
@@ -13712,111 +14447,34 @@ var makeNextPesHeaderStore = () => {
   };
 };
 
-// src/state/transport-stream.ts
-var transportStreamState = () => {
+// src/state/transport-stream/pts-start-offset.ts
+var ptsStartOffsetStore = () => {
+  const offsets = {};
   return {
-    nextPesHeaderStore: makeNextPesHeaderStore(),
-    streamBuffers: new Map
+    getOffset: (trackId) => offsets[trackId] || 0,
+    setOffset: (trackId, newOffset) => {
+      offsets[trackId] = newOffset;
+    }
   };
 };
 
-// src/state/webm.ts
-var webmState = () => {
-  const trackEntries = {};
-  const onTrackEntrySegment = (trackEntry2) => {
-    const trackId = getTrackId(trackEntry2);
-    if (!trackId) {
-      throw new Error("Expected track id");
-    }
-    if (trackEntries[trackId]) {
-      return;
-    }
-    const codec = getTrackCodec(trackEntry2);
-    if (!codec) {
-      throw new Error("Expected codec");
-    }
-    const trackTimescale = getTrackTimestampScale(trackEntry2);
-    trackEntries[trackId] = {
-      codec: codec.value,
-      trackTimescale: trackTimescale?.value ?? null
-    };
-  };
-  const timestampMap = new Map;
-  const getTimestampOffsetForByteOffset = (byteOffset) => {
-    const entries = Array.from(timestampMap.entries());
-    const sortedByByteOffset = entries.sort((a, b) => {
-      return a[0] - b[0];
-    }).reverse();
-    for (const [offset, timestamp] of sortedByByteOffset) {
-      if (offset >= byteOffset) {
-        continue;
-      }
-      return timestamp;
-    }
-    return timestampMap.get(byteOffset);
-  };
-  const setTimestampOffset = (byteOffset, timestamp) => {
-    timestampMap.set(byteOffset, timestamp);
-  };
-  let timescale = null;
-  const setTimescale = (newTimescale) => {
-    timescale = newTimescale;
-  };
-  const getTimescale = () => {
-    if (timescale === null) {
-      return 1e6;
-    }
-    return timescale;
-  };
-  const segments = [];
-  const clusters = [];
-  const avcProfilesMap = {};
-  const setAvcProfileForTrackNumber = (trackNumber2, avcProfile) => {
-    avcProfilesMap[trackNumber2] = avcProfile;
-  };
-  const getAvcProfileForTrackNumber = (trackNumber2) => {
-    return avcProfilesMap[trackNumber2] ?? null;
-  };
-  return {
-    onTrackEntrySegment,
-    getTrackInfoByNumber: (id) => trackEntries[id],
-    setTimestampOffset,
-    getTimestampOffsetForByteOffset,
-    timescale,
-    getTimescale,
-    setTimescale,
-    addSegment: (seg) => {
-      const segment = {
-        ...seg,
-        index: segments.length
-      };
-      segments.push(segment);
-    },
-    addCluster: (cluster) => {
-      clusters.push(cluster);
-    },
-    isInsideSegment: (iterator) => {
-      const offset = iterator.counter.getOffset();
-      const insideClusters = segments.filter((cluster) => {
-        return offset >= cluster.start && offset <= cluster.start + cluster.size;
-      });
-      if (insideClusters.length > 1) {
-        throw new Error("Expected to only be inside 1 cluster");
-      }
-      return insideClusters[0] ?? null;
-    },
-    isInsideCluster: (iterator) => {
-      for (const cluster of clusters) {
-        const offset = iterator.counter.getOffset();
-        if (offset >= cluster.start && offset <= cluster.start + cluster.size) {
-          return cluster;
-        }
-      }
-      return null;
+// src/state/transport-stream/transport-stream.ts
+var transportStreamState = () => {
+  const streamBuffers = new Map;
+  const startOffset = ptsStartOffsetStore();
+  const lastEmittedSample = lastEmittedSampleState();
+  const state = {
+    nextPesHeaderStore: makeNextPesHeaderStore(),
+    observedPesHeaders: makeObservedPesHeader(),
+    streamBuffers,
+    startOffset,
+    resetBeforeSeek: () => {
+      state.streamBuffers.clear();
+      state.nextPesHeaderStore = makeNextPesHeaderStore();
     },
-    setAvcProfileForTrackNumber,
-    getAvcProfileForTrackNumber
+    lastEmittedSample
   };
+  return state;
 };
 
 // src/state/parser-state.ts
@@ -13840,7 +14498,8 @@ var makeParserState = ({
   callbacks,
   fieldsInReturnValue,
   mimeType,
-  initialReaderInstance
+  initialReaderInstance,
+  makeSamplesStartAtZero
 }) => {
   let skippedBytes = 0;
   const returnValue = {};
@@ -13851,7 +14510,7 @@ var makeParserState = ({
   const structure = structureState();
   const keyframes = keyframesState();
   const emittedFields = emittedState();
-  const slowDurationAndFps = slowDurationAndFpsState();
+  const slowDurationAndFps = samplesObservedState();
   const mp3Info = makeMp3State();
   const images = imagesState();
   const timings = timingsState();
@@ -13874,7 +14533,7 @@ var makeParserState = ({
   return {
     riff: riffSpecificState(),
     transportStream: transportStreamState(),
-    webm: webmState(),
+    webm: webmState({ controller, logLevel, readerInterface, src }),
     iso: isoBaseMediaState({
       contentLength,
       controller,
@@ -13934,7 +14593,8 @@ var makeParserState = ({
     mimeType,
     errored,
     currentReader: currentReaderState,
-    seekInfiniteLoop
+    seekInfiniteLoop,
+    makeSamplesStartAtZero
   };
 };
 
@@ -14016,6 +14676,7 @@ var internalParseMedia = async function({
   selectM3uStream: selectM3uStreamFn,
   selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn,
   mp4HeaderSegment,
+  makeSamplesStartAtZero,
   ...more
 }) {
   controller._internals.markAsReadyToEmitEvents();
@@ -14024,7 +14685,7 @@ var internalParseMedia = async function({
     logLevel,
     apiName
   });
-  Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src instanceof URL ? src.toString() : src.name}`);
+  Log.verbose(logLevel, `Reading ${typeof src === "string" ? src : src instanceof URL ? src.toString() : src instanceof File ? src.name : src.toString()}`);
   const {
     reader: readerInstance,
     contentLength,
@@ -14061,7 +14722,8 @@ var internalParseMedia = async function({
     callbacks: more,
     fieldsInReturnValue: _fieldsInReturnValue ?? {},
     mimeType: contentType,
-    initialReaderInstance: readerInstance
+    initialReaderInstance: readerInstance,
+    makeSamplesStartAtZero
   });
   if (!hasAudioTrackHandlers && !hasVideoTrackHandlers && Object.values(state.fields).every((v) => !v) && mode === "query") {
     Log.warn(logLevel, new Error("Warning - No `fields` and no `on*` callbacks were passed to `parseMedia()`. Specify the data you would like to retrieve."));
@@ -14492,7 +15154,8 @@ var startParsing = async (message, reader) => {
           });
         };
       } : null,
-      onDiscardedData: null
+      onDiscardedData: null,
+      makeSamplesStartAtZero: true
     });
     post({
       type: "response-done",