@remotion/media-parser 4.0.286 → 4.0.287

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

@@ -242,8 +242,7 @@ var fetchReadContent = async ({
   });
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      reader.reader.cancel().catch(() => {
-      });
+      reader.reader.cancel().catch(() => {});
     }, { once: true });
   }
   return {
@@ -537,6 +536,19 @@ var mediaParserController = () => {
     }
     await pauseSignal.waitUntilResume();
   };
+  let seekingHintResolution = null;
+  const getSeekingHints = () => {
+    if (!seekingHintResolution) {
+      throw new Error("The mediaParserController() was not yet used in a parseMedia() call");
+    }
+    return seekingHintResolution();
+  };
+  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;
+  };
   return {
     abort: (reason) => {
       abortController.abort(reason);
@@ -547,12 +559,14 @@ var mediaParserController = () => {
     resume: pauseSignal.resume,
     addEventListener: emitter.addEventListener,
     removeEventListener: emitter.removeEventListener,
+    getSeekingHints,
     _internals: {
       signal: abortController.signal,
       checkForAbortAndPause,
       seekSignal,
       markAsReadyToEmitEvents: emitter.markAsReady,
-      performedSeeksSignal
+      performedSeeksSignal,
+      attachSeekingHintResolution
     }
   };
 };
@@ -634,6 +648,29 @@ var m3uHasStreams = (state) => {
   return state.m3u.hasFinishedManifest();
 };
 
+// src/state/iso-base-media/precomputed-moof.ts
+var precomputedMoofState = () => {
+  let moofBoxes = [];
+  return {
+    getMoofBoxes: () => moofBoxes,
+    setMoofBoxes: (boxes) => {
+      moofBoxes = boxes;
+    }
+  };
+};
+var toMoofBox = (box) => {
+  if (box.type !== "regular-box") {
+    throw new Error("expected regular bpx");
+  }
+  return {
+    offset: box.offset,
+    trafBoxes: box.children.filter((c) => c.type === "regular-box" && c.boxType === "traf")
+  };
+};
+var deduplicateMoofBoxesByOffset = (moofBoxes) => {
+  return moofBoxes.filter((m, i, arr) => i === arr.findIndex((t) => t.offset === m.offset));
+};
+
 // src/containers/iso-base-media/traversal.ts
 var getMoovFromFromIsoStructure = (structure) => {
   const moovBox = structure.boxes.find((s) => s.type === "moov-box");
@@ -645,11 +682,12 @@ var getMoovFromFromIsoStructure = (structure) => {
 var getMoovBoxFromState = ({
   structureState,
   isoState,
-  mp4HeaderSegment
+  mp4HeaderSegment,
+  mayUsePrecomputed
 }) => {
-  const got = isoState.moov.getMoovBox();
-  if (got) {
-    return got;
+  const got = isoState.moov.getMoovBoxAndPrecomputed();
+  if (got && (mayUsePrecomputed || !got.precomputed)) {
+    return got.moovBox;
   }
   if (mp4HeaderSegment) {
     return getMoovFromFromIsoStructure(mp4HeaderSegment);
@@ -659,7 +697,7 @@ var getMoovBoxFromState = ({
 };
 var getMoofBoxes = (main) => {
   const moofBoxes = main.filter((s) => s.type === "regular-box" && s.boxType === "moof");
-  return moofBoxes;
+  return moofBoxes.map((m) => toMoofBox(m));
 };
 var getMvhdBox = (moovBox) => {
   const mvHdBox = moovBox.children.find((s) => s.type === "mvhd-box");
@@ -931,7 +969,8 @@ var getFpsFromIsoMaseMedia = (state) => {
   const moovBox = getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mayUsePrecomputed: true
   });
   if (!moovBox) {
     return null;
@@ -2089,6 +2128,40 @@ var detectFileType = (data) => {
   return { type: "unknown" };
 };
 
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
 // src/iterator/buffer-manager.ts
 var bufferManager = ({
   initialData,
@@ -2292,8 +2365,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   };
   const getPaddedFourByteNumber = () => {
     let lastInt = 128;
-    while (lastInt = getUint8(), lastInt === 128) {
-    }
+    while (lastInt = getUint8(), lastInt === 128) {}
     return lastInt;
   };
   const getUint32 = () => {
@@ -2361,11 +2433,11 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     return (1 << zerosCount) - 1 + suffix;
   };
   const peekB = (length) => {
-    console.log([...getSlice(length)].map((b) => b.toString(16).padStart(2, "0")));
+    Log.info("info", [...getSlice(length)].map((b) => b.toString(16).padStart(2, "0")));
     counter.decrement(length);
   };
   const peekD = (length) => {
-    console.log([...getSlice(length)].map((b) => b));
+    Log.info("info", [...getSlice(length)].map((b) => b.toString(16).padStart(2, "0")));
     counter.decrement(length);
   };
   const leb128 = () => {
@@ -2702,11 +2774,11 @@ var parseAv1PrivateData = (data, colrAtom) => {
 
 // src/get-video-codec.ts
 var getVideoCodec = (state) => {
-  const track = getTracks(state);
+  const track = getTracks(state, true);
   return track.videoTracks[0]?.codecWithoutConfig ?? null;
 };
 var hasVideoCodec = (state) => {
-  return getHasTracks(state);
+  return getHasTracks(state, true);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -3951,14 +4023,15 @@ var matroskaHasTracks = ({
 };
 
 // src/get-tracks.ts
-var isoBaseMediaHasTracks = (state) => {
+var isoBaseMediaHasTracks = (state, mayUsePrecomputed) => {
   return Boolean(getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mayUsePrecomputed
   }));
 };
-var getHasTracks = (state) => {
+var getHasTracks = (state, mayUsePrecomputed) => {
   const structure = state.structure.getStructure();
   if (structure.type === "matroska") {
     return matroskaHasTracks({
@@ -3967,7 +4040,7 @@ var getHasTracks = (state) => {
     });
   }
   if (structure.type === "iso-base-media") {
-    return isoBaseMediaHasTracks(state);
+    return isoBaseMediaHasTracks(state, mayUsePrecomputed);
   }
   if (structure.type === "riff") {
     return hasAllTracksFromAvi(state);
@@ -4039,11 +4112,12 @@ var getTracksFromMoovBox = (moovBox) => {
     otherTracks
   };
 };
-var getTracksFromIsoBaseMedia = (state) => {
+var getTracksFromIsoBaseMedia = (state, mayUsePrecomputed) => {
   const moovBox = getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mayUsePrecomputed
   });
   if (!moovBox) {
     return {
@@ -4065,13 +4139,13 @@ var defaultGetTracks = (parserState) => {
     videoTracks: tracks2.filter((t) => t.type === "video")
   };
 };
-var getTracks = (state) => {
+var getTracks = (state, mayUsePrecomputed) => {
   const structure = state.structure.getStructure();
   if (structure.type === "matroska") {
     return getCategorizedTracksFromMatroska(state);
   }
   if (structure.type === "iso-base-media") {
-    return getTracksFromIsoBaseMedia(state);
+    return getTracksFromIsoBaseMedia(state, mayUsePrecomputed);
   }
   if (structure.type === "riff") {
     return getTracksFromAvi(structure, state);
@@ -4087,7 +4161,7 @@ var getTracks = (state) => {
 
 // src/get-audio-codec.ts
 var getAudioCodec = (parserState) => {
-  const tracks2 = getTracks(parserState);
+  const tracks2 = getTracks(parserState, true);
   const allTracks = tracks2.audioTracks.length + tracks2.otherTracks.length + tracks2.videoTracks.length;
   if (allTracks === 0) {
     throw new Error("No tracks yet");
@@ -4102,7 +4176,7 @@ var getAudioCodec = (parserState) => {
   return null;
 };
 var hasAudioCodec = (state) => {
-  return getHasTracks(state);
+  return getHasTracks(state, true);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -4338,7 +4412,7 @@ var getDimensions = (state) => {
   if (structure && isAudioStructure(structure)) {
     return null;
   }
-  const { videoTracks } = getTracks(state);
+  const { videoTracks } = getTracks(state, true);
   if (!videoTracks.length) {
     return null;
   }
@@ -4431,13 +4505,12 @@ var getSamplesFromMoof = ({
   moofBox,
   trackId
 }) => {
-  if (moofBox.type !== "regular-box") {
-    throw new Error("Expected moof-box");
-  }
-  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
-  const mapped = trafs.map((traf) => {
+  const mapped = moofBox.trafBoxes.map((traf) => {
     const tfhdBox = getTfhdBox(traf);
-    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
+    if (!tfhdBox || tfhdBox.trackId !== trackId) {
+      return [];
+    }
+    return getSamplesFromTraf(traf, moofBox.offset);
   });
   return mapped.flat(1);
 };
@@ -4449,10 +4522,13 @@ var collectSamplePositionsFromMoofBoxes = ({
   tkhdBox
 }) => {
   const isComplete = tfraBoxes.length > 0 && tfraBoxes.every((t) => t.entries.length === moofBoxes.length);
-  const samplePositions_ = moofBoxes.map((m) => {
-    return getSamplesFromMoof({ moofBox: m, trackId: tkhdBox.trackId });
+  const samplePositions = moofBoxes.map((m) => {
+    return getSamplesFromMoof({
+      moofBox: m,
+      trackId: tkhdBox.trackId
+    });
   });
-  return { samplePositions: samplePositions_, isComplete };
+  return { samplePositions, isComplete };
 };
 
 // src/get-sample-positions.ts
@@ -4820,7 +4896,8 @@ var getDurationFromIsoBaseMedia = (parserState) => {
   const moovBox = getMoovBoxFromState({
     structureState: parserState.structure,
     isoState: parserState.iso,
-    mp4HeaderSegment: parserState.mp4HeaderSegment
+    mp4HeaderSegment: parserState.mp4HeaderSegment,
+    mayUsePrecomputed: true
   });
   if (!moovBox) {
     return null;
@@ -4837,7 +4914,7 @@ var getDurationFromIsoBaseMedia = (parserState) => {
   if (mvhdBox.durationInSeconds > 0) {
     return mvhdBox.durationInSeconds;
   }
-  const tracks2 = getTracks(parserState);
+  const tracks2 = getTracks(parserState, true);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -4901,7 +4978,7 @@ var hasDuration = (parserState) => {
   if (structure === null) {
     return false;
   }
-  return getHasTracks(parserState);
+  return getHasTracks(parserState, true);
 };
 var hasSlowDuration = (parserState) => {
   try {
@@ -4916,16 +4993,16 @@ var isVideoTrackHdr = (track) => {
   return track.color.matrixCoefficients === "bt2020" && track.color.transferCharacteristics === "arib-std-b67" && track.color.primaries === "bt2020";
 };
 var getIsHdr = (state) => {
-  const { videoTracks } = getTracks(state);
+  const { videoTracks } = getTracks(state, true);
   return videoTracks.some((track) => isVideoTrackHdr(track));
 };
 var hasHdr = (state) => {
-  return getHasTracks(state);
+  return getHasTracks(state, true);
 };
 
 // src/containers/iso-base-media/get-keyframes.ts
 var getKeyframesFromIsoBaseMedia = (state) => {
-  const { videoTracks } = getTracksFromIsoBaseMedia(state);
+  const { videoTracks } = getTracksFromIsoBaseMedia(state, true);
   const structure = state.structure.getIsoStructure();
   const moofBoxes = getMoofBoxes(structure.boxes);
   const tfraBoxes = getTfraBoxes(structure);
@@ -4966,7 +5043,7 @@ var getKeyframes = (state) => {
 var hasKeyframes = (parserState) => {
   const structure = parserState.structure.getStructure();
   if (structure.type === "iso-base-media") {
-    return getHasTracks(parserState);
+    return getHasTracks(parserState, true);
   }
   return true;
 };
@@ -5079,7 +5156,8 @@ var getMetadataFromIsoBase = (state) => {
   const moov = getMoovBoxFromState({
     structureState: state.structure,
     isoState: state.iso,
-    mp4HeaderSegment: state.mp4HeaderSegment
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mayUsePrecomputed: true
   });
   if (!moov) {
     return [];
@@ -5290,40 +5368,6 @@ var hasSampleRate = (state) => {
   return state.callbacks.tracks.hasAllTracks();
 };
 
-// src/log.ts
-var logLevels = ["trace", "verbose", "info", "warn", "error"];
-var getNumberForLogLevel = (level) => {
-  return logLevels.indexOf(level);
-};
-var isEqualOrBelowLogLevel = (currentLevel, level) => {
-  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
-};
-var Log = {
-  trace: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
-      return console.log(...args);
-    }
-  },
-  verbose: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
-      return console.log(...args);
-    }
-  },
-  info: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "info")) {
-      return console.log(...args);
-    }
-  },
-  warn: (logLevel, ...args) => {
-    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
-      return console.warn(...args);
-    }
-  },
-  error: (...args) => {
-    return console.error(...args);
-  }
-};
-
 // src/state/video-section.ts
 var isByteInMediaSection = ({
   position,
@@ -5466,13 +5510,15 @@ var findBestSegmentFromTfra = ({
   };
 };
 
-// src/containers/iso-base-media/get-seeking-from-mp4.ts
+// src/containers/iso-base-media/get-seeking-byte.ts
 var getSeekingByteFromIsoBaseMedia = async ({
   info,
   time,
   logLevel,
   currentPosition,
-  isoState
+  isoState,
+  mp4HeaderSegment,
+  structure
 }) => {
   const tracks2 = getTracksFromMoovBox(info.moovBox);
   const allTracks = [
@@ -5480,6 +5526,18 @@ var getSeekingByteFromIsoBaseMedia = async ({
     ...tracks2.audioTracks,
     ...tracks2.otherTracks
   ];
+  const hasMoov = Boolean(getMoovBoxFromState({
+    mp4HeaderSegment,
+    structureState: structure,
+    isoState,
+    mayUsePrecomputed: false
+  }));
+  if (!hasMoov) {
+    Log.trace(logLevel, "No moov box found, must wait");
+    return {
+      type: "valid-but-must-wait"
+    };
+  }
   const firstVideoTrack = allTracks.find((t) => t.type === "video");
   if (!firstVideoTrack) {
     throw new Error("No video track found");
@@ -5515,7 +5573,7 @@ var getSeekingByteFromIsoBaseMedia = async ({
         }
       }
     }
-    const atom = await isoState.mfra.triggerLoad();
+    const atom = await (info.mfraAlreadyLoaded ? Promise.resolve(info.mfraAlreadyLoaded) : isoState.mfra.triggerLoad());
     if (atom) {
       const moofOffset = findBestSegmentFromTfra({
         mfra: atom,
@@ -5586,12 +5644,12 @@ var getSeekingByteFromWav = ({
   time
 }) => {
   const bytesPerSecond = info.sampleRate * info.blockAlign;
-  const durationInSeconds = info.mediaSections.size / bytesPerSecond;
+  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.mediaSections.start
+    byte: byteOffset + info.mediaSection.start
   });
 };
 
@@ -5652,8 +5710,7 @@ var getSeekingByteFromMatroska = async ({
   webmState,
   info,
   logLevel,
-  mediaSection,
-  keyframes
+  mediaSection
 }) => {
   if (!info.track) {
     Log.trace(logLevel, "No video track found, cannot seek yet");
@@ -5661,9 +5718,9 @@ var getSeekingByteFromMatroska = async ({
       type: "valid-but-must-wait"
     };
   }
-  const cuesResponse = await webmState.cues.getLoadedCues();
+  const cuesResponse = info.loadedCues ?? await webmState.cues.getLoadedCues();
   const byteFromObservedKeyframe = findKeyframeBeforeTime2({
-    keyframes: keyframes.getKeyframes(),
+    keyframes: info.keyframes,
     time
   });
   const byteFromCues = getByteFromCues({
@@ -6114,7 +6171,10 @@ var handleAvcPacket = async ({
     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);
+    transportStream.startOffset.setOffset({
+      trackId: programId,
+      newOffset: startOffset
+    });
     const track = {
       m3uStreamFormat: null,
       rotation: 0,
@@ -6178,20 +6238,30 @@ var handleAvcPacket = async ({
 var makeObservedPesHeader = () => {
   const pesHeaders = [];
   const confirmedAsKeyframe = [];
+  const addPesHeader = (pesHeader) => {
+    if (pesHeaders.find((p) => p.offset === pesHeader.offset)) {
+      return;
+    }
+    pesHeaders.push(pesHeader);
+  };
+  const markPtsAsKeyframe = (pts) => {
+    confirmedAsKeyframe.push(pts);
+  };
+  const getPesKeyframeHeaders = () => {
+    return pesHeaders.filter((p) => confirmedAsKeyframe.includes(p.pts));
+  };
+  const setPesKeyframesFromSeekingHints = (hints) => {
+    for (const pesHeader of hints.observedPesHeaders) {
+      addPesHeader(pesHeader);
+      markPtsAsKeyframe(pesHeader.pts);
+    }
+  };
   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));
-    }
+    addPesHeader,
+    markPtsAsKeyframe,
+    getPesKeyframeHeaders,
+    setPesKeyframesFromSeekingHints
   };
   return state;
 };
@@ -6213,34 +6283,36 @@ var getSeekingByte = ({
   transportStream,
   webmState,
   mediaSection,
-  keyframes
+  mp4HeaderSegment,
+  structure
 }) => {
-  if (info.type === "iso-base-media-seeking-info") {
+  if (info.type === "iso-base-media-seeking-hints") {
     return getSeekingByteFromIsoBaseMedia({
       info,
       time,
       logLevel,
       currentPosition,
-      isoState
+      isoState,
+      mp4HeaderSegment,
+      structure
     });
   }
-  if (info.type === "wav-seeking-info") {
+  if (info.type === "wav-seeking-hints") {
     return getSeekingByteFromWav({
       info,
       time
     });
   }
-  if (info.type === "webm-seeking-info") {
+  if (info.type === "webm-seeking-hints") {
     return getSeekingByteFromMatroska({
       info,
       time,
       webmState,
       logLevel,
-      mediaSection,
-      keyframes
+      mediaSection
     });
   }
-  if (info.type === "transport-stream-seeking-info") {
+  if (info.type === "transport-stream-seeking-hints") {
     const lastKeyframeBeforeTimeInSeconds = getLastKeyFrameBeforeTimeInSeconds({
       observedPesHeaders: info.observedPesHeaders,
       timeInSeconds: time,
@@ -6256,8 +6328,22 @@ var getSeekingByte = ({
   throw new Error(`Unknown seeking info type: ${info}`);
 };
 
-// src/containers/iso-base-media/get-seeking-info-from-mp4.ts
-var getSeekingInfoFromMp4 = ({
+// src/state/iso-base-media/precomputed-tfra.ts
+var precomputedTfraState = () => {
+  let tfraBoxes = [];
+  return {
+    getTfraBoxes: () => tfraBoxes,
+    setTfraBoxes: (boxes) => {
+      tfraBoxes = boxes;
+    }
+  };
+};
+var deduplicateTfraBoxesByOffset = (tfraBoxes) => {
+  return tfraBoxes.filter((m, i, arr) => i === arr.findIndex((t) => t.offset === m.offset));
+};
+
+// src/containers/iso-base-media/seeking-hints.ts
+var getSeekingHintsFromMp4 = ({
   structureState,
   isoState,
   mp4HeaderSegment,
@@ -6267,37 +6353,65 @@ var getSeekingInfoFromMp4 = ({
   const moovAtom = getMoovBoxFromState({
     isoState,
     mp4HeaderSegment,
-    structureState
+    structureState,
+    mayUsePrecomputed: true
   });
-  const moofBoxes = getMoofBoxes(structure.boxes);
-  const tfraBoxes = getTfraBoxes(structure);
+  const moofBoxes = deduplicateMoofBoxesByOffset([
+    ...isoState.moof.getMoofBoxes(),
+    ...getMoofBoxes(structure.boxes)
+  ]);
+  const tfraBoxes = deduplicateTfraBoxesByOffset([
+    ...isoState.tfra.getTfraBoxes(),
+    ...getTfraBoxes(structure)
+  ]);
   if (!moovAtom) {
     return null;
   }
   return {
-    type: "iso-base-media-seeking-info",
+    type: "iso-base-media-seeking-hints",
     moovBox: moovAtom,
     moofBoxes,
     tfraBoxes,
-    mediaSections: mediaSectionState2.getMediaSections()
+    mediaSections: mediaSectionState2.getMediaSections(),
+    mfraAlreadyLoaded: isoState.mfra.getIfAlreadyLoaded()
   };
 };
+var setSeekingHintsForMp4 = ({
+  hints,
+  state
+}) => {
+  state.iso.moov.setMoovBox({
+    moovBox: hints.moovBox,
+    precomputed: true
+  });
+};
 
-// src/containers/transport-stream/get-seeking-info.ts
-var getSeekingInfoFromTransportStream = (transportStream, tracksState) => {
+// src/containers/transport-stream/seeking-hints.ts
+var getSeekingHintsFromTransportStream = (transportStream, tracksState) => {
   const firstVideoTrack = tracksState.getTracks().find((t) => t.type === "video");
   if (!firstVideoTrack) {
-    throw new Error("No video track found");
+    return null;
   }
   return {
-    type: "transport-stream-seeking-info",
+    type: "transport-stream-seeking-hints",
     observedPesHeaders: transportStream.observedPesHeaders.getPesKeyframeHeaders(),
-    ptsStartOffset: transportStream.startOffset.getOffset(firstVideoTrack.trackId)
+    ptsStartOffset: transportStream.startOffset.getOffset(firstVideoTrack.trackId),
+    firstVideoTrackId: firstVideoTrack.trackId
   };
 };
+var setSeekingHintsForTransportStream = ({
+  hints,
+  state
+}) => {
+  state.transportStream.observedPesHeaders.setPesKeyframesFromSeekingHints(hints);
+  state.transportStream.startOffset.setOffset({
+    trackId: hints.firstVideoTrackId,
+    newOffset: hints.ptsStartOffset
+  });
+};
 
-// src/containers/wav/get-seeking-info.ts
-var getSeekingInfoFromWav = ({
+// src/containers/wav/seeking-hints.ts
+var getSeekingHintsFromWav = ({
   structure,
   mediaSectionState: mediaSectionState2
 }) => {
@@ -6310,41 +6424,62 @@ var getSeekingInfoFromWav = ({
     return null;
   }
   return {
-    type: "wav-seeking-info",
+    type: "wav-seeking-hints",
     sampleRate: fmtBox.sampleRate,
     blockAlign: fmtBox.blockAlign,
-    mediaSections: mediaSection[0]
+    mediaSection: mediaSection[0]
   };
 };
+var setSeekingHintsForWav = ({
+  hints,
+  state
+}) => {
+  state.mediaSection.addMediaSection(hints.mediaSection);
+};
 
-// src/containers/webm/seek/get-seeking-info.ts
-var getSeekingInfoFromMatroska = (tracksState) => {
+// src/containers/webm/seek/seeking-hints.ts
+var getSeekingHintsFromMatroska = (tracksState, keyframesState, webmState) => {
   const tracks2 = tracksState.getTracks();
   const firstVideoTrack = tracks2.find((track) => track.type === "video");
+  const keyframes = keyframesState.getKeyframes();
+  const loadedCues = webmState.cues.getIfAlreadyLoaded();
   return {
-    type: "webm-seeking-info",
+    type: "webm-seeking-hints",
     track: firstVideoTrack ? {
       timescale: firstVideoTrack.timescale,
       trackId: firstVideoTrack.trackId
-    } : null
+    } : null,
+    keyframes,
+    loadedCues,
+    timestampMap: webmState.getTimeStampMapForSeekingHints()
   };
 };
+var setSeekingHintsForWebm = ({
+  hints,
+  state
+}) => {
+  state.webm.cues.setFromSeekingHints(hints);
+  state.keyframes.setFromSeekingHints(hints);
+  state.webm.setTimeStampMapForSeekingHints(hints.timestampMap);
+};
 
-// src/get-seeking-info.ts
-var getSeekingInfo = ({
+// src/get-seeking-hints.ts
+var getSeekingHints = ({
   structureState,
   mp4HeaderSegment,
   mediaSectionState: mediaSectionState2,
   isoState,
   transportStream,
-  tracksState
+  tracksState,
+  keyframesState,
+  webmState
 }) => {
   const structure = structureState.getStructureOrNull();
   if (!structure) {
     return null;
   }
   if (structure.type === "iso-base-media") {
-    return getSeekingInfoFromMp4({
+    return getSeekingHintsFromMp4({
       structureState,
       isoState,
       mp4HeaderSegment,
@@ -6352,16 +6487,16 @@ var getSeekingInfo = ({
     });
   }
   if (structure.type === "wav") {
-    return getSeekingInfoFromWav({
+    return getSeekingHintsFromWav({
       structure,
       mediaSectionState: mediaSectionState2
     });
   }
   if (structure.type === "matroska") {
-    return getSeekingInfoFromMatroska(tracksState);
+    return getSeekingHintsFromMatroska(tracksState, keyframesState, webmState);
   }
   if (structure.type === "transport-stream") {
-    return getSeekingInfoFromTransportStream(transportStream, tracksState);
+    return getSeekingHintsFromTransportStream(transportStream, tracksState);
   }
   throw new Error(`Seeking is not supported for this format: ${structure.type}`);
 };
@@ -6590,22 +6725,24 @@ var turnSeekIntoByte = async ({
     if (seek2.timeInSeconds < 0) {
       throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek2)}`);
     }
-    const seekingInfo = getSeekingInfo({
+    const seekingHints = getSeekingHints({
       structureState,
       mp4HeaderSegment,
       mediaSectionState: mediaSectionState2,
       isoState,
       transportStream,
-      tracksState
+      tracksState,
+      keyframesState: keyframes,
+      webmState
     });
-    if (!seekingInfo) {
+    if (!seekingHints) {
       Log.trace(logLevel, "No seeking info, cannot seek yet");
       return {
         type: "valid-but-must-wait"
       };
     }
     const seekingByte = await getSeekingByte({
-      info: seekingInfo,
+      info: seekingHints,
       time: seek2.timeInSeconds,
       logLevel,
       currentPosition: iterator.counter.getOffset(),
@@ -6613,7 +6750,8 @@ var turnSeekIntoByte = async ({
       transportStream,
       webmState,
       mediaSection: mediaSectionState2,
-      keyframes
+      mp4HeaderSegment,
+      structure: structureState
     });
     return seekingByte;
   }
@@ -6889,7 +7027,7 @@ var emitAvailableInfo = async ({
     }
     if (key === "tracks") {
       if (!emittedFields.tracks && hasInfo.tracks) {
-        const { videoTracks, audioTracks } = getTracks(state);
+        const { videoTracks, audioTracks } = getTracks(state, true);
         await callbackFunctions.onTracks?.({ videoTracks, audioTracks });
         if (fieldsInReturnValue.tracks) {
           returnValue.tracks = { videoTracks, audioTracks };
@@ -7131,7 +7269,7 @@ var getAvailableInfo = ({
       return Boolean(structure && hasAudioCodec(state));
     }
     if (key === "tracks") {
-      return Boolean(structure && getHasTracks(state));
+      return Boolean(structure && getHasTracks(state, true));
     }
     if (key === "keyframes") {
       return Boolean(structure && hasKeyframes(state));
@@ -7766,7 +7904,7 @@ var parseFlac = ({
 
 // src/state/iso-base-media/cached-sample-positions.ts
 var calculateFlatSamples = (state) => {
-  const tracks2 = getTracks(state);
+  const tracks2 = getTracks(state, true);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -7859,7 +7997,9 @@ var makeTracksSectionState = (canSkipTracksState, src) => {
     addTrack: (track) => {
       tracks2.push(track);
     },
-    getTracks: () => tracks2,
+    getTracks: () => {
+      return tracks2;
+    },
     ensureHasTracksAtEnd: (fields) => {
       if (canSkipTracksState.canSkipTracks()) {
         return;
@@ -9620,7 +9760,7 @@ var processBox = async ({
       iterator.discard(boxSize - 8);
       return null;
     }
-    if (isoState && isoState.moov.getMoovBox()) {
+    if (isoState && isoState.moov.getMoovBoxAndPrecomputed() && !isoState.moov.getMoovBoxAndPrecomputed()?.precomputed) {
       Log.verbose(logLevel, "Moov box already parsed, skipping");
       iterator.discard(boxSize - 8);
       return null;
@@ -9849,13 +9989,16 @@ var parseMdatSection = async (state) => {
   if (maySkipVideoData({ state })) {
     return makeSkip(endOfMdat);
   }
-  const alreadyHas = getHasTracks(state);
-  if (!alreadyHas) {
+  const alreadyHasMoov = getHasTracks(state, true);
+  if (!alreadyHasMoov) {
     const moov = await getMoovAtom({
       endOfMdat,
       state
     });
-    state.iso.moov.setMoovBox(moov);
+    state.iso.moov.setMoovBox({
+      moovBox: moov,
+      precomputed: false
+    });
     state.callbacks.tracks.setIsDone(state.logLevel);
     state.structure.getIsoStructure().boxes.push(moov);
     return parseMdatSection(state);
@@ -10258,8 +10401,8 @@ var parseM3uManifest = ({
   return Promise.resolve(null);
 };
 
-// src/forward-controller.ts
-var forwardMediaParserController = ({
+// src/forward-controller-pause-resume-abort.ts
+var forwardMediaParserControllerPauseResume = ({
   parentController,
   childController
 }) => {
@@ -10331,7 +10474,8 @@ var parseMedia = (options) => {
     onError: () => ({ action: "fail" }),
     acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
     apiName: "parseMedia()",
-    makeSamplesStartAtZero: options.makeSamplesStartAtZero ?? true
+    makeSamplesStartAtZero: options.makeSamplesStartAtZero ?? true,
+    seekingHints: options.seekingHints ?? null
   });
 };
 
@@ -10373,28 +10517,29 @@ var iteratorOverSegmentFiles = async ({
   const playlist = getPlaylist(structure, playlistUrl);
   const chunks = getChunks(playlist);
   let resolver = onInitialProgress;
-  let rejector = (_e) => {
-  };
-  const childController = mediaParserController();
-  const forwarded = forwardMediaParserController({
-    childController,
-    parentController
-  });
-  const makeContinuationFn = () => {
-    return {
-      continue() {
-        const { promise, reject, resolve } = withResolvers();
-        resolver = resolve;
-        rejector = reject;
-        childController.resume();
-        return promise;
-      },
-      abort() {
-        childController.abort();
-      }
-    };
-  };
+  let rejector = (_e) => {};
   for (const chunk of chunks) {
+    resolver = onInitialProgress;
+    rejector = (_e) => {};
+    const childController = mediaParserController();
+    const forwarded = forwardMediaParserControllerPauseResume({
+      childController,
+      parentController
+    });
+    const makeContinuationFn = () => {
+      return {
+        continue() {
+          const { promise, reject, resolve } = withResolvers();
+          resolver = resolve;
+          rejector = reject;
+          childController.resume();
+          return promise;
+        },
+        abort() {
+          childController.abort();
+        }
+      };
+    };
     const isLastChunk = chunk === chunks[chunks.length - 1];
     await childController._internals.checkForAbortAndPause();
     const src = readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);
@@ -11428,7 +11573,7 @@ var parseMediaSection = async (state) => {
   await parseMovi({
     state
   });
-  const tracks2 = getTracks(state);
+  const tracks2 = getTracks(state, false);
   if (!tracks2.videoTracks.some((t) => t.codec === TO_BE_OVERRIDDEN_LATER) && !state.callbacks.tracks.getIsDone()) {
     state.callbacks.tracks.setIsDone(state.logLevel);
   }
@@ -11799,7 +11944,10 @@ var handleAacPacket = async ({
   });
   if (!isTrackRegistered) {
     const startOffset = makeSamplesStartAtZero ? Math.min(streamBuffer.pesHeader.pts, streamBuffer.pesHeader.dts ?? Infinity) : 0;
-    transportStream.startOffset.setOffset(programId, startOffset);
+    transportStream.startOffset.setOffset({
+      trackId: programId,
+      newOffset: startOffset
+    });
     const track = {
       type: "audio",
       codecPrivate: codecPrivate2,
@@ -13312,6 +13460,30 @@ var warnIfRemotionLicenseNotAcknowledged = ({
   Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
 };
 
+// src/set-seeking-hints.ts
+var setSeekingHints = ({
+  hints,
+  state
+}) => {
+  if (hints.type === "iso-base-media-seeking-hints") {
+    setSeekingHintsForMp4({ hints, state });
+    return;
+  }
+  if (hints.type === "wav-seeking-hints") {
+    setSeekingHintsForWav({ hints, state });
+    return;
+  }
+  if (hints.type === "transport-stream-seeking-hints") {
+    setSeekingHintsForTransportStream({ hints, state });
+    return;
+  }
+  if (hints.type === "webm-seeking-hints") {
+    setSeekingHintsForWebm({ hints, state });
+    return;
+  }
+  throw new Error(`Unknown seeking hints type: ${hints}`);
+};
+
 // src/get-fields-from-callbacks.ts
 var getFieldsFromCallback = ({
   fields,
@@ -13542,6 +13714,7 @@ var lazyMfraLoad = ({
   logLevel
 }) => {
   let prom = null;
+  let result = null;
   const triggerLoad = () => {
     if (prom) {
       return prom;
@@ -13555,12 +13728,24 @@ var lazyMfraLoad = ({
       logLevel
     }).then((boxes) => {
       Log.verbose(logLevel, "Lazily found mfra atom.");
+      result = boxes;
       return boxes;
     });
     return prom;
   };
+  const getIfAlreadyLoaded = () => {
+    if (result) {
+      return result;
+    }
+    return null;
+  };
+  const setFromSeekingHints = (hints) => {
+    result = hints.mfraAlreadyLoaded;
+  };
   return {
-    triggerLoad
+    triggerLoad,
+    getIfAlreadyLoaded,
+    setFromSeekingHints
   };
 };
 
@@ -13571,7 +13756,7 @@ var moovState = () => {
     setMoovBox: (moov) => {
       moovBox = moov;
     },
-    getMoovBox: () => moovBox
+    getMoovBoxAndPrecomputed: () => moovBox
   };
 };
 
@@ -13592,23 +13777,33 @@ var isoBaseMediaState = ({
       readerInterface,
       src,
       logLevel
-    })
+    }),
+    moof: precomputedMoofState(),
+    tfra: precomputedTfraState()
   };
 };
 
 // src/state/keyframes.ts
 var keyframesState = () => {
   const keyframes = [];
-  return {
-    addKeyframe: (keyframe) => {
-      if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
-        return;
-      }
-      keyframes.push(keyframe);
-    },
-    getKeyframes: () => {
-      return keyframes;
+  const addKeyframe = (keyframe) => {
+    if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+      return;
     }
+    keyframes.push(keyframe);
+  };
+  const getKeyframes2 = () => {
+    return keyframes;
+  };
+  const setFromSeekingHints = (hints) => {
+    for (const keyframe of hints.keyframes) {
+      addKeyframe(keyframe);
+    }
+  };
+  return {
+    addKeyframe,
+    getKeyframes: getKeyframes2,
+    setFromSeekingHints
   };
 };
 
@@ -13885,6 +14080,7 @@ var lazyCuesFetch = ({
 }) => {
   let prom = null;
   let sOffset = null;
+  let result = null;
   const triggerLoad = (position, segmentOffset) => {
     if (prom) {
       return prom;
@@ -13902,6 +14098,7 @@ var lazyCuesFetch = ({
       src
     }).then((cues) => {
       Log.verbose(logLevel, "Cues loaded");
+      result = cues;
       return cues;
     });
     return prom;
@@ -13922,9 +14119,27 @@ var lazyCuesFetch = ({
       segmentOffset: sOffset
     };
   };
+  const getIfAlreadyLoaded = () => {
+    if (result) {
+      if (!sOffset) {
+        throw new Error("Segment offset not set");
+      }
+      return {
+        cues: result,
+        segmentOffset: sOffset
+      };
+    }
+    return null;
+  };
+  const setFromSeekingHints = (hints) => {
+    result = hints.loadedCues?.cues ?? null;
+    sOffset = hints.loadedCues?.segmentOffset ?? null;
+  };
   return {
     triggerLoad,
-    getLoadedCues
+    getLoadedCues,
+    getIfAlreadyLoaded,
+    setFromSeekingHints
   };
 };
 
@@ -13954,7 +14169,7 @@ var webmState = ({
       trackTimescale: trackTimescale?.value ?? null
     };
   };
-  const timestampMap = new Map;
+  let timestampMap = new Map;
   const getTimestampOffsetForByteOffset = (byteOffset) => {
     const entries = Array.from(timestampMap.entries());
     const sortedByByteOffset = entries.sort((a, b) => {
@@ -13996,12 +14211,20 @@ var webmState = ({
     readerInterface,
     src
   });
+  const getTimeStampMapForSeekingHints = () => {
+    return timestampMap;
+  };
+  const setTimeStampMapForSeekingHints = (newTimestampMap) => {
+    timestampMap = newTimestampMap;
+  };
   return {
     cues,
     onTrackEntrySegment,
     getTrackInfoByNumber: (id) => trackEntries[id],
     setTimestampOffset,
     getTimestampOffsetForByteOffset,
+    getTimeStampMapForSeekingHints,
+    setTimeStampMapForSeekingHints,
     getTimescale,
     setTimescale,
     addSegment: (seg) => {
@@ -14231,9 +14454,6 @@ var samplesObservedState = () => {
       const timeBetweenSamplesAudio = startingTimestampDifferenceAudio / (audioSamples.size - 1);
       audioDuration = timeBetweenSamplesAudio * audioSamples.size;
     }
-    if (videoDuration === null && audioDuration === null) {
-      throw new Error("No samples");
-    }
     return Math.max(videoDuration ?? 0, audioDuration ?? 0);
   };
   const addVideoSample = (videoSample) => {
@@ -14365,7 +14585,7 @@ var ptsStartOffsetStore = () => {
   const offsets = {};
   return {
     getOffset: (trackId) => offsets[trackId] || 0,
-    setOffset: (trackId, newOffset) => {
+    setOffset: ({ newOffset, trackId }) => {
       offsets[trackId] = newOffset;
     }
   };
@@ -14526,8 +14746,7 @@ var throttledStateUpdate = ({
     return {
       get: () => currentState,
       update: null,
-      stopAndGetLastProgress: () => {
-      }
+      stopAndGetLastProgress: () => {}
     };
   }
   let lastUpdated = null;
@@ -14538,8 +14757,7 @@ var throttledStateUpdate = ({
     updateFn(currentState);
     lastUpdated = currentState;
   };
-  let cleanup = () => {
-  };
+  let cleanup = () => {};
   if (everyMilliseconds > 0) {
     const interval = setInterval(() => {
       callUpdateIfChanged();
@@ -14590,6 +14808,7 @@ var internalParseMedia = async function({
   selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn,
   mp4HeaderSegment,
   makeSamplesStartAtZero,
+  seekingHints,
   ...more
 }) {
   controller._internals.markAsReadyToEmitEvents();
@@ -14638,6 +14857,19 @@ var internalParseMedia = async function({
     initialReaderInstance: readerInstance,
     makeSamplesStartAtZero
   });
+  if (seekingHints) {
+    setSeekingHints({ hints: seekingHints, state });
+  }
+  controller._internals.attachSeekingHintResolution(() => Promise.resolve(getSeekingHints({
+    tracksState: state.callbacks.tracks,
+    keyframesState: state.keyframes,
+    webmState: state.webm,
+    structureState: state.structure,
+    mp4HeaderSegment: state.mp4HeaderSegment,
+    mediaSectionState: state.mediaSection,
+    isoState: state.iso,
+    transportStream: state.transportStream
+  })));
   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."));
   }
@@ -14665,7 +14897,7 @@ var internalParseMedia = async function({
   return state.returnValue;
 };
 
-// src/worker/forward-controller.ts
+// src/worker/forward-controller-to-worker.ts
 var forwardMediaParserControllerToWorker = (controller) => {
   return (message) => {
     if (message.type === "request-pause") {
@@ -14676,6 +14908,20 @@ var forwardMediaParserControllerToWorker = (controller) => {
       controller._experimentalSeek(message.payload);
       return;
     }
+    if (message.type === "request-get-seeking-hints") {
+      controller.getSeekingHints().then((hints) => {
+        postMessage({
+          type: "response-get-seeking-hints",
+          payload: hints
+        });
+      }).catch((error) => {
+        postMessage({
+          type: "response-error",
+          payload: error
+        });
+      });
+      return;
+    }
     if (message.type === "request-resume") {
       controller.resume();
       return;
@@ -14691,7 +14937,11 @@ var forwardMediaParserControllerToWorker = (controller) => {
 };
 
 // src/worker/serialize-error.ts
-var serializeError = (error, logLevel) => {
+var serializeError = ({
+  error,
+  logLevel,
+  seekingHints
+}) => {
   if (error instanceof IsAGifError) {
     return {
       type: "response-error",
@@ -14732,7 +14982,8 @@ var serializeError = (error, logLevel) => {
       type: "response-error",
       errorName: "MediaParserAbortError",
       errorMessage: error.message,
-      errorStack: error.stack ?? ""
+      errorStack: error.stack ?? "",
+      seekingHints
     };
   }
   if (error.name !== "Error") {
@@ -14784,7 +15035,9 @@ var startParsing = async (message, reader) => {
     acknowledgeRemotionLicense,
     logLevel: userLogLevel,
     progressIntervalInMs,
-    mp4HeaderSegment
+    mp4HeaderSegment,
+    seekingHints,
+    makeSamplesStartAtZero
   } = payload;
   const {
     postAudioCodec,
@@ -15068,14 +15321,24 @@ var startParsing = async (message, reader) => {
         };
       } : null,
       onDiscardedData: null,
-      makeSamplesStartAtZero: true
+      makeSamplesStartAtZero: makeSamplesStartAtZero ?? true,
+      seekingHints: seekingHints ?? null
     });
     post({
       type: "response-done",
-      payload: ret
+      payload: ret,
+      seekingHints: await controller.getSeekingHints()
     });
   } catch (e) {
-    post(serializeError(e, logLevel));
+    let seekingHintsRes = null;
+    try {
+      seekingHintsRes = await controller.getSeekingHints();
+    } catch {}
+    post(serializeError({
+      error: e,
+      logLevel,
+      seekingHints: seekingHintsRes
+    }));
   }
 };
 var onMessageForWorker = forwardMediaParserControllerToWorker(controller);