@remotion/media-parser 4.0.311 → 4.0.313

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

@@ -750,24 +750,38 @@ var mediaParserController = () => {
     await pauseSignal.waitUntilResume();
   };
   let seekingHintResolution = null;
+  let simulateSeekResolution = null;
   const getSeekingHints = () => {
     if (!seekingHintResolution) {
       throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
     }
     return seekingHintResolution();
   };
+  const simulateSeek = (seekInSeconds) => {
+    if (!simulateSeekResolution) {
+      throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
+    }
+    return simulateSeekResolution(seekInSeconds);
+  };
   const attachSeekingHintResolution = (callback) => {
     if (seekingHintResolution) {
       throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
     }
     seekingHintResolution = callback;
   };
+  const attachSimulateSeekResolution = (callback) => {
+    if (simulateSeekResolution) {
+      throw new Error("The mediaParserController() was used in multiple parseMedia() calls. Create a separate controller for each call.");
+    }
+    simulateSeekResolution = callback;
+  };
   return {
     abort: (reason) => {
       abortController.abort(reason);
       emitter.dispatchAbort(reason);
     },
     seek: seekSignal.seek,
+    simulateSeek,
     pause: pauseSignal.pause,
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
@@ -779,7 +793,8 @@ var mediaParserController = () => {
       seekSignal,
       markAsReadyToEmitEvents: emitter.markAsReady,
       performedSeeksSignal,
-      attachSeekingHintResolution
+      attachSeekingHintResolution,
+      attachSimulateSeekResolution
     }
   };
 };
@@ -1053,6 +1068,21 @@ var getTrunBoxes = (segment) => {
   const trunBoxes = segment.children.filter((c) => c.type === "trun-box");
   return trunBoxes;
 };
+var getMvexBox = (moovAtom) => {
+  const mvexBox = moovAtom.children.find((s) => s.type === "regular-box" && s.boxType === "mvex");
+  if (!mvexBox || mvexBox.type !== "regular-box") {
+    return null;
+  }
+  return mvexBox;
+};
+var getTrexBoxes = (moovAtom) => {
+  const mvexBox = getMvexBox(moovAtom);
+  if (!mvexBox) {
+    return [];
+  }
+  const trexBoxes = mvexBox.children.filter((c) => c.type === "trex-box");
+  return trexBoxes;
+};
 var getTfraBoxesFromMfraBoxChildren = (mfraBoxChildren) => {
   const tfraBoxes = mfraBoxChildren.filter((b) => b.type === "tfra-box");
   return tfraBoxes;
@@ -2425,14 +2455,28 @@ var detectFileType = (data) => {
 };
 
 // src/iterator/buffer-manager.ts
+var makeBufferWithMaxBytes = (initialData, maxBytes) => {
+  const maxByteLength = Math.min(maxBytes, 2 ** 31);
+  try {
+    const buf = new ArrayBuffer(initialData.byteLength, {
+      maxByteLength
+    });
+    return buf;
+  } catch (e) {
+    if (e instanceof RangeError && maxBytes > 2 ** 27) {
+      return new ArrayBuffer(initialData.byteLength, {
+        maxByteLength: 2 ** 27
+      });
+    }
+    throw e;
+  }
+};
 var bufferManager = ({
   initialData,
   maxBytes,
   counter
 }) => {
-  const buf = new ArrayBuffer(initialData.byteLength, {
-    maxByteLength: maxBytes === null ? initialData.byteLength : Math.min(maxBytes, 2 ** 31)
-  });
+  const buf = makeBufferWithMaxBytes(initialData, maxBytes);
   if (!buf.resize) {
     throw new Error("`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111");
   }
@@ -4812,14 +4856,15 @@ var areSamplesComplete = ({
 };
 
 // src/samples-from-moof.ts
-var getSamplesFromTraf = (trafSegment, moofOffset) => {
+var getSamplesFromTraf = (trafSegment, moofOffset, trexBoxes) => {
   if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
     throw new Error("Expected traf-box");
   }
   const tfhdBox = getTfhdBox(trafSegment);
-  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
-  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
-  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+  const trexBox = trexBoxes.find((t) => t.trackId === tfhdBox?.trackId) ?? null;
+  const defaultTrackSampleDuration = tfhdBox?.defaultSampleDuration || trexBox?.defaultSampleDuration || null;
+  const defaultTrackSampleSize = tfhdBox?.defaultSampleSize || trexBox?.defaultSampleSize || null;
+  const defaultTrackSampleFlags = tfhdBox?.defaultSampleFlags ?? trexBox?.defaultSampleFlags ?? null;
   const tfdtBox = getTfdtBox(trafSegment);
   const trunBoxes = getTrunBoxes(trafSegment);
   let time = 0;
@@ -4834,16 +4879,16 @@ var getSamplesFromTraf = (trafSegment, moofOffset) => {
     }
     for (const sample of trunBox.samples) {
       i++;
-      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
+      const duration2 = sample.sampleDuration || defaultTrackSampleDuration;
       if (duration2 === null) {
         throw new Error("Expected duration");
       }
-      const size = sample.sampleSize ?? defaultSampleSize;
+      const size = sample.sampleSize ?? defaultTrackSampleSize;
       if (size === null) {
         throw new Error("Expected size");
       }
       const isFirstSample = i === 0;
-      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
+      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultTrackSampleFlags;
       if (sampleFlags === null) {
         throw new Error("Expected sample flags");
       }
@@ -4869,14 +4914,15 @@ var getSamplesFromTraf = (trafSegment, moofOffset) => {
 };
 var getSamplesFromMoof = ({
   moofBox,
-  trackId
+  trackId,
+  trexBoxes
 }) => {
   const mapped = moofBox.trafBoxes.map((traf) => {
     const tfhdBox = getTfhdBox(traf);
     if (!tfhdBox || tfhdBox.trackId !== trackId) {
       return [];
     }
-    return getSamplesFromTraf(traf, moofBox.offset);
+    return getSamplesFromTraf(traf, moofBox.offset, trexBoxes);
   });
   return mapped.flat(1);
 };
@@ -4885,7 +4931,8 @@ var getSamplesFromMoof = ({
 var collectSamplePositionsFromMoofBoxes = ({
   moofBoxes,
   tkhdBox,
-  isComplete
+  isComplete,
+  trexBoxes
 }) => {
   const samplePositions = moofBoxes.map((m, index) => {
     const isLastFragment = index === moofBoxes.length - 1 && isComplete;
@@ -4893,7 +4940,8 @@ var collectSamplePositionsFromMoofBoxes = ({
       isLastFragment,
       samples: getSamplesFromMoof({
         moofBox: m,
-        trackId: tkhdBox.trackId
+        trackId: tkhdBox.trackId,
+        trexBoxes
       })
     };
   });
@@ -5066,7 +5114,8 @@ var collectSamplePositionsFromTrak = (trakBox) => {
 var getSamplePositionsFromTrack = ({
   trakBox,
   moofBoxes,
-  moofComplete
+  moofComplete,
+  trexBoxes
 }) => {
   const tkhdBox = getTkhdBox(trakBox);
   if (!tkhdBox) {
@@ -5076,7 +5125,8 @@ var getSamplePositionsFromTrack = ({
     const { samplePositions } = collectSamplePositionsFromMoofBoxes({
       moofBoxes,
       tkhdBox,
-      isComplete: moofComplete
+      isComplete: moofComplete,
+      trexBoxes
     });
     return {
       samplePositions: samplePositions.map((s) => s.samples).flat(1),
@@ -5362,7 +5412,8 @@ var getDurationFromIsoBaseMedia = (parserState) => {
     const { samplePositions, isComplete } = getSamplePositionsFromTrack({
       trakBox,
       moofBoxes,
-      moofComplete: areSamplesComplete({ moofBoxes, tfraBoxes })
+      moofComplete: areSamplesComplete({ moofBoxes, tfraBoxes }),
+      trexBoxes: getTrexBoxes(moovBox)
     });
     if (!isComplete) {
       return null;
@@ -5468,7 +5519,8 @@ var getKeyframesFromIsoBaseMedia = (state) => {
       moofComplete: areSamplesComplete({
         moofBoxes,
         tfraBoxes
-      })
+      }),
+      trexBoxes: getTrexBoxes(moov)
     });
     if (!isComplete) {
       return [];
@@ -5844,7 +5896,11 @@ var getSeekingByteForAac = ({
     }
   }
   if (bestAudioSample) {
-    return { type: "do-seek", byte: bestAudioSample.offset };
+    return {
+      type: "do-seek",
+      byte: bestAudioSample.offset,
+      timeInSeconds: bestAudioSample.timeInSeconds
+    };
   }
   return { type: "valid-but-must-wait" };
 };
@@ -5871,7 +5927,7 @@ var getSeekingByteForFlac = ({
     }
   }
   if (bestAudioSample) {
-    return bestAudioSample.offset;
+    return bestAudioSample;
   }
   return null;
 };
@@ -5909,7 +5965,7 @@ var findKeyframeBeforeTime = ({
     Log.trace(logLevel, "Found a sample, but the offset has not yet been marked as a video section yet. Not yet able to seek, but probably once we have started reading the next box.", videoSample);
     return null;
   }
-  return videoSample.offset;
+  return videoSample;
 };
 
 // src/containers/iso-base-media/find-track-to-seek.ts
@@ -5930,7 +5986,8 @@ var findAnyTrackWithSamplePositions = (allTracks, struc) => {
         moofComplete: areSamplesComplete({
           moofBoxes: getMoofBoxes(struc.boxes),
           tfraBoxes: getTfraBoxes(struc.boxes)
-        })
+        }),
+        trexBoxes: getTrexBoxes(moov)
       });
       if (samplePositions.length === 0) {
         continue;
@@ -5960,7 +6017,8 @@ var findTrackToSeek = (allTracks, structure) => {
     moofComplete: areSamplesComplete({
       moofBoxes: getMoofBoxes(struc.boxes),
       tfraBoxes: getTfraBoxes(struc.boxes)
-    })
+    }),
+    trexBoxes: getTrexBoxes(moov)
   });
   if (samplePositions.length === 0) {
     return findAnyTrackWithSamplePositions(allTracks, struc);
@@ -6122,7 +6180,8 @@ var getSeekingByteFromFragmentedMp4 = async ({
   const { samplePositions: samplePositionsArray } = collectSamplePositionsFromMoofBoxes({
     moofBoxes: info.moofBoxes,
     tkhdBox,
-    isComplete
+    isComplete,
+    trexBoxes: getTrexBoxes(moov)
   });
   Log.trace(logLevel, "Fragmented MP4 - Checking if we have seeking info for this time range");
   for (const positions of samplePositionsArray) {
@@ -6140,7 +6199,8 @@ var getSeekingByteFromFragmentedMp4 = async ({
       if (kf) {
         return {
           type: "do-seek",
-          byte: kf
+          byte: kf.offset,
+          timeInSeconds: Math.min(kf.decodingTimestamp, kf.timestamp) / firstTrack.originalTimescale
         };
       }
     }
@@ -6243,7 +6303,8 @@ var getSeekingByteFromIsoBaseMedia = ({
   if (keyframe) {
     return Promise.resolve({
       type: "do-seek",
-      byte: keyframe
+      byte: keyframe.offset,
+      timeInSeconds: Math.min(keyframe.decodingTimestamp, keyframe.timestamp) / track.originalTimescale
     });
   }
   return Promise.resolve({
@@ -6283,7 +6344,8 @@ var getSeekingByteForM3u8 = ({
   }
   return {
     type: "do-seek",
-    byte: currentPosition
+    byte: currentPosition,
+    timeInSeconds: time
   };
 };
 
@@ -6517,9 +6579,12 @@ var getSeekingByteForMp3 = ({
       type: "valid-but-must-wait"
     };
   }
+  const byte = Math.max(...candidates);
+  const timeInSeconds = byte === bestAudioSample?.offset ? bestAudioSample.timeInSeconds : time;
   return {
     type: "do-seek",
-    byte: Math.max(...candidates)
+    byte,
+    timeInSeconds
   };
 };
 
@@ -6563,7 +6628,8 @@ var getSeekingByteForRiff = async ({
     avcState.clear();
     return {
       type: "do-seek",
-      byte: lastKeyframe.positionInBytes
+      byte: lastKeyframe.positionInBytes,
+      timeInSeconds: Math.min(lastKeyframe.decodingTimeInSeconds, lastKeyframe.presentationTimeInSeconds)
     };
   }
   if (idx1Entries.videoTrackIndex === null) {
@@ -6594,121 +6660,8 @@ var getSeekingByteForRiff = async ({
   avcState.clear();
   return {
     type: "do-seek",
-    byte: bestEntry.offset + info.moviOffset - 4
-  };
-};
-
-// src/containers/wav/get-seeking-byte.ts
-var WAVE_SAMPLES_PER_SECOND = 25;
-var getSeekingByteFromWav = ({
-  info,
-  time
-}) => {
-  const bytesPerSecond = info.sampleRate * info.blockAlign;
-  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
-  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
-  const byteOffset = bytesPerSecond * timeRoundedDown;
-  return Promise.resolve({
-    type: "do-seek",
-    byte: byteOffset + info.mediaSection.start
-  });
-};
-
-// src/containers/webm/seek/get-seeking-byte.ts
-var toSeconds = (timeInTimescale, track) => {
-  return timeInTimescale / track.timescale * 1000;
-};
-var findBiggestCueBeforeTime = ({
-  cues,
-  time,
-  track
-}) => {
-  let biggestCueBeforeTime;
-  for (const cue of cues) {
-    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
-    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
-      biggestCueBeforeTime = cue;
-    }
-  }
-  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 keyframeBeforeTime?.positionInBytes ?? null;
-};
-var getByteFromCues = ({
-  cuesResponse,
-  time,
-  info,
-  logLevel
-}) => {
-  if (!cuesResponse) {
-    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
-    return null;
-  }
-  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;
-  }
-  return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
-};
-var getSeekingByteFromMatroska = async ({
-  time,
-  webmState,
-  info,
-  logLevel,
-  mediaSection
-}) => {
-  if (!info.track) {
-    Log.trace(logLevel, "No video track found, cannot seek yet");
-    return {
-      type: "valid-but-must-wait"
-    };
-  }
-  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
-  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
-    keyframes: info.keyframes,
-    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"
-    };
-  }
-  mediaSection.addMediaSection({
-    start: byteToSeekTo,
-    size: 1
-  });
-  return {
-    type: "do-seek",
-    byte: byteToSeekTo
+    byte: bestEntry.offset + info.moviOffset - 4,
+    timeInSeconds: bestEntry.sampleCounts[idx1Entries.videoTrackIndex] / info.samplesPerSecond
   };
 };
 
@@ -7250,6 +7203,137 @@ var handleAvcPacket = async ({
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
+// src/containers/wav/get-seeking-byte.ts
+var WAVE_SAMPLES_PER_SECOND = 25;
+var getSeekingByteFromWav = ({
+  info,
+  time
+}) => {
+  const bytesPerSecond = info.sampleRate * info.blockAlign;
+  const durationInSeconds = info.mediaSection.size / bytesPerSecond;
+  const timeRoundedDown = Math.floor(Math.min(time, durationInSeconds - 0.0000001) * WAVE_SAMPLES_PER_SECOND) / WAVE_SAMPLES_PER_SECOND;
+  const byteOffset = bytesPerSecond * timeRoundedDown;
+  return Promise.resolve({
+    type: "do-seek",
+    byte: byteOffset + info.mediaSection.start,
+    timeInSeconds: timeRoundedDown
+  });
+};
+
+// src/containers/webm/seek/get-seeking-byte.ts
+var toSeconds = (timeInTimescale, track) => {
+  return timeInTimescale / track.timescale * 1000;
+};
+var findBiggestCueBeforeTime = ({
+  cues,
+  time,
+  track
+}) => {
+  let biggestCueBeforeTime;
+  for (const cue of cues) {
+    const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+    if (cueTimeInSeconds < time && (!biggestCueBeforeTime || cueTimeInSeconds > toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+      biggestCueBeforeTime = cue;
+    }
+  }
+  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 keyframeBeforeTime ?? null;
+};
+var getByteFromCues = ({
+  cuesResponse,
+  time,
+  info,
+  logLevel
+}) => {
+  if (!cuesResponse) {
+    Log.trace(logLevel, "Has no Matroska cues at the moment, cannot use them");
+    return null;
+  }
+  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;
+  }
+  return {
+    byte: biggestCueBeforeTime.clusterPositionInSegment + segmentOffset,
+    timeInSeconds: toSeconds(biggestCueBeforeTime.timeInTimescale, info.track)
+  };
+};
+var getSeekingByteFromMatroska = async ({
+  time,
+  webmState,
+  info,
+  logLevel,
+  mediaSection
+}) => {
+  if (!info.track) {
+    Log.trace(logLevel, "No video track found, cannot seek yet");
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
+  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
+  const byteFromObservedKeyframe = findKeyframeBeforeTime2({
+    keyframes: info.keyframes,
+    time
+  });
+  const byteFromCues = getByteFromCues({
+    cuesResponse,
+    time,
+    info,
+    logLevel
+  });
+  const byteFromFirstMediaSection = webmState.getFirstCluster()?.start ?? null;
+  const seekPossibilities = [
+    byteFromCues?.byte ?? null,
+    byteFromObservedKeyframe?.positionInBytes ?? null,
+    byteFromFirstMediaSection
+  ].filter((n) => n !== null);
+  const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
+  if (byteToSeekTo === null) {
+    return {
+      type: "invalid"
+    };
+  }
+  mediaSection.addMediaSection({
+    start: byteToSeekTo,
+    size: 1
+  });
+  const timeInSeconds = (() => {
+    if (byteToSeekTo === byteFromObservedKeyframe?.positionInBytes) {
+      return Math.min(byteFromObservedKeyframe.decodingTimeInSeconds, byteFromObservedKeyframe.presentationTimeInSeconds);
+    }
+    if (byteToSeekTo === byteFromCues?.byte) {
+      return byteFromCues.timeInSeconds;
+    }
+    if (byteToSeekTo === byteFromFirstMediaSection) {
+      return 0;
+    }
+    throw new Error("Should not happen");
+  })();
+  return {
+    type: "do-seek",
+    byte: byteToSeekTo,
+    timeInSeconds
+  };
+};
+
 // src/state/transport-stream/observed-pes-header.ts
 var makeObservedPesHeader = () => {
   const pesHeaders = [];
@@ -7339,7 +7423,8 @@ var getSeekingByte = ({
     if (byte) {
       return Promise.resolve({
         type: "do-seek",
-        byte
+        byte: byte.offset,
+        timeInSeconds: byte.timeInSeconds
       });
     }
     return Promise.resolve({
@@ -7352,11 +7437,20 @@ var getSeekingByte = ({
       timeInSeconds: time,
       ptsStartOffset: info.ptsStartOffset
     });
-    const byte = lastKeyframeBeforeTimeInSeconds?.offset ?? 0;
+    if (!lastKeyframeBeforeTimeInSeconds) {
+      transportStream.resetBeforeSeek();
+      return Promise.resolve({
+        type: "do-seek",
+        byte: 0,
+        timeInSeconds: 0
+      });
+    }
+    const byte = lastKeyframeBeforeTimeInSeconds.offset;
     transportStream.resetBeforeSeek();
     return Promise.resolve({
       type: "do-seek",
-      byte
+      byte,
+      timeInSeconds: Math.min(lastKeyframeBeforeTimeInSeconds.pts, lastKeyframeBeforeTimeInSeconds.dts ?? Infinity) / MPEG_TIMESCALE
     });
   }
   if (info.type === "riff-seeking-hints") {
@@ -9239,7 +9333,8 @@ var calculateFlatSamples = ({
     const { samplePositions } = getSamplePositionsFromTrack({
       trakBox,
       moofBoxes: relevantMoofBox ? [relevantMoofBox] : [],
-      moofComplete
+      moofComplete,
+      trexBoxes: getTrexBoxes(moov)
     });
     return samplePositions.map((samplePosition) => {
       return {
@@ -9955,7 +10050,7 @@ var toUnixTimestamp = (value) => {
   return Math.floor(value + baseDate.getTime() / 1000) * 1000;
 };
 
-// src/containers/iso-base-media/mvhd.ts
+// src/containers/iso-base-media/moov/mvhd.ts
 var parseMvhd = ({
   iterator,
   offset,
@@ -10011,6 +10106,34 @@ var parseMvhd = ({
   };
 };
 
+// src/containers/iso-base-media/moov/trex.ts
+var parseTrex = ({
+  iterator,
+  offset,
+  size
+}) => {
+  const box = iterator.startBox(size - 8);
+  const version = iterator.getUint8();
+  iterator.discard(3);
+  const trackId = iterator.getUint32();
+  const defaultSampleDescriptionIndex = iterator.getUint32();
+  const defaultSampleDuration = iterator.getUint32();
+  const defaultSampleSize = iterator.getUint32();
+  const defaultSampleFlags = iterator.getUint32();
+  box.expectNoMoreBytes();
+  return {
+    type: "trex-box",
+    boxSize: size,
+    offset,
+    trackId,
+    version,
+    defaultSampleDescriptionIndex,
+    defaultSampleDuration,
+    defaultSampleSize,
+    defaultSampleFlags
+  };
+};
+
 // src/containers/iso-base-media/stsd/av1c.ts
 var parseAv1C = ({
   data,
@@ -11383,10 +11506,16 @@ var processBox = async ({
       })
     };
   }
+  if (boxType === "trex") {
+    return {
+      type: "box",
+      box: await parseTrex({ iterator, offset: fileOffset, size: boxSize })
+    };
+  }
   if (boxType === "moof") {
     await onlyIfMoovAtomExpected?.isoState?.mfra.triggerLoad();
   }
-  if (boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "mfra" || boxType === "edts" || boxType === "stsb") {
+  if (boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "mfra" || boxType === "edts" || boxType === "mvex" || boxType === "stsb") {
     const children = await getIsoBaseMediaChildren({
       iterator,
       size: boxSize - 8,
@@ -11406,6 +11535,7 @@ var processBox = async ({
     };
   }
   iterator.discard(boxSize - 8);
+  Log.verbose(logLevel, "Unknown ISO Base Media Box:", boxType);
   return {
     type: "box",
     box: {
@@ -14778,10 +14908,11 @@ var parseList = ({
   const metadata = [];
   const remainingBytes = () => ckSize - (iterator.counter.getOffset() - startOffset);
   while (remainingBytes() > 0) {
-    if (remainingBytes() < 4) {
-      iterator.discard(remainingBytes());
-      break;
+    const byte = iterator.getUint8();
+    if (byte === 0) {
+      continue;
     }
+    iterator.counter.decrement(1);
     const key = iterator.getByteString(4, false);
     const size = iterator.getUint32Le();
     const value = iterator.getByteString(size, true);
@@ -16199,7 +16330,7 @@ var lazyMfraLoad = ({
       logLevel,
       prefetchCache
     }).then((boxes) => {
-      Log.verbose(logLevel, "Lazily found mfra atom.");
+      Log.verbose(logLevel, boxes ? "Lazily found mfra atom." : "No mfra atom found.");
       result = boxes;
       return boxes;
     });
@@ -17726,6 +17857,46 @@ var internalParseMedia = async function({
     contentLength: state.contentLength,
     aacState: state.aac
   })));
+  controller._internals.attachSimulateSeekResolution((seek2) => {
+    const {
+      aacState: aacState2,
+      avcState: avcState2,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      m3uState: m3uState2,
+      mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    } = getWorkOnSeekRequestOptions(state);
+    return turnSeekIntoByte({
+      aacState: aacState2,
+      seek: seek2,
+      avcState: avcState2,
+      contentLength,
+      flacState: flacState2,
+      isoState,
+      iterator,
+      keyframes,
+      logLevel,
+      m3uPlaylistContext,
+      m3uState: m3uState2,
+      mediaSectionState: mediaSection,
+      mp3State,
+      riffState,
+      samplesObserved,
+      structureState: structureState2,
+      tracksState,
+      transportStream,
+      webmState: webmState2
+    });
+  });
   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."));
   }
@@ -17779,6 +17950,21 @@ var forwardMediaParserControllerToWorker = (controller) => {
       });
       return;
     }
+    if (message.type === "request-simulate-seek") {
+      controller.simulateSeek(message.payload).then((resolution) => {
+        postMessage({
+          type: "response-simulate-seek",
+          nonce: message.nonce,
+          payload: resolution
+        });
+      }).catch((err) => {
+        postMessage({
+          type: "response-error",
+          payload: err
+        });
+      });
+      return;
+    }
     if (message.type === "request-resume") {
       controller.resume();
       return;