@remotion/media-parser 4.0.248 → 4.0.249

package/dist/esm/index.mjs

@@ -996,9 +996,10 @@ var isTransportStream = (data) => {
 };
 var isMp3 = (data) => {
   const mpegPattern = new Uint8Array([255, 243, 228, 100]);
-  const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+  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(id3Pattern)(subarray);
+  return matchesPattern(mpegPattern)(subarray) || matchesPattern(id3v3Pattern)(subarray) || matchesPattern(id3v2Pattern)(subarray);
 };
 var isGif = (data) => {
   const gifPattern = new Uint8Array([71, 73, 70, 56]);
@@ -1241,6 +1242,14 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   let view = new DataView(data.buffer);
   const counter = makeOffsetCounter();
   let discardAllowed = true;
+  const startCheckpoint = () => {
+    const checkpoint = counter.getOffset();
+    return {
+      returnToCheckpoint: () => {
+        counter.decrement(counter.getOffset() - checkpoint);
+      }
+    };
+  };
   const getSlice = (amount) => {
     const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
     counter.increment(amount);
@@ -1633,6 +1642,18 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       }
       return new TextDecoder().decode(bytes).trim();
     },
+    planBytes: (size) => {
+      const currentOffset = counter.getOffset();
+      return {
+        discardRest: () => {
+          const toDiscard = size - (counter.getOffset() - currentOffset);
+          if (toDiscard < 0) {
+            throw new Error("read too many bytes");
+          }
+          return getSlice(toDiscard);
+        }
+      };
+    },
     getFloat64: () => {
       const val = view.getFloat64(counter.getDiscardedOffset());
       counter.increment(8);
@@ -1651,7 +1672,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     disallowDiscard,
     allowDiscard,
     startBox,
-    readExpGolomb
+    readExpGolomb,
+    startCheckpoint
   };
 };
 
@@ -1720,6 +1742,22 @@ var parseMvhd = ({
   };
 };
 
+// src/convert-audio-or-video-sample.ts
+var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
+  const { cts, dts, timestamp } = sample;
+  return {
+    cts: cts * 1e6 / timescale,
+    dts: dts * 1e6 / timescale,
+    timestamp: timestamp * 1e6 / timescale,
+    duration: sample.duration === undefined ? undefined : sample.duration * 1e6 / timescale,
+    data: sample.data,
+    trackId: sample.trackId,
+    type: sample.type,
+    offset: sample.offset,
+    timescale: 1e6
+  };
+};
+
 // src/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -2010,6 +2048,9 @@ var getFps = (segments) => {
   if (segments.type === "transport-stream") {
     return null;
   }
+  if (segments.type === "mp3") {
+    return null;
+  }
   throw new Error("Cannot get fps, not implemented");
 };
 var hasFpsSuitedForSlowFps = (boxes) => {
@@ -2046,7 +2087,7 @@ var getAudioCodec = (boxes, parserState) => {
   return null;
 };
 var hasAudioCodec = (boxes, state) => {
-  return hasTracks(boxes, state);
+  return getHasTracks(boxes, state);
 };
 var getCodecSpecificatorFromEsdsBox = ({
   child
@@ -2429,7 +2470,7 @@ var getVideoCodec = (boxes, state) => {
   return track.videoTracks[0]?.codecWithoutConfig ?? null;
 };
 var hasVideoCodec = (boxes, state) => {
-  return hasTracks(boxes, state);
+  return getHasTracks(boxes, state);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -2652,6 +2693,19 @@ var makeBaseMediaTrack = (trakBox) => {
   return track;
 };
 
+// src/boxes/mp3/get-tracks-from-mp3.ts
+var getTracksFromMp3 = (parserState) => {
+  const tracks2 = parserState.callbacks.tracks.getTracks();
+  if (tracks2.length === 0) {
+    throw new Error("No tracks found");
+  }
+  return {
+    audioTracks: tracks2.filter((t) => t.type === "audio"),
+    otherTracks: [],
+    videoTracks: []
+  };
+};
+
 // src/boxes/avc/codec-string.ts
 var getCodecStringFromSpsAndPps = (sps) => {
   return `avc1.${sps.spsData.profile.toString(16).padStart(2, "0")}${sps.spsData.compatibility.toString(16).padStart(2, "0")}${sps.spsData.level.toString(16).padStart(2, "0")}`;
@@ -3492,7 +3546,7 @@ var isoBaseMediaHasTracks = (structure) => {
   const tracks2 = getTraks(moovBox);
   return tracks2.length === numberOfTracks;
 };
-var hasTracks = (structure, state) => {
+var getHasTracks = (structure, state) => {
   if (structure.type === "matroska") {
     const mainSegment = getMainSegment(structure.boxes);
     if (!mainSegment) {
@@ -3509,6 +3563,9 @@ var hasTracks = (structure, state) => {
   if (structure.type === "transport-stream") {
     return hasAllTracksFromTransportStream(structure, state);
   }
+  if (structure.type === "mp3") {
+    return state.callbacks.tracks.getTracks().length > 0;
+  }
   throw new Error("Unknown container " + structure);
 };
 var getTracksFromMa = (segments, state) => {
@@ -3580,56 +3637,10 @@ var getTracks = (segments, state) => {
   if (segments.type === "transport-stream") {
     return getTracksFromTransportStream(segments, state);
   }
-  throw new Error(`Unknown container${segments}`);
-};
-
-// src/get-container.ts
-var getContainer = (segments) => {
-  if (segments.type === "iso-base-media") {
-    return "mp4";
-  }
-  if (segments.type === "matroska") {
-    return "webm";
-  }
-  if (segments.type === "transport-stream") {
-    return "transport-stream";
-  }
-  if (segments.type === "riff") {
-    if (isRiffAvi2(segments)) {
-      return "avi";
-    }
-  }
-  throw new Error("Unknown container");
-};
-var hasContainer = (boxes) => {
-  try {
-    return getContainer(boxes) !== null;
-  } catch {
-    return false;
-  }
-};
-
-// src/get-dimensions.ts
-var getDimensions = (boxes, state) => {
-  const { videoTracks } = getTracks(boxes, state);
-  if (!videoTracks.length) {
-    throw new Error("Expected video track");
-  }
-  const firstVideoTrack = videoTracks[0];
-  return {
-    width: firstVideoTrack.width,
-    height: firstVideoTrack.height,
-    rotation: firstVideoTrack.rotation,
-    unrotatedHeight: firstVideoTrack.displayAspectHeight,
-    unrotatedWidth: firstVideoTrack.displayAspectWidth
-  };
-};
-var hasDimensions = (boxes, state) => {
-  try {
-    return getDimensions(boxes, state) !== null;
-  } catch {
-    return false;
+  if (segments.type === "mp3") {
+    return getTracksFromMp3(state);
   }
+  throw new Error(`Unknown container${segments}`);
 };
 
 // src/get-sample-positions.ts
@@ -3842,153 +3853,476 @@ var getSamplePositionsFromTrack = (trakBox, moofBox) => {
   return samplePositions;
 };
 
-// src/get-duration.ts
-var getDurationFromMatroska = (segments) => {
-  const mainSegment = segments.find((s) => s.type === "Segment");
-  if (!mainSegment || mainSegment.type !== "Segment") {
-    return null;
-  }
-  const { value: children } = mainSegment;
-  if (!children) {
-    return null;
-  }
-  const infoSegment = children.find((s) => s.type === "Info");
-  const relevantBoxes = [
-    ...mainSegment.value,
-    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
-  ];
-  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
-  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
-    return null;
-  }
-  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
-  if (!duration2 || duration2.type !== "Duration") {
-    return null;
-  }
-  return duration2.value.value / timestampScale2.value.value * 1000;
-};
-var getDurationFromIsoBaseMedia = (structure, parserState) => {
-  const moovBox = getMoovBox(structure.boxes);
-  if (!moovBox) {
-    return null;
-  }
-  const moofBox = getMoofBox(structure.boxes);
-  const mvhdBox = getMvhdBox(moovBox);
-  if (!mvhdBox) {
-    return null;
-  }
-  if (mvhdBox.type !== "mvhd-box") {
-    throw new Error("Expected mvhd-box");
-  }
-  if (mvhdBox.durationInSeconds > 0) {
-    return mvhdBox.durationInSeconds;
+// src/boxes/iso-base-media/mdat/mdat.ts
+var parseMdat = async ({
+  data,
+  size,
+  fileOffset,
+  existingBoxes,
+  state,
+  signal,
+  maySkipSampleProcessing
+}) => {
+  const alreadyHas = getHasTracks({
+    type: "iso-base-media",
+    boxes: existingBoxes
+  }, state);
+  if (!alreadyHas) {
+    if (maySkipSampleProcessing) {
+      data.discard(size - (data.counter.getOffset() - fileOffset));
+      return Promise.resolve({
+        type: "mdat-box",
+        boxSize: size,
+        status: "samples-skipped",
+        fileOffset
+      });
+    }
+    data.discard(size - (data.counter.getOffset() - fileOffset));
+    data.disallowDiscard();
+    return Promise.resolve({
+      type: "mdat-box",
+      boxSize: size,
+      status: "samples-buffered",
+      fileOffset
+    });
   }
-  const tracks2 = getTracks(structure, parserState);
+  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, state);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
     ...tracks2.otherTracks
   ];
-  const allSamples = allTracks.map((t) => {
-    const { timescale: ts } = t;
-    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
-    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
-    return highest ?? 0;
-  });
-  const highestTimestamp = Math.max(...allSamples);
-  return highestTimestamp;
-};
-var getDurationFromAvi = (structure) => {
-  const strl = getStrlBoxes(structure);
-  const lengths = [];
-  for (const s of strl) {
-    const strh = getStrhBox(s.children);
-    if (!strh) {
-      throw new Error("No strh box");
+  const flatSamples = allTracks.map((track) => {
+    const samplePositions = getSamplePositionsFromTrack(track.trakBox, getMoofBox(existingBoxes));
+    if (!samplePositions) {
+      throw new Error("No sample positions");
     }
-    const samplesPerSecond = strh.rate / strh.scale;
-    const streamLength = strh.length / samplesPerSecond;
-    lengths.push(streamLength);
-  }
-  return Math.max(...lengths);
-};
-var getDuration = (structure, parserState) => {
-  if (structure.type === "matroska") {
-    return getDurationFromMatroska(structure.boxes);
-  }
-  if (structure.type === "iso-base-media") {
-    return getDurationFromIsoBaseMedia(structure, parserState);
-  }
-  if (structure.type === "riff") {
-    return getDurationFromAvi(structure);
-  }
-  if (structure.type === "transport-stream") {
-    return null;
-  }
-  throw new Error("Has no duration " + structure);
-};
-var hasDuration = (structure, parserState) => {
-  return hasTracks(structure, parserState);
-};
-var hasSlowDuration = (structure, parserState) => {
-  try {
-    return getDuration(structure, parserState) !== null;
-  } catch {
-    return false;
-  }
-};
-
-// src/get-is-hdr.ts
-var isVideoTrackHdr = (track) => {
-  return track.color.matrixCoefficients === "bt2020" && track.color.transferCharacteristics === "arib-std-b67" && track.color.primaries === "bt2020";
-};
-var getIsHdr = (boxes, state) => {
-  const { videoTracks } = getTracks(boxes, state);
-  return videoTracks.some((track) => isVideoTrackHdr(track));
-};
-var hasHdr = (boxes, state) => {
-  return hasTracks(boxes, state);
-};
-
-// src/boxes/iso-base-media/get-keyframes.ts
-var getKeyframesFromIsoBaseMedia = (structure) => {
-  const { videoTracks } = getTracksFromIsoBaseMedia(structure.boxes);
-  const moofBox = getMoofBox(structure.boxes);
-  const allSamples = videoTracks.map((t) => {
-    const { timescale: ts } = t;
-    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
-    const keyframes = samplePositions.filter((k) => {
-      return k.isKeyframe;
-    }).map((k) => {
+    return samplePositions.map((samplePosition) => {
       return {
-        trackId: t.trackId,
-        presentationTimeInSeconds: k.cts / ts,
-        decodingTimeInSeconds: k.dts / ts,
-        positionInBytes: k.offset,
-        sizeInBytes: k.size
+        track: { ...track },
+        samplePosition
       };
     });
-    return keyframes;
-  });
-  return allSamples.flat();
-};
-
-// src/get-keyframes.ts
-var getKeyframes = (structure) => {
-  if (structure.type === "iso-base-media") {
-    return getKeyframesFromIsoBaseMedia(structure);
-  }
-  return null;
-};
-var hasKeyframes = (structure, parserState) => {
-  if (structure.type === "iso-base-media") {
-    return hasTracks(structure, parserState);
-  }
-  return true;
-};
-
-// src/may-skip-video-data/need-samples-for-fields.ts
-var needsSamples = {
+  }).flat(1);
+  while (true) {
+    if (signal && signal.aborted) {
+      break;
+    }
+    const samplesWithIndex = flatSamples.find((sample) => {
+      return sample.samplePosition.offset === data.counter.getOffset();
+    });
+    if (!samplesWithIndex) {
+      const nextSample_ = flatSamples.filter((s) => s.samplePosition.offset > data.counter.getOffset()).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+      if (nextSample_) {
+        data.discard(nextSample_.samplePosition.offset - data.counter.getOffset());
+        continue;
+      } else {
+        const bytesRemaining = size + fileOffset - data.counter.getOffset();
+        data.discard(bytesRemaining);
+        break;
+      }
+    }
+    if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
+      break;
+    }
+    const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
+    const { cts, dts, duration: duration2, isKeyframe, offset } = samplesWithIndex.samplePosition;
+    if (samplesWithIndex.track.type === "audio") {
+      await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe ? "key" : "delta",
+        offset,
+        timescale: samplesWithIndex.track.timescale
+      }, samplesWithIndex.track.timescale));
+    }
+    if (samplesWithIndex.track.type === "video") {
+      const nalUnitType = bytes[4] & 31;
+      let isRecoveryPoint = false;
+      if (nalUnitType === 6) {
+        const seiType = bytes[5];
+        isRecoveryPoint = seiType === 6;
+      }
+      await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+        data: bytes,
+        timestamp: cts,
+        duration: duration2,
+        cts,
+        dts,
+        trackId: samplesWithIndex.track.trackId,
+        type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
+        offset,
+        timescale: samplesWithIndex.track.timescale
+      }, samplesWithIndex.track.timescale));
+    }
+    const remaining = size - (data.counter.getOffset() - fileOffset);
+    data.removeBytesRead();
+    if (remaining === 0) {
+      break;
+    }
+  }
+  const expectedOffsetNow = size + fileOffset;
+  const actualOffsetNow = data.counter.getOffset();
+  if (expectedOffsetNow !== actualOffsetNow) {
+    return Promise.resolve({
+      type: "partial-mdat-box",
+      boxSize: size,
+      fileOffset
+    });
+  }
+  return Promise.resolve({
+    type: "mdat-box",
+    boxSize: size,
+    status: "samples-processed",
+    fileOffset
+  });
+};
+
+// src/boxes/iso-base-media/parse-mdat-partially.ts
+var parseMdatPartially = async ({
+  iterator,
+  boxSize,
+  fileOffset,
+  parsedBoxes,
+  state,
+  signal
+}) => {
+  const box = await parseMdat({
+    data: iterator,
+    size: boxSize,
+    fileOffset,
+    existingBoxes: parsedBoxes,
+    state,
+    signal,
+    maySkipSampleProcessing: state.supportsContentRange
+  });
+  if (box.type === "partial-mdat-box") {
+    return box;
+  }
+  if ((box.status === "samples-processed" || box.status === "samples-buffered") && box.fileOffset + boxSize === iterator.counter.getOffset()) {
+    return {
+      type: "complete",
+      box,
+      size: boxSize,
+      skipTo: null
+    };
+  }
+  return {
+    type: "partial-mdat-box",
+    boxSize,
+    fileOffset
+  };
+};
+
+// src/get-container.ts
+var getContainer = (segments) => {
+  if (segments.type === "iso-base-media") {
+    return "mp4";
+  }
+  if (segments.type === "matroska") {
+    return "webm";
+  }
+  if (segments.type === "transport-stream") {
+    return "transport-stream";
+  }
+  if (segments.type === "mp3") {
+    return "mp3";
+  }
+  if (segments.type === "riff") {
+    if (isRiffAvi2(segments)) {
+      return "avi";
+    }
+    throw new Error("Unknown RIFF container " + segments.type);
+  }
+  throw new Error("Unknown container " + segments);
+};
+var hasContainer = (boxes) => {
+  try {
+    return getContainer(boxes) !== null;
+  } catch {
+    return false;
+  }
+};
+
+// src/get-dimensions.ts
+var getDimensions = (boxes, state) => {
+  const { videoTracks } = getTracks(boxes, state);
+  if (!videoTracks.length) {
+    if (boxes.type === "mp3") {
+      return null;
+    }
+    throw new Error("Expected video track");
+  }
+  const firstVideoTrack = videoTracks[0];
+  return {
+    width: firstVideoTrack.width,
+    height: firstVideoTrack.height,
+    rotation: firstVideoTrack.rotation,
+    unrotatedHeight: firstVideoTrack.displayAspectHeight,
+    unrotatedWidth: firstVideoTrack.displayAspectWidth
+  };
+};
+var hasDimensions = (boxes, state) => {
+  try {
+    return getDimensions(boxes, state) !== null;
+  } catch {
+    return false;
+  }
+};
+
+// src/boxes/mp3/get-frame-length.ts
+var getUnroundedMpegFrameLength = ({
+  samplesPerFrame,
+  bitrateKbit,
+  samplingFrequency: samplingFrequency2,
+  padding,
+  layer
+}) => {
+  if (layer === 1) {
+    throw new Error("MPEG Layer I is not supported");
+  }
+  return samplesPerFrame / 8 * bitrateKbit / samplingFrequency2 * 1000 + (padding ? layer === 1 ? 4 : 1 : 0);
+};
+var getAverageMpegFrameLength = ({
+  samplesPerFrame,
+  bitrateKbit,
+  samplingFrequency: samplingFrequency2,
+  layer
+}) => {
+  const withoutPadding = getUnroundedMpegFrameLength({
+    bitrateKbit,
+    layer,
+    padding: false,
+    samplesPerFrame,
+    samplingFrequency: samplingFrequency2
+  });
+  const rounded = Math.floor(withoutPadding);
+  const rest = withoutPadding % 1;
+  return rest * (rounded + 1) + (1 - rest) * rounded;
+};
+var getMpegFrameLength = ({
+  samplesPerFrame,
+  bitrateKbit,
+  samplingFrequency: samplingFrequency2,
+  padding,
+  layer
+}) => {
+  return Math.floor(getUnroundedMpegFrameLength({
+    bitrateKbit,
+    layer,
+    padding,
+    samplesPerFrame,
+    samplingFrequency: samplingFrequency2
+  }));
+};
+
+// src/boxes/mp3/samples-per-mpeg-file.ts
+var getSamplesPerMpegFrame = ({
+  mpegVersion,
+  layer
+}) => {
+  if (mpegVersion === 1) {
+    if (layer === 1) {
+      return 384;
+    }
+    if (layer === 2 || layer === 3) {
+      return 1152;
+    }
+  }
+  if (mpegVersion === 2) {
+    if (layer === 1) {
+      return 384;
+    }
+    if (layer === 2) {
+      return 1152;
+    }
+    if (layer === 3) {
+      return 576;
+    }
+  }
+  throw new Error("Invalid MPEG layer");
+};
+
+// src/boxes/mp3/get-duration.ts
+var getDurationFromMp3 = (state) => {
+  if (state.contentLength === null) {
+    return null;
+  }
+  const mp3Info = state.mp3Info.getMp3Info();
+  if (!mp3Info) {
+    throw new Error("No mp3 info");
+  }
+  const samplesPerFrame = getSamplesPerMpegFrame({
+    layer: mp3Info.layer,
+    mpegVersion: mp3Info.mpegVersion
+  });
+  const frameLengthInBytes = getMpegFrameLength({
+    bitrateKbit: mp3Info.bitrateKbit,
+    padding: false,
+    samplesPerFrame,
+    samplingFrequency: mp3Info.sampleRate,
+    layer: mp3Info.layer
+  });
+  const frames = Math.floor((state.contentLength - mp3Info.startOfMpegStream) / frameLengthInBytes);
+  const samples = frames * samplesPerFrame;
+  const durationInSeconds = samples / mp3Info.sampleRate;
+  return durationInSeconds;
+};
+
+// src/get-duration.ts
+var getDurationFromMatroska = (segments) => {
+  const mainSegment = segments.find((s) => s.type === "Segment");
+  if (!mainSegment || mainSegment.type !== "Segment") {
+    return null;
+  }
+  const { value: children } = mainSegment;
+  if (!children) {
+    return null;
+  }
+  const infoSegment = children.find((s) => s.type === "Info");
+  const relevantBoxes = [
+    ...mainSegment.value,
+    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
+  ];
+  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
+  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
+    return null;
+  }
+  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
+  if (!duration2 || duration2.type !== "Duration") {
+    return null;
+  }
+  return duration2.value.value / timestampScale2.value.value * 1000;
+};
+var getDurationFromIsoBaseMedia = (structure, parserState) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
+    return null;
+  }
+  const moofBox = getMoofBox(structure.boxes);
+  const mvhdBox = getMvhdBox(moovBox);
+  if (!mvhdBox) {
+    return null;
+  }
+  if (mvhdBox.type !== "mvhd-box") {
+    throw new Error("Expected mvhd-box");
+  }
+  if (mvhdBox.durationInSeconds > 0) {
+    return mvhdBox.durationInSeconds;
+  }
+  const tracks2 = getTracks(structure, parserState);
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  const allSamples = allTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+    return highest ?? 0;
+  });
+  const highestTimestamp = Math.max(...allSamples);
+  return highestTimestamp;
+};
+var getDurationFromAvi = (structure) => {
+  const strl = getStrlBoxes(structure);
+  const lengths = [];
+  for (const s of strl) {
+    const strh = getStrhBox(s.children);
+    if (!strh) {
+      throw new Error("No strh box");
+    }
+    const samplesPerSecond = strh.rate / strh.scale;
+    const streamLength = strh.length / samplesPerSecond;
+    lengths.push(streamLength);
+  }
+  return Math.max(...lengths);
+};
+var getDuration = (structure, parserState) => {
+  if (structure.type === "matroska") {
+    return getDurationFromMatroska(structure.boxes);
+  }
+  if (structure.type === "iso-base-media") {
+    return getDurationFromIsoBaseMedia(structure, parserState);
+  }
+  if (structure.type === "riff") {
+    return getDurationFromAvi(structure);
+  }
+  if (structure.type === "transport-stream") {
+    return null;
+  }
+  if (structure.type === "mp3") {
+    return getDurationFromMp3(parserState);
+  }
+  throw new Error("Has no duration " + structure);
+};
+var hasDuration = (structure, parserState) => {
+  return getHasTracks(structure, parserState);
+};
+var hasSlowDuration = (structure, parserState) => {
+  try {
+    return getDuration(structure, parserState) !== null;
+  } catch {
+    return false;
+  }
+};
+
+// src/get-is-hdr.ts
+var isVideoTrackHdr = (track) => {
+  return track.color.matrixCoefficients === "bt2020" && track.color.transferCharacteristics === "arib-std-b67" && track.color.primaries === "bt2020";
+};
+var getIsHdr = (boxes, state) => {
+  const { videoTracks } = getTracks(boxes, state);
+  return videoTracks.some((track) => isVideoTrackHdr(track));
+};
+var hasHdr = (boxes, state) => {
+  return getHasTracks(boxes, state);
+};
+
+// src/boxes/iso-base-media/get-keyframes.ts
+var getKeyframesFromIsoBaseMedia = (structure) => {
+  const { videoTracks } = getTracksFromIsoBaseMedia(structure.boxes);
+  const moofBox = getMoofBox(structure.boxes);
+  const allSamples = videoTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const keyframes = samplePositions.filter((k) => {
+      return k.isKeyframe;
+    }).map((k) => {
+      return {
+        trackId: t.trackId,
+        presentationTimeInSeconds: k.cts / ts,
+        decodingTimeInSeconds: k.dts / ts,
+        positionInBytes: k.offset,
+        sizeInBytes: k.size
+      };
+    });
+    return keyframes;
+  });
+  return allSamples.flat();
+};
+
+// src/get-keyframes.ts
+var getKeyframes = (structure) => {
+  if (structure.type === "iso-base-media") {
+    return getKeyframesFromIsoBaseMedia(structure);
+  }
+  return null;
+};
+var hasKeyframes = (structure, parserState) => {
+  if (structure.type === "iso-base-media") {
+    return getHasTracks(structure, parserState);
+  }
+  return true;
+};
+
+// src/may-skip-video-data/need-samples-for-fields.ts
+var needsSamples = {
   slowDurationInSeconds: true,
   slowFps: true,
   slowKeyframes: true,
@@ -4010,7 +4344,8 @@ var needsSamples = {
   metadata: false,
   location: false,
   mimeType: false,
-  keyframes: false
+  keyframes: false,
+  images: false
 };
 var needsToIterateOverSamples = ({
   fields,
@@ -4029,6 +4364,216 @@ var maySkipVideoData = ({ state }) => {
   });
 };
 
+// src/boxes/mp3/get-metadata-from-mp3.ts
+var getMetadataFromMp3 = (mp3Structure) => {
+  const findHeader = mp3Structure.boxes.find((b) => b.type === "id3-header");
+  return findHeader ? findHeader.metatags : null;
+};
+
+// src/metadata/metadata-from-iso.ts
+var mapToKey = (index) => {
+  if (index === 2839630420) {
+    return "artist";
+  }
+  if (index === 2841734242) {
+    return "album";
+  }
+  if (index === 2841865588) {
+    return "comment";
+  }
+  if (index === 2841928057) {
+    return "releaseDate";
+  }
+  if (index === 2842125678) {
+    return "genre";
+  }
+  if (index === 2842583405) {
+    return "title";
+  }
+  if (index === 2842980207) {
+    return "encoder";
+  }
+  if (index === 2843177588) {
+    return "writer";
+  }
+  if (index === 2841866361) {
+    return "copyright";
+  }
+  if (index === 2841930098) {
+    return "director";
+  }
+  if (index === 2842718820) {
+    return "producer";
+  }
+  if (index === 2841929075) {
+    return "description";
+  }
+  return null;
+};
+var parseIlstBoxWithoutKeys = (ilstBox) => {
+  return ilstBox.entries.map((entry) => {
+    const key = mapToKey(entry.index);
+    if (!key) {
+      return null;
+    }
+    if (entry.value.type === "unknown") {
+      return null;
+    }
+    return {
+      trackId: null,
+      key,
+      value: entry.value.value
+    };
+  }).filter(truthy);
+};
+var parseIsoMetaBox = (meta, trackId) => {
+  const ilstBox = meta.children.find((b) => b.type === "ilst-box");
+  const keysBox = meta.children.find((b) => b.type === "keys-box");
+  if (!ilstBox || !keysBox) {
+    if (ilstBox) {
+      return parseIlstBoxWithoutKeys(ilstBox);
+    }
+    return [];
+  }
+  const entries = [];
+  for (let i = 0;i < ilstBox.entries.length; i++) {
+    const ilstEntry = ilstBox.entries[i];
+    const keysEntry = keysBox.entries[i];
+    if (ilstEntry.value.type !== "unknown") {
+      const value = typeof ilstEntry.value.value === "string" && ilstEntry.value.value.endsWith("\x00") ? ilstEntry.value.value.slice(0, -1) : ilstEntry.value.value;
+      entries.push({
+        key: keysEntry.value,
+        value,
+        trackId
+      });
+    }
+  }
+  return entries;
+};
+var getMetadataFromIsoBase = (isoBase) => {
+  const moov = getMoovBox(isoBase.boxes);
+  if (!moov) {
+    return [];
+  }
+  const traks = getTraks(moov);
+  const meta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "meta");
+  const udta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "udta");
+  const metaInUdta = udta?.children.find((b) => {
+    return b.type === "regular-box" && b.boxType === "meta";
+  });
+  const metaInTracks = traks.map((t) => {
+    const metaBox = t.children.find((child) => child.type === "regular-box" && child.boxType === "meta");
+    if (metaBox) {
+      const tkhd = getTkhdBox(t);
+      if (!tkhd) {
+        throw new Error("No tkhd box found");
+      }
+      return parseIsoMetaBox(metaBox, tkhd.trackId);
+    }
+    return null;
+  }).filter(truthy);
+  return [
+    ...meta ? parseIsoMetaBox(meta, null) : [],
+    ...metaInUdta ? parseIsoMetaBox(metaInUdta, null) : [],
+    ...metaInTracks.flat(1)
+  ];
+};
+
+// src/metadata/metadata-from-matroska.ts
+var removeEndZeroes = (value) => {
+  return value.endsWith("\x00") ? removeEndZeroes(value.slice(0, -1)) : value;
+};
+var parseSimpleTagIntoEbml = (children, trackId) => {
+  const tagName = children.find((c) => c.type === "TagName");
+  const tagString = children.find((c) => c.type === "TagString");
+  if (!tagName || !tagString) {
+    return null;
+  }
+  return {
+    trackId,
+    key: tagName.value.toLowerCase(),
+    value: removeEndZeroes(tagString.value)
+  };
+};
+var getMetadataFromMatroska = (structure) => {
+  const entries = [];
+  for (const segment of structure.boxes) {
+    if (segment.type !== "Segment") {
+      continue;
+    }
+    const tags2 = segment.value.filter((s) => s.type === "Tags");
+    for (const tag of tags2) {
+      for (const child of tag.value) {
+        if (child.type !== "Tag") {
+          continue;
+        }
+        let trackId = null;
+        const target = child.value.find((c) => c.type === "Targets");
+        if (target) {
+          const tagTrackId = target.value.find((c) => c.type === "TagTrackUID")?.value;
+          if (tagTrackId) {
+            trackId = getTrackWithUid(segment, tagTrackId);
+          }
+        }
+        const simpleTags = child.value.filter((s) => s.type === "SimpleTag");
+        for (const simpleTag of simpleTags) {
+          const parsed = parseSimpleTagIntoEbml(simpleTag.value, trackId);
+          if (parsed) {
+            entries.push(parsed);
+          }
+        }
+      }
+    }
+  }
+  return entries;
+};
+
+// src/metadata/metadata-from-riff.ts
+var getMetadataFromRiff = (structure) => {
+  const boxes = structure.boxes.find((b) => b.type === "list-box" && b.listType === "INFO");
+  if (!boxes) {
+    return [];
+  }
+  const { children } = boxes;
+  return children.map((child) => {
+    if (child.type !== "isft-box") {
+      return null;
+    }
+    return {
+      trackId: null,
+      key: "encoder",
+      value: child.software
+    };
+  }).filter(truthy);
+};
+
+// src/metadata/get-metadata.ts
+var getMetadata = (structure) => {
+  if (structure.type === "matroska") {
+    return getMetadataFromMatroska(structure);
+  }
+  if (structure.type === "riff") {
+    return getMetadataFromRiff(structure);
+  }
+  if (structure.type === "transport-stream") {
+    return [];
+  }
+  if (structure.type === "mp3") {
+    const tags2 = getMetadataFromMp3(structure);
+    if (tags2 === null) {
+      throw new Error("Failed to get metadata from mp3");
+    }
+    return tags2;
+  }
+  return getMetadataFromIsoBase(structure);
+};
+var hasMetadata = (structure) => {
+  if (structure.type === "mp3") {
+    return getMetadataFromMp3(structure) !== null;
+  }
+  return false;
+};
+
 // src/has-all-info.ts
 var getAvailableInfo = ({
   fieldsToFetch,
@@ -4066,7 +4611,7 @@ var getAvailableInfo = ({
       return Boolean(structure && hasAudioCodec(structure, state));
     }
     if (key === "tracks") {
-      return Boolean(structure && hasTracks(structure, state));
+      return Boolean(structure && getHasTracks(structure, state));
     }
     if (key === "keyframes") {
       return Boolean(structure && hasKeyframes(structure, state));
@@ -4086,33 +4631,122 @@ var getAvailableInfo = ({
     if (key === "container") {
       return Boolean(structure && hasContainer(structure));
     }
-    if (key === "metadata" || key === "location") {
-      return false;
+    if (key === "metadata" || key === "location" || key === "images") {
+      return Boolean(structure && hasMetadata(structure));
     }
     if (key === "slowKeyframes") {
       return false;
     }
-    if (key === "slowNumberOfFrames") {
-      return false;
+    if (key === "slowNumberOfFrames") {
+      return false;
+    }
+    throw new Error(`Unknown key: ${key}`);
+  });
+  const entries = [];
+  let i = 0;
+  for (const [key] of keys) {
+    entries.push([key, infos[i++]]);
+  }
+  return Object.fromEntries(entries);
+};
+var hasAllInfo = ({
+  fields,
+  state
+}) => {
+  const availableInfo = getAvailableInfo({
+    fieldsToFetch: fields ?? {},
+    state
+  });
+  return Object.values(availableInfo).every(Boolean) && (maySkipVideoData({ state }) || state.callbacks.canSkipTracksState.canSkipTracks());
+};
+
+// src/continue-mdat-routine.ts
+var continueMdatRoutine = async ({
+  iterator,
+  maxBytes,
+  allowIncompleteBoxes,
+  initialBoxes,
+  state,
+  continueMdat,
+  signal,
+  logLevel,
+  fields
+}) => {
+  const initialOffset = iterator.counter.getOffset();
+  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
+    const result = await parseMdatPartially({
+      iterator,
+      boxSize: continueMdat.boxSize,
+      fileOffset: continueMdat.fileOffset,
+      parsedBoxes: initialBoxes,
+      state,
+      signal
+    });
+    if (result.type === "incomplete") {
+      throw new Error("Incomplete boxes are not allowed in this routine");
+    }
+    if (result.type === "partial-mdat-box") {
+      return {
+        status: "incomplete",
+        continueParsing: () => {
+          return Promise.resolve(continueMdatRoutine({
+            iterator,
+            maxBytes,
+            allowIncompleteBoxes,
+            initialBoxes,
+            state,
+            continueMdat: result,
+            signal,
+            logLevel,
+            fields
+          }));
+        },
+        skipTo: null
+      };
+    }
+    const alreadyHasMdat = state.structure.getStructureOrNull()?.boxes.find((b) => b.type === "mdat-box");
+    if (result.box.type === "mdat-box" && alreadyHasMdat) {
+      initialBoxes = initialBoxes.filter((b) => b.type !== "mdat-box");
+      initialBoxes.push(result.box);
+      iterator.allowDiscard();
+      break;
+    } else {
+      initialBoxes.push(result.box);
+      if (hasAllInfo({ fields, state })) {
+        return {
+          status: "done"
+        };
+      }
     }
-    throw new Error(`Unknown key: ${key}`);
-  });
-  const entries = [];
-  let i = 0;
-  for (const [key] of keys) {
-    entries.push([key, infos[i++]]);
+    iterator.removeBytesRead();
   }
-  return Object.fromEntries(entries);
-};
-var hasAllInfo = ({
-  fields,
-  state
-}) => {
-  const availableInfo = getAvailableInfo({
-    fieldsToFetch: fields ?? {},
-    state
-  });
-  return Object.values(availableInfo).every(Boolean) && (maySkipVideoData({ state }) || state.callbacks.canSkipTracksState.canSkipTracks());
+  const mdatState = getMdatBox(initialBoxes);
+  const skipped = mdatState?.status === "samples-skipped" && !maySkipVideoData({ state }) && state.supportsContentRange;
+  const buffered = mdatState?.status === "samples-buffered" && !maySkipVideoData({ state });
+  if (skipped || buffered) {
+    return {
+      status: "incomplete",
+      continueParsing: () => {
+        if (buffered) {
+          iterator.skipTo(mdatState.fileOffset, false);
+        }
+        return parseIsoBaseMediaBoxes({
+          iterator,
+          maxBytes,
+          allowIncompleteBoxes: false,
+          initialBoxes,
+          state,
+          signal,
+          logLevel,
+          fields
+        });
+      },
+      skipTo: skipped ? mdatState.fileOffset : null
+    };
+  }
+  return {
+    status: "done"
+  };
 };
 
 // src/register-track.ts
@@ -4225,199 +4859,98 @@ var processDescriptor = ({
         upStream,
         avgBitrate,
         maxBitrate,
-        decoderSpecificConfigs
-      }
-    };
-  }
-  if (tag === 6) {
-    const size = iterator.getPaddedFourByteNumber();
-    iterator.discard(size);
-    return {
-      descriptor: {
-        type: "sl-config-descriptor"
-      }
-    };
-  }
-  return {
-    descriptor: null
-  };
-};
-var parseDescriptors = (iterator, maxBytes) => {
-  const descriptors = [];
-  const initialOffset = iterator.counter.getOffset();
-  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
-    const { descriptor } = processDescriptor({
-      iterator
-    });
-    if (descriptor) {
-      descriptors.push(descriptor);
-    } else {
-      break;
-    }
-  }
-  return descriptors;
-};
-
-// src/boxes/iso-base-media/esds/esds.ts
-var parseEsds = ({
-  data,
-  size,
-  fileOffset
-}) => {
-  const version = data.getUint8();
-  data.discard(3);
-  const tag = data.getUint8();
-  const sizeOfInstance = data.getPaddedFourByteNumber();
-  const esId = data.getUint16();
-  data.discard(1);
-  const remaining = size - (data.counter.getOffset() - fileOffset);
-  const descriptors = parseDescriptors(data, remaining);
-  const remainingNow = size - (data.counter.getOffset() - fileOffset);
-  data.discard(remainingNow);
-  return {
-    type: "esds-box",
-    version,
-    tag,
-    sizeOfInstance,
-    esId,
-    descriptors
-  };
-};
-
-// src/convert-audio-or-video-sample.ts
-var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
-  const { cts, dts, timestamp } = sample;
-  return {
-    cts: cts * 1e6 / timescale,
-    dts: dts * 1e6 / timescale,
-    timestamp: timestamp * 1e6 / timescale,
-    duration: sample.duration === undefined ? undefined : sample.duration * 1e6 / timescale,
-    data: sample.data,
-    trackId: sample.trackId,
-    type: sample.type,
-    offset: sample.offset,
-    timescale: 1e6
-  };
-};
-
-// src/boxes/iso-base-media/mdat/mdat.ts
-var parseMdat = async ({
-  data,
-  size,
-  fileOffset,
-  existingBoxes,
-  state,
-  signal,
-  maySkipSampleProcessing
-}) => {
-  const alreadyHas = hasTracks({
-    type: "iso-base-media",
-    boxes: existingBoxes
-  }, state);
-  if (!alreadyHas) {
-    if (maySkipSampleProcessing) {
-      data.discard(size - (data.counter.getOffset() - fileOffset));
-      return Promise.resolve({
-        type: "mdat-box",
-        boxSize: size,
-        status: "samples-skipped",
-        fileOffset
-      });
-    }
-    data.discard(size - (data.counter.getOffset() - fileOffset));
-    data.disallowDiscard();
-    return Promise.resolve({
-      type: "mdat-box",
-      boxSize: size,
-      status: "samples-buffered",
-      fileOffset
-    });
-  }
-  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, state);
-  const allTracks = [
-    ...tracks2.videoTracks,
-    ...tracks2.audioTracks,
-    ...tracks2.otherTracks
-  ];
-  const flatSamples = allTracks.map((track) => {
-    const samplePositions = getSamplePositionsFromTrack(track.trakBox, getMoofBox(existingBoxes));
-    if (!samplePositions) {
-      throw new Error("No sample positions");
-    }
-    return samplePositions.map((samplePosition) => {
-      return {
-        track: { ...track },
-        samplePosition
-      };
-    });
-  }).flat(1);
-  while (true) {
-    if (signal && signal.aborted) {
-      break;
-    }
-    const samplesWithIndex = flatSamples.find((sample) => {
-      return sample.samplePosition.offset === data.counter.getOffset();
-    });
-    if (!samplesWithIndex) {
-      const nextSample_ = flatSamples.filter((s) => s.samplePosition.offset > data.counter.getOffset()).sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
-      if (nextSample_) {
-        data.discard(nextSample_.samplePosition.offset - data.counter.getOffset());
-        continue;
-      } else {
-        const bytesRemaining = size + fileOffset - data.counter.getOffset();
-        data.discard(bytesRemaining);
-        break;
-      }
-    }
-    if (data.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-      break;
-    }
-    const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
-    const { cts, dts, duration: duration2, isKeyframe, offset } = samplesWithIndex.samplePosition;
-    if (samplesWithIndex.track.type === "audio") {
-      await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-        data: bytes,
-        timestamp: cts,
-        duration: duration2,
-        cts,
-        dts,
-        trackId: samplesWithIndex.track.trackId,
-        type: isKeyframe ? "key" : "delta",
-        offset,
-        timescale: samplesWithIndex.track.timescale
-      }, samplesWithIndex.track.timescale));
-    }
-    if (samplesWithIndex.track.type === "video") {
-      const nalUnitType = bytes[4] & 31;
-      let isRecoveryPoint = false;
-      if (nalUnitType === 6) {
-        const seiType = bytes[5];
-        isRecoveryPoint = seiType === 6;
-      }
-      await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
-        data: bytes,
-        timestamp: cts,
-        duration: duration2,
-        cts,
-        dts,
-        trackId: samplesWithIndex.track.trackId,
-        type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
-        offset,
-        timescale: samplesWithIndex.track.timescale
-      }, samplesWithIndex.track.timescale));
-    }
-    const remaining = size - (data.counter.getOffset() - fileOffset);
-    data.removeBytesRead();
-    if (remaining === 0) {
+        decoderSpecificConfigs
+      }
+    };
+  }
+  if (tag === 6) {
+    const size = iterator.getPaddedFourByteNumber();
+    iterator.discard(size);
+    return {
+      descriptor: {
+        type: "sl-config-descriptor"
+      }
+    };
+  }
+  return {
+    descriptor: null
+  };
+};
+var parseDescriptors = (iterator, maxBytes) => {
+  const descriptors = [];
+  const initialOffset = iterator.counter.getOffset();
+  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
+    const { descriptor } = processDescriptor({
+      iterator
+    });
+    if (descriptor) {
+      descriptors.push(descriptor);
+    } else {
       break;
     }
   }
-  return Promise.resolve({
-    type: "mdat-box",
-    boxSize: size,
-    status: "samples-processed",
-    fileOffset
-  });
+  return descriptors;
+};
+
+// src/boxes/iso-base-media/esds/esds.ts
+var parseEsds = ({
+  data,
+  size,
+  fileOffset
+}) => {
+  const version = data.getUint8();
+  data.discard(3);
+  const tag = data.getUint8();
+  const sizeOfInstance = data.getPaddedFourByteNumber();
+  const esId = data.getUint16();
+  data.discard(1);
+  const remaining = size - (data.counter.getOffset() - fileOffset);
+  const descriptors = parseDescriptors(data, remaining);
+  const remainingNow = size - (data.counter.getOffset() - fileOffset);
+  data.discard(remainingNow);
+  return {
+    type: "esds-box",
+    version,
+    tag,
+    sizeOfInstance,
+    esId,
+    descriptors
+  };
+};
+
+// src/boxes/iso-base-media/get-children.ts
+var getChildren = async ({
+  boxType,
+  iterator,
+  bytesRemainingInBox,
+  state,
+  signal,
+  logLevel,
+  fields
+}) => {
+  const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
+  if (parseChildren) {
+    const boxes = [];
+    const parsed = await parseIsoBaseMediaBoxes({
+      iterator,
+      maxBytes: bytesRemainingInBox,
+      allowIncompleteBoxes: false,
+      initialBoxes: boxes,
+      state,
+      signal,
+      logLevel,
+      fields
+    });
+    if (parsed.status === "incomplete") {
+      throw new Error("Incomplete boxes are not allowed");
+    }
+    return boxes;
+  }
+  if (bytesRemainingInBox < 0) {
+    throw new Error("Box size is too big " + JSON.stringify({ boxType }));
+  }
+  iterator.discard(bytesRemainingInBox);
+  return [];
 };
 
 // src/boxes/iso-base-media/mdhd.ts
@@ -4580,7 +5113,6 @@ var parseMoov = async ({
     allowIncompleteBoxes: false,
     initialBoxes: boxes,
     state,
-    continueMdat: false,
     signal,
     logLevel,
     fields
@@ -4882,7 +5414,6 @@ var parseMebx = async ({
     allowIncompleteBoxes: false,
     initialBoxes: boxes,
     state,
-    continueMdat: false,
     signal,
     logLevel: "info",
     fields
@@ -5291,7 +5822,6 @@ var parseTrak = async ({
     allowIncompleteBoxes: false,
     initialBoxes,
     state: options,
-    continueMdat: false,
     signal,
     logLevel,
     fields
@@ -5350,71 +5880,6 @@ var parseTrun = ({
 };
 
 // src/boxes/iso-base-media/process-box.ts
-var getChildren = async ({
-  boxType,
-  iterator,
-  bytesRemainingInBox,
-  state,
-  signal,
-  logLevel,
-  fields
-}) => {
-  const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "udta" || boxType === "moof" || boxType === "dims" || boxType === "meta" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
-  if (parseChildren) {
-    const boxes = [];
-    const parsed = await parseIsoBaseMediaBoxes({
-      iterator,
-      maxBytes: bytesRemainingInBox,
-      allowIncompleteBoxes: false,
-      initialBoxes: boxes,
-      state,
-      continueMdat: false,
-      signal,
-      logLevel,
-      fields
-    });
-    if (parsed.status === "incomplete") {
-      throw new Error("Incomplete boxes are not allowed");
-    }
-    return boxes;
-  }
-  if (bytesRemainingInBox < 0) {
-    throw new Error("Box size is too big " + JSON.stringify({ boxType }));
-  }
-  iterator.discard(bytesRemainingInBox);
-  return [];
-};
-var parseMdatPartially = async ({
-  iterator,
-  boxSize,
-  fileOffset,
-  parsedBoxes,
-  state,
-  signal
-}) => {
-  const box = await parseMdat({
-    data: iterator,
-    size: boxSize,
-    fileOffset,
-    existingBoxes: parsedBoxes,
-    state,
-    signal,
-    maySkipSampleProcessing: state.supportsContentRange
-  });
-  if ((box.status === "samples-processed" || box.status === "samples-buffered") && box.fileOffset + boxSize === iterator.counter.getOffset()) {
-    return {
-      type: "complete",
-      box,
-      size: boxSize,
-      skipTo: null
-    };
-  }
-  return {
-    type: "partial-mdat-box",
-    boxSize,
-    fileOffset
-  };
-};
 var processBox = async ({
   iterator,
   allowIncompleteBoxes,
@@ -5427,15 +5892,6 @@ var processBox = async ({
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
   const boxSizeRaw = iterator.getFourByteNumber();
-  if (boxSizeRaw === 1 && iterator.bytesRemaining() < 12 || iterator.bytesRemaining() < 4) {
-    iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-    if (allowIncompleteBoxes) {
-      return {
-        type: "incomplete"
-      };
-    }
-    throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
-  }
   if (boxSizeRaw === 0) {
     return {
       type: "complete",
@@ -5447,45 +5903,54 @@ var processBox = async ({
       skipTo: null
     };
   }
+  if (boxSizeRaw === 1 && iterator.bytesRemaining() < 12 || iterator.bytesRemaining() < 4) {
+    iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+    if (!allowIncompleteBoxes) {
+      throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
+    }
+    return {
+      type: "incomplete"
+    };
+  }
   const boxType = iterator.getByteString(4, false);
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
-    if (boxType === "mdat") {
-      const shouldSkip = maySkipVideoData({ state }) || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, state) && state.supportsContentRange;
-      if (shouldSkip) {
-        const skipTo = fileOffset + boxSize;
-        const bytesToSkip = skipTo - iterator.counter.getOffset();
-        if (bytesToSkip > 1e6) {
-          return {
-            type: "complete",
-            box: {
-              type: "mdat-box",
-              boxSize,
-              fileOffset,
-              status: "samples-skipped"
-            },
-            size: boxSize,
-            skipTo: fileOffset + boxSize
-          };
-        }
-      } else {
-        return parseMdatPartially({
-          iterator,
-          boxSize,
-          fileOffset,
-          parsedBoxes,
-          state,
-          signal
-        });
+    if (boxType !== "mdat") {
+      iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+      if (!allowIncompleteBoxes) {
+        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
       }
-    }
-    iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-    if (allowIncompleteBoxes) {
       return {
         type: "incomplete"
       };
     }
-    throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
+    const shouldSkip = maySkipVideoData({ state }) || !getHasTracks({ type: "iso-base-media", boxes: parsedBoxes }, state) && state.supportsContentRange;
+    if (shouldSkip) {
+      const skipTo = fileOffset + boxSize;
+      const bytesToSkip = skipTo - iterator.counter.getOffset();
+      if (bytesToSkip > 1e6) {
+        return {
+          type: "complete",
+          box: {
+            type: "mdat-box",
+            boxSize,
+            fileOffset,
+            status: "samples-skipped"
+          },
+          size: boxSize,
+          skipTo: fileOffset + boxSize
+        };
+      }
+    } else {
+      return parseMdatPartially({
+        iterator,
+        boxSize,
+        fileOffset,
+        parsedBoxes,
+        state,
+        signal
+      });
+    }
   }
   if (boxType === "ftyp") {
     const box = parseFtyp({ iterator, size: boxSize, offset: fileOffset });
@@ -5828,8 +6293,8 @@ var processBox = async ({
       signal,
       maySkipSampleProcessing: state.supportsContentRange
     });
-    if (box === null) {
-      throw new Error("Unexpected null");
+    if (box.type === "partial-mdat-box") {
+      return box;
     }
     return {
       type: "complete",
@@ -5861,28 +6326,34 @@ var processBox = async ({
     skipTo: null
   };
 };
+
+// src/boxes/iso-base-media/parse-boxes.ts
 var parseIsoBaseMediaBoxes = async ({
   iterator,
   maxBytes,
   allowIncompleteBoxes,
   initialBoxes,
   state,
-  continueMdat,
   signal,
   logLevel,
   fields
 }) => {
   const initialOffset = iterator.counter.getOffset();
-  const alreadyHasMdat = state.structure.getStructureOrNull()?.boxes.find((b) => b.type === "mdat-box");
-  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
-    const result = continueMdat ? await parseMdatPartially({
+  const continueParsing = () => {
+    return parseIsoBaseMediaBoxes({
       iterator,
-      boxSize: continueMdat.boxSize,
-      fileOffset: continueMdat.fileOffset,
-      parsedBoxes: initialBoxes,
+      maxBytes,
+      allowIncompleteBoxes,
+      initialBoxes,
       state,
-      signal
-    }) : await processBox({
+      signal,
+      logLevel,
+      fields
+    });
+  };
+  const alreadyHasMdat = state.structure.getStructureOrNull()?.boxes.find((b) => b.type === "mdat-box");
+  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
+    const result = await processBox({
       iterator,
       allowIncompleteBoxes,
       parsedBoxes: initialBoxes,
@@ -5897,19 +6368,7 @@ var parseIsoBaseMediaBoxes = async ({
       }
       return {
         status: "incomplete",
-        continueParsing: () => {
-          return parseIsoBaseMediaBoxes({
-            iterator,
-            maxBytes,
-            allowIncompleteBoxes,
-            initialBoxes,
-            state,
-            continueMdat: false,
-            signal,
-            logLevel,
-            fields
-          });
-        },
+        continueParsing,
         skipTo: null
       };
     }
@@ -5917,7 +6376,7 @@ var parseIsoBaseMediaBoxes = async ({
       return {
         status: "incomplete",
         continueParsing: () => {
-          return Promise.resolve(parseIsoBaseMediaBoxes({
+          return Promise.resolve(continueMdatRoutine({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
@@ -5951,38 +6410,14 @@ var parseIsoBaseMediaBoxes = async ({
       }
       return {
         status: "incomplete",
-        continueParsing: () => {
-          return parseIsoBaseMediaBoxes({
-            iterator,
-            maxBytes,
-            allowIncompleteBoxes,
-            initialBoxes,
-            state,
-            continueMdat: false,
-            signal,
-            logLevel,
-            fields
-          });
-        },
+        continueParsing,
         skipTo: result.skipTo
       };
     }
     if (iterator.bytesRemaining() < 0) {
       return {
         status: "incomplete",
-        continueParsing: () => {
-          return parseIsoBaseMediaBoxes({
-            iterator,
-            maxBytes,
-            allowIncompleteBoxes,
-            initialBoxes,
-            state,
-            continueMdat: false,
-            signal,
-            logLevel,
-            fields
-          });
-        },
+        continueParsing,
         skipTo: null
       };
     }
@@ -6004,7 +6439,6 @@ var parseIsoBaseMediaBoxes = async ({
           allowIncompleteBoxes: false,
           initialBoxes,
           state,
-          continueMdat: false,
           signal,
           logLevel,
           fields
@@ -6126,7 +6560,6 @@ var processSample = async ({
         maxBytes: bytesRemainingInBox,
         initialBoxes,
         state: options,
-        continueMdat: false,
         signal,
         logLevel,
         fields
@@ -6175,7 +6608,6 @@ var processSample = async ({
         maxBytes: bytesRemainingInBox,
         initialBoxes,
         state: options,
-        continueMdat: false,
         signal,
         logLevel,
         fields
@@ -6227,7 +6659,6 @@ var processSample = async ({
         maxBytes: bytesRemainingInBox,
         initialBoxes: [],
         state: options,
-        continueMdat: false,
         signal,
         logLevel,
         fields
@@ -6284,7 +6715,6 @@ var processSample = async ({
       maxBytes: bytesRemainingInBox,
       initialBoxes,
       state: options,
-      continueMdat: false,
       signal,
       logLevel,
       fields
@@ -6670,11 +7100,24 @@ var emittedState = () => {
     slowFps: false,
     slowKeyframes: false,
     slowNumberOfFrames: false,
-    keyframes: false
+    keyframes: false,
+    images: false
   };
   return emittedFields;
 };
 
+// src/state/images.ts
+var imagesState = () => {
+  const images = [];
+  const addImage = (image) => {
+    images.push(image);
+  };
+  return {
+    images,
+    addImage
+  };
+};
+
 // src/state/keyframes.ts
 var keyframesState = () => {
   const keyframes = [];
@@ -6688,6 +7131,17 @@ var keyframesState = () => {
   };
 };
 
+// src/state/mp3.ts
+var makeMp3State = () => {
+  let mp3Info = null;
+  return {
+    getMp3Info: () => mp3Info,
+    setMp3Info: (info) => {
+      mp3Info = info;
+    }
+  };
+};
+
 // src/state/riff.ts
 var riffSpecificState = () => {
   let avcProfile = null;
@@ -6741,7 +7195,8 @@ var needsTracksField = {
   mimeType: false,
   slowKeyframes: true,
   slowNumberOfFrames: true,
-  keyframes: true
+  keyframes: true,
+  images: true
 };
 var makeCanSkipTracksState = ({
   hasAudioTrackHandlers,
@@ -6831,6 +7286,9 @@ var sampleCallback = ({
           await callback(audioSample);
         }
       }
+      if (needsToIterateOverSamples({ emittedFields, fields })) {
+        slowDurationAndFpsState.addAudioSample(audioSample);
+      }
     },
     getSamplesForTrack: (trackId) => {
       return samplesForTrack[trackId] ?? 0;
@@ -6862,7 +7320,7 @@ var sampleCallback = ({
             sizeInBytes: videoSample.data.length
           });
         }
-        slowDurationAndFpsState.addSample(videoSample);
+        slowDurationAndFpsState.addVideoSample(videoSample);
       }
     },
     canSkipTracksState,
@@ -6885,33 +7343,64 @@ var sampleCallback = ({
 
 // src/state/slow-duration-fps.ts
 var slowDurationAndFpsState = () => {
-  let smallestSample;
-  let largestSample;
-  let samples = 0;
+  let smallestVideoSample;
+  let largestVideoSample;
+  let smallestAudioSample;
+  let largestAudioSample;
+  let videoSamples = 0;
+  let audioSamples = 0;
+  const getSlowVideoDurationInSeconds = () => {
+    let videoDuration = null;
+    if (smallestVideoSample !== undefined && largestVideoSample !== undefined) {
+      const startingTimestampDifference = largestVideoSample - smallestVideoSample;
+      const timeBetweenSamples = startingTimestampDifference / (videoSamples - 1);
+      videoDuration = timeBetweenSamples * videoSamples;
+    }
+    return videoDuration;
+  };
   const getSlowDurationInSeconds = () => {
-    if (smallestSample !== undefined && largestSample !== undefined) {
-      const startingTimestampDifference = largestSample - smallestSample;
-      const timeBetweenSamples = startingTimestampDifference / (samples - 1);
-      return timeBetweenSamples * samples;
+    const videoDuration = getSlowVideoDurationInSeconds();
+    let audioDuration = null;
+    if (smallestAudioSample !== undefined && largestAudioSample !== undefined) {
+      const startingTimestampDifferenceAudio = largestAudioSample - smallestAudioSample;
+      const timeBetweenSamplesAudio = startingTimestampDifferenceAudio / (audioSamples - 1);
+      audioDuration = timeBetweenSamplesAudio * audioSamples;
     }
-    throw new Error("No samples");
+    if (videoDuration === null && audioDuration === null) {
+      throw new Error("No samples");
+    }
+    return Math.max(videoDuration ?? 0, audioDuration ?? 0);
   };
   return {
-    addSample: (videoSample) => {
-      samples++;
+    addVideoSample: (videoSample) => {
+      videoSamples++;
       const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
-      if (largestSample === undefined || presentationTimeInSeconds > largestSample) {
-        largestSample = presentationTimeInSeconds;
+      if (largestVideoSample === undefined || presentationTimeInSeconds > largestVideoSample) {
+        largestVideoSample = presentationTimeInSeconds;
+      }
+      if (smallestVideoSample === undefined || presentationTimeInSeconds < smallestVideoSample) {
+        smallestVideoSample = presentationTimeInSeconds;
       }
-      if (smallestSample === undefined || presentationTimeInSeconds < smallestSample) {
-        smallestSample = presentationTimeInSeconds;
+    },
+    addAudioSample: (audioSample) => {
+      audioSamples++;
+      const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
+      if (largestAudioSample === undefined || presentationTimeInSeconds > largestAudioSample) {
+        largestAudioSample = presentationTimeInSeconds;
+      }
+      if (smallestAudioSample === undefined || presentationTimeInSeconds < smallestAudioSample) {
+        smallestAudioSample = presentationTimeInSeconds;
       }
     },
     getSlowDurationInSeconds,
     getFps: () => {
-      return samples / getSlowDurationInSeconds();
+      const videoDuration = getSlowVideoDurationInSeconds() ?? 0;
+      if (videoDuration === 0) {
+        return 0;
+      }
+      return videoSamples / videoDuration;
     },
-    getSlowNumberOfFrames: () => samples
+    getSlowNumberOfFrames: () => videoSamples
   };
 };
 
@@ -7002,7 +7491,8 @@ var makeParserState = ({
   fields,
   onAudioTrack,
   onVideoTrack,
-  supportsContentRange
+  supportsContentRange,
+  contentLength
 }) => {
   let skippedBytes = 0;
   const increaseSkippedBytes = (bytes) => {
@@ -7012,6 +7502,8 @@ var makeParserState = ({
   const keyframes = keyframesState();
   const emittedFields = emittedState();
   const slowDurationAndFps = slowDurationAndFpsState();
+  const mp3Info = makeMp3State();
+  const images = imagesState();
   return {
     riff: riffSpecificState(),
     callbacks: sampleCallback({
@@ -7037,7 +7529,10 @@ var makeParserState = ({
     webm: webmState(),
     emittedFields,
     fields,
-    slowDurationAndFps
+    slowDurationAndFps,
+    mp3Info,
+    contentLength,
+    images
   };
 };
 
@@ -7395,299 +7890,108 @@ class IsAGifError extends Error {
     fileName
   }) {
     super(message);
-    this.fileName = "IsAGifError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAGifError);
-    }
-  }
-}
-
-class IsAnImageError extends Error {
-  imageType;
-  dimensions;
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    dimensions,
-    imageType,
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnImageError";
-    this.imageType = imageType;
-    this.dimensions = dimensions;
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnImageError);
-    }
-  }
-}
-
-class IsAPdfError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAPdfError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAPdfError);
-    }
-  }
-}
-
-class IsAnUnsupportedFileTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedFileTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
-    }
-  }
-}
-
-class IsAnUnsupportedAudioTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  audioType;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName,
-    audioType
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedAudioTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    this.audioType = audioType;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
-    }
-  }
-}
-// src/metadata/metadata-from-iso.ts
-var mapToKey = (index) => {
-  if (index === 2839630420) {
-    return "artist";
-  }
-  if (index === 2841734242) {
-    return "album";
-  }
-  if (index === 2841865588) {
-    return "comment";
-  }
-  if (index === 2841928057) {
-    return "releaseDate";
-  }
-  if (index === 2842125678) {
-    return "genre";
-  }
-  if (index === 2842583405) {
-    return "title";
-  }
-  if (index === 2842980207) {
-    return "encoder";
-  }
-  if (index === 2843177588) {
-    return "writer";
-  }
-  if (index === 2841866361) {
-    return "copyright";
-  }
-  if (index === 2841930098) {
-    return "director";
-  }
-  if (index === 2842718820) {
-    return "producer";
-  }
-  if (index === 2841929075) {
-    return "description";
-  }
-  return null;
-};
-var parseIlstBoxWithoutKeys = (ilstBox) => {
-  return ilstBox.entries.map((entry) => {
-    const key = mapToKey(entry.index);
-    if (!key) {
-      return null;
-    }
-    if (entry.value.type === "unknown") {
-      return null;
-    }
-    return {
-      trackId: null,
-      key,
-      value: entry.value.value
-    };
-  }).filter(truthy);
-};
-var parseIsoMetaBox = (meta, trackId) => {
-  const ilstBox = meta.children.find((b) => b.type === "ilst-box");
-  const keysBox = meta.children.find((b) => b.type === "keys-box");
-  if (!ilstBox || !keysBox) {
-    if (ilstBox) {
-      return parseIlstBoxWithoutKeys(ilstBox);
-    }
-    return [];
-  }
-  const entries = [];
-  for (let i = 0;i < ilstBox.entries.length; i++) {
-    const ilstEntry = ilstBox.entries[i];
-    const keysEntry = keysBox.entries[i];
-    if (ilstEntry.value.type !== "unknown") {
-      const value = typeof ilstEntry.value.value === "string" && ilstEntry.value.value.endsWith("\x00") ? ilstEntry.value.value.slice(0, -1) : ilstEntry.value.value;
-      entries.push({
-        key: keysEntry.value,
-        value,
-        trackId
-      });
-    }
-  }
-  return entries;
-};
-var getMetadataFromIsoBase = (isoBase) => {
-  const moov = getMoovBox(isoBase.boxes);
-  if (!moov) {
-    return [];
-  }
-  const traks = getTraks(moov);
-  const meta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "meta");
-  const udta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "udta");
-  const metaInUdta = udta?.children.find((b) => {
-    return b.type === "regular-box" && b.boxType === "meta";
-  });
-  const metaInTracks = traks.map((t) => {
-    const metaBox = t.children.find((child) => child.type === "regular-box" && child.boxType === "meta");
-    if (metaBox) {
-      const tkhd = getTkhdBox(t);
-      if (!tkhd) {
-        throw new Error("No tkhd box found");
-      }
-      return parseIsoMetaBox(metaBox, tkhd.trackId);
-    }
-    return null;
-  }).filter(truthy);
-  return [
-    ...meta ? parseIsoMetaBox(meta, null) : [],
-    ...metaInUdta ? parseIsoMetaBox(metaInUdta, null) : [],
-    ...metaInTracks.flat(1)
-  ];
-};
-
-// src/metadata/metadata-from-matroska.ts
-var removeEndZeroes = (value) => {
-  return value.endsWith("\x00") ? removeEndZeroes(value.slice(0, -1)) : value;
-};
-var parseSimpleTagIntoEbml = (children, trackId) => {
-  const tagName = children.find((c) => c.type === "TagName");
-  const tagString = children.find((c) => c.type === "TagString");
-  if (!tagName || !tagString) {
-    return null;
-  }
-  return {
-    trackId,
-    key: tagName.value.toLowerCase(),
-    value: removeEndZeroes(tagString.value)
-  };
-};
-var getMetadataFromMatroska = (structure) => {
-  const entries = [];
-  for (const segment of structure.boxes) {
-    if (segment.type !== "Segment") {
-      continue;
-    }
-    const tags2 = segment.value.filter((s) => s.type === "Tags");
-    for (const tag of tags2) {
-      for (const child of tag.value) {
-        if (child.type !== "Tag") {
-          continue;
-        }
-        let trackId = null;
-        const target = child.value.find((c) => c.type === "Targets");
-        if (target) {
-          const tagTrackId = target.value.find((c) => c.type === "TagTrackUID")?.value;
-          if (tagTrackId) {
-            trackId = getTrackWithUid(segment, tagTrackId);
-          }
-        }
-        const simpleTags = child.value.filter((s) => s.type === "SimpleTag");
-        for (const simpleTag of simpleTags) {
-          const parsed = parseSimpleTagIntoEbml(simpleTag.value, trackId);
-          if (parsed) {
-            entries.push(parsed);
-          }
-        }
-      }
+    this.fileName = "IsAGifError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAGifError);
     }
   }
-  return entries;
-};
+}
 
-// src/metadata/metadata-from-riff.ts
-var getMetadataFromRiff = (structure) => {
-  const boxes = structure.boxes.find((b) => b.type === "list-box" && b.listType === "INFO");
-  if (!boxes) {
-    return [];
-  }
-  const { children } = boxes;
-  return children.map((child) => {
-    if (child.type !== "isft-box") {
-      return null;
+class IsAnImageError extends Error {
+  imageType;
+  dimensions;
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    dimensions,
+    imageType,
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnImageError";
+    this.imageType = imageType;
+    this.dimensions = dimensions;
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnImageError);
     }
-    return {
-      trackId: null,
-      key: "encoder",
-      value: child.software
-    };
-  }).filter(truthy);
-};
-
-// src/metadata/get-metadata.ts
-var getMetadata = (structure) => {
-  if (structure.type === "matroska") {
-    return getMetadataFromMatroska(structure);
   }
-  if (structure.type === "riff") {
-    return getMetadataFromRiff(structure);
+}
+
+class IsAPdfError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAPdfError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAPdfError);
+    }
   }
-  if (structure.type === "transport-stream") {
-    return [];
+}
+
+class IsAnUnsupportedFileTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedFileTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
+    }
   }
-  return getMetadataFromIsoBase(structure);
-};
+}
 
+class IsAnUnsupportedAudioTypeError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  audioType;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    fileName,
+    audioType
+  }) {
+    super(message);
+    this.name = "IsAnUnsupportedAudioTypeError";
+    this.mimeType = mimeType;
+    this.sizeInBytes = sizeInBytes;
+    this.fileName = fileName;
+    this.audioType = audioType;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
+    }
+  }
+}
 // src/get-location.ts
 function parseLocation(locationString) {
   const locationPattern = /^([+-]\d{2}\.?\d{0,10})([+-]\d{3}\.?\d{0,10})([+-]\d+(\.\d+)?)?\/$/;
@@ -7808,7 +8112,7 @@ var emitAvailableInfo = ({
     if (key === "dimensions") {
       if (hasInfo.dimensions && !emittedFields.dimensions && parseResult && segments) {
         const dimensionsQueried = getDimensions(segments, state);
-        const dimensions = {
+        const dimensions = dimensionsQueried === null ? null : {
           height: dimensionsQueried.height,
           width: dimensionsQueried.width
         };
@@ -7823,7 +8127,7 @@ var emitAvailableInfo = ({
     if (key === "unrotatedDimensions") {
       if (hasInfo.unrotatedDimensions && !emittedFields.unrotatedDimensions && parseResult && segments) {
         const dimensionsQueried = getDimensions(segments, state);
-        const unrotatedDimensions = {
+        const unrotatedDimensions = dimensionsQueried === null ? null : {
           height: dimensionsQueried.unrotatedHeight,
           width: dimensionsQueried.unrotatedWidth
         };
@@ -7838,7 +8142,7 @@ var emitAvailableInfo = ({
     if (key === "rotation") {
       if (hasInfo.rotation && !emittedFields.rotation && parseResult && segments) {
         const dimensionsQueried = getDimensions(segments, state);
-        const { rotation } = dimensionsQueried;
+        const rotation = dimensionsQueried?.rotation ?? 0;
         callbacks.onRotation?.(rotation);
         if (fieldsInReturnValue.rotation) {
           returnValue.rotation = rotation;
@@ -7994,41 +8298,489 @@ var emitAvailableInfo = ({
       }
       continue;
     }
+    if (key === "images") {
+      if (!emittedFields.images && hasInfo.images && parseResult) {
+        callbacks.onImages?.(state.images.images);
+        if (fieldsInReturnValue.images) {
+          returnValue.images = state.images.images;
+        }
+        emittedFields.images = true;
+      }
+      continue;
+    }
     throw new Error(`Unhandled key: ${key}`);
   }
 };
 
-// src/get-fields-from-callbacks.ts
-var getFieldsFromCallback = ({
-  fields,
-  callbacks
+// src/get-fields-from-callbacks.ts
+var getFieldsFromCallback = ({
+  fields,
+  callbacks
+}) => {
+  const newFields = {
+    audioCodec: Boolean(callbacks.onAudioCodec),
+    container: Boolean(callbacks.onContainer),
+    dimensions: Boolean(callbacks.onDimensions),
+    durationInSeconds: Boolean(callbacks.onDurationInSeconds),
+    fps: Boolean(callbacks.onFps),
+    internalStats: Boolean(callbacks.onInternalStats),
+    isHdr: Boolean(callbacks.onIsHdr),
+    location: Boolean(callbacks.onLocation),
+    metadata: Boolean(callbacks.onMetadata),
+    mimeType: Boolean(callbacks.onMimeType),
+    name: Boolean(callbacks.onName),
+    rotation: Boolean(callbacks.onRotation),
+    size: Boolean(callbacks.onSize),
+    structure: Boolean(callbacks.onStructure),
+    tracks: Boolean(callbacks.onTracks),
+    unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
+    videoCodec: Boolean(callbacks.onVideoCodec),
+    slowKeyframes: Boolean(callbacks.onSlowKeyframes),
+    slowDurationInSeconds: Boolean(callbacks.onSlowDurationInSeconds),
+    slowFps: Boolean(callbacks.onSlowFps),
+    slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
+    keyframes: Boolean(callbacks.onKeyframes),
+    images: Boolean(callbacks.onImages),
+    ...fields
+  };
+  return newFields;
+};
+
+// src/boxes/mp3/id3.ts
+function combine28Bits(a, b, c, d) {
+  const val1 = a & 127;
+  const val2 = b & 127;
+  const val3 = c & 127;
+  const val4 = d & 127;
+  return val1 << 21 | val2 << 14 | val3 << 7 | val4;
+}
+var parseId3 = ({
+  iterator,
+  structure,
+  state
+}) => {
+  if (iterator.bytesRemaining() < 9) {
+    return;
+  }
+  const { returnToCheckpoint } = iterator.startCheckpoint();
+  iterator.discard(3);
+  const versionMajor = iterator.getUint8();
+  const versionMinor = iterator.getUint8();
+  const flags = iterator.getUint8();
+  const sizeArr = iterator.getSlice(4);
+  const size = combine28Bits(sizeArr[0], sizeArr[1], sizeArr[2], sizeArr[3]);
+  if (iterator.bytesRemaining() < size) {
+    returnToCheckpoint();
+    return;
+  }
+  const entries = [];
+  const initial = iterator.counter.getOffset();
+  while (iterator.counter.getOffset() < size + initial) {
+    const name = versionMajor === 3 ? iterator.getByteString(4, true) : iterator.getByteString(3, true);
+    if (name === "") {
+      iterator.discard(size + initial - iterator.counter.getOffset());
+      break;
+    }
+    const s = versionMajor === 3 ? iterator.getUint32() : iterator.getUint24();
+    if (versionMajor === 3) {
+      iterator.getUint16();
+    }
+    let subtract = 0;
+    if (!name.startsWith("W")) {
+      iterator.getUint8();
+      subtract += 1;
+    }
+    if (name === "APIC") {
+      const { discardRest } = iterator.planBytes(s - subtract);
+      const mimeType = iterator.readUntilNullTerminator();
+      iterator.getUint16();
+      const description = iterator.readUntilNullTerminator();
+      iterator.discard(1);
+      const data = discardRest();
+      state.images.addImage({
+        data,
+        description,
+        mimeType
+      });
+    } else {
+      const information = iterator.getByteString(s - subtract, true);
+      entries.push({
+        key: name,
+        value: information,
+        trackId: null
+      });
+    }
+  }
+  structure.boxes.push({
+    type: "id3-header",
+    flags,
+    size,
+    versionMajor,
+    versionMinor,
+    metatags: entries
+  });
+};
+
+// src/boxes/mp3/id3-v1.ts
+var parseID3V1 = (iterator) => {
+  if (iterator.bytesRemaining() < 128) {
+    return;
+  }
+  iterator.discard(128);
+};
+
+// src/boxes/mp3/parse-mpeg-header.ts
+function getSamplingFrequency({
+  bits,
+  mpegVersion
+}) {
+  const samplingTable = {
+    0: { MPEG1: 44100, MPEG2: 22050 },
+    1: { MPEG1: 48000, MPEG2: 24000 },
+    2: { MPEG1: 32000, MPEG2: 16000 },
+    3: { MPEG1: "reserved", MPEG2: "reserved" }
+  };
+  const key = `MPEG${mpegVersion}`;
+  const value = samplingTable[bits][key];
+  if (value === "reserved") {
+    throw new Error("Reserved sampling frequency");
+  }
+  if (!value) {
+    throw new Error("Invalid sampling frequency for MPEG version: " + JSON.stringify({ bits, version: mpegVersion }));
+  }
+  return value;
+}
+function getBitrateKB({
+  bits,
+  mpegVersion,
+  level
+}) {
+  const bitrateTable = {
+    0: {
+      "V1,L1": "free",
+      "V1,L2": "free",
+      "V1,L3": "free",
+      "V2,L1": "free",
+      "V2,L2&L3": "free"
+    },
+    1: { "V1,L1": 32, "V1,L2": 32, "V1,L3": 32, "V2,L1": 32, "V2,L2&L3": 8 },
+    2: {
+      "V1,L1": 64,
+      "V1,L2": 48,
+      "V1,L3": 40,
+      "V2,L1": 48,
+      "V2,L2&L3": 16
+    },
+    3: {
+      "V1,L1": 96,
+      "V1,L2": 56,
+      "V1,L3": 48,
+      "V2,L1": 56,
+      "V2,L2&L3": 24
+    },
+    4: {
+      "V1,L1": 128,
+      "V1,L2": 64,
+      "V1,L3": 56,
+      "V2,L1": 64,
+      "V2,L2&L3": 32
+    },
+    5: {
+      "V1,L1": 160,
+      "V1,L2": 80,
+      "V1,L3": 64,
+      "V2,L1": 80,
+      "V2,L2&L3": 40
+    },
+    6: {
+      "V1,L1": 192,
+      "V1,L2": 96,
+      "V1,L3": 80,
+      "V2,L1": 96,
+      "V2,L2&L3": 48
+    },
+    7: {
+      "V1,L1": 224,
+      "V1,L2": 112,
+      "V1,L3": 96,
+      "V2,L1": 112,
+      "V2,L2&L3": 56
+    },
+    8: {
+      "V1,L1": 256,
+      "V1,L2": 128,
+      "V1,L3": 112,
+      "V2,L1": 128,
+      "V2,L2&L3": 64
+    },
+    9: {
+      "V1,L1": 288,
+      "V1,L2": 160,
+      "V1,L3": 128,
+      "V2,L1": 144,
+      "V2,L2&L3": 80
+    },
+    10: {
+      "V1,L1": 320,
+      "V1,L2": 192,
+      "V1,L3": 160,
+      "V2,L1": 160,
+      "V2,L2&L3": 96
+    },
+    11: {
+      "V1,L1": 352,
+      "V1,L2": 224,
+      "V1,L3": 192,
+      "V2,L1": 176,
+      "V2,L2&L3": 112
+    },
+    12: {
+      "V1,L1": 384,
+      "V1,L2": 256,
+      "V1,L3": 224,
+      "V2,L1": 192,
+      "V2,L2&L3": 128
+    },
+    13: {
+      "V1,L1": 416,
+      "V1,L2": 320,
+      "V1,L3": 256,
+      "V2,L1": 224,
+      "V2,L2&L3": 144
+    },
+    14: {
+      "V1,L1": 448,
+      "V1,L2": 384,
+      "V1,L3": 320,
+      "V2,L1": 256,
+      "V2,L2&L3": 160
+    },
+    15: {
+      "V1,L1": "bad",
+      "V1,L2": "bad",
+      "V1,L3": "bad",
+      "V2,L1": "bad",
+      "V2,L2&L3": "bad"
+    }
+  };
+  let key;
+  if (mpegVersion === 2 && (level === 2 || level === 3)) {
+    key = "V2,L2&L3";
+  } else {
+    key = `V${mpegVersion},L${level}`;
+  }
+  return bitrateTable[bits][key];
+}
+var parseMpegHeader = async ({
+  iterator,
+  state
+}) => {
+  const initialOffset = iterator.counter.getOffset();
+  if (iterator.bytesRemaining() < 32) {
+    return;
+  }
+  iterator.startReadingBits();
+  for (let i = 0;i < 11; i++) {
+    const expectToBe1 = iterator.getBits(1);
+    if (expectToBe1 !== 1) {
+      throw new Error("Expected 1");
+    }
+  }
+  const audioVersionId = iterator.getBits(2);
+  if (audioVersionId !== 3 && audioVersionId !== 2) {
+    throw new Error("Expected MPEG Version 1 or 2");
+  }
+  const mpegVersion = audioVersionId === 3 ? 1 : 2;
+  const layerBits = iterator.getBits(2);
+  if (layerBits === 0) {
+    throw new Error("Expected Layer I, II or III");
+  }
+  const layer = layerBits === 3 ? 1 : layerBits === 2 ? 2 : 3;
+  const protectionBit = iterator.getBits(1);
+  if (protectionBit !== 1) {
+    throw new Error("Does not support CRC yet");
+  }
+  const bitrateIndex = iterator.getBits(4);
+  const bitrateKbit = getBitrateKB({
+    bits: bitrateIndex,
+    mpegVersion,
+    level: audioVersionId
+  });
+  if (bitrateKbit === "bad") {
+    throw new Error("Invalid bitrate");
+  }
+  if (bitrateKbit === "free") {
+    throw new Error("Free bitrate not supported");
+  }
+  const samplingFrequencyIndex = iterator.getBits(2);
+  const sampleRate = getSamplingFrequency({
+    bits: samplingFrequencyIndex,
+    mpegVersion
+  });
+  const padding = Boolean(iterator.getBits(1));
+  iterator.getBits(1);
+  const channelMode = iterator.getBits(2);
+  iterator.getBits(2);
+  iterator.getBits(1);
+  iterator.getBits(1);
+  iterator.getBits(2);
+  const numberOfChannels = channelMode === 3 ? 1 : 2;
+  const samplesPerFrame = getSamplesPerMpegFrame({ mpegVersion, layer });
+  const frameLength = getMpegFrameLength({
+    bitrateKbit,
+    padding,
+    samplesPerFrame,
+    samplingFrequency: sampleRate,
+    layer
+  });
+  iterator.stopReadingBits();
+  const offsetNow = iterator.counter.getOffset();
+  iterator.counter.decrement(offsetNow - initialOffset);
+  const data = iterator.getSlice(frameLength);
+  if (state.callbacks.tracks.getTracks().length === 0) {
+    state.mp3Info.setMp3Info({
+      layer,
+      mpegVersion,
+      sampleRate,
+      bitrateKbit,
+      startOfMpegStream: initialOffset
+    });
+    await registerTrack({
+      container: "mp3",
+      state,
+      track: {
+        type: "audio",
+        codec: "mp3",
+        codecPrivate: null,
+        codecWithoutConfig: "mp3",
+        description: undefined,
+        numberOfChannels,
+        sampleRate,
+        timescale: 1e6,
+        trackId: 0,
+        trakBox: null
+      }
+    });
+    state.callbacks.tracks.setIsDone();
+  }
+  const mp3Info = state.mp3Info.getMp3Info();
+  if (!mp3Info) {
+    throw new Error("No MP3 info by now");
+  }
+  const avgLength = getAverageMpegFrameLength({
+    bitrateKbit,
+    layer,
+    samplesPerFrame,
+    samplingFrequency: sampleRate
+  });
+  const nthFrame = Math.round((initialOffset - mp3Info.startOfMpegStream) / avgLength);
+  const durationInSeconds = samplesPerFrame / sampleRate;
+  const timeInSeconds = nthFrame * samplesPerFrame / sampleRate;
+  const timestamp = Math.round(timeInSeconds * 1e6);
+  const duration2 = Math.round(durationInSeconds * 1e6);
+  await state.callbacks.onAudioSample(0, {
+    data,
+    cts: timestamp,
+    dts: timestamp,
+    duration: duration2,
+    offset: initialOffset,
+    timescale: 1e6,
+    timestamp,
+    trackId: 0,
+    type: "key"
+  });
+};
+
+// src/boxes/mp3/parse-mp3.ts
+var parseMp3 = async ({
+  iterator,
+  structure,
+  state
+}) => {
+  const continueParsing = () => {
+    return parseMp3({ iterator, structure, state });
+  };
+  if (iterator.bytesRemaining() === 0) {
+    return Promise.resolve({
+      status: "done"
+    });
+  }
+  if (iterator.bytesRemaining() < 3) {
+    return {
+      status: "incomplete",
+      skipTo: null,
+      continueParsing
+    };
+  }
+  const { returnToCheckpoint } = iterator.startCheckpoint();
+  const bytes = iterator.getSlice(3);
+  returnToCheckpoint();
+  if (bytes[0] === 84 && bytes[1] === 65 && bytes[2] === 71) {
+    parseID3V1(iterator);
+    return {
+      status: "incomplete",
+      continueParsing,
+      skipTo: null
+    };
+  }
+  if (bytes[0] === 73 && bytes[1] === 68 && bytes[2] === 51) {
+    parseId3({ iterator, structure, state });
+    return {
+      status: "incomplete",
+      continueParsing,
+      skipTo: null
+    };
+  }
+  if (bytes[0] === 255) {
+    await parseMpegHeader({
+      iterator,
+      state
+    });
+    return {
+      status: "incomplete",
+      continueParsing,
+      skipTo: null
+    };
+  }
+  throw new Error("Unknown MP3 header ");
+};
+
+// src/boxes/riff/continue-after-riff-result.ts
+var continueAfterRiffBoxResult = ({
+  result,
+  structure,
+  iterator,
+  maxOffset,
+  state: options,
+  fields
 }) => {
-  const newFields = {
-    audioCodec: Boolean(callbacks.onAudioCodec),
-    container: Boolean(callbacks.onContainer),
-    dimensions: Boolean(callbacks.onDimensions),
-    durationInSeconds: Boolean(callbacks.onDurationInSeconds),
-    fps: Boolean(callbacks.onFps),
-    internalStats: Boolean(callbacks.onInternalStats),
-    isHdr: Boolean(callbacks.onIsHdr),
-    location: Boolean(callbacks.onLocation),
-    metadata: Boolean(callbacks.onMetadata),
-    mimeType: Boolean(callbacks.onMimeType),
-    name: Boolean(callbacks.onName),
-    rotation: Boolean(callbacks.onRotation),
-    size: Boolean(callbacks.onSize),
-    structure: Boolean(callbacks.onStructure),
-    tracks: Boolean(callbacks.onTracks),
-    unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
-    videoCodec: Boolean(callbacks.onVideoCodec),
-    slowKeyframes: Boolean(callbacks.onSlowKeyframes),
-    slowDurationInSeconds: Boolean(callbacks.onSlowDurationInSeconds),
-    slowFps: Boolean(callbacks.onSlowFps),
-    slowNumberOfFrames: Boolean(callbacks.onSlowNumberOfFrames),
-    keyframes: Boolean(callbacks.onKeyframes),
-    ...fields
-  };
-  return newFields;
+  if (result.type === "incomplete") {
+    return Promise.resolve({
+      status: "incomplete",
+      async continueParsing() {
+        return Promise.resolve(continueAfterRiffBoxResult({
+          result: await result.continueParsing(),
+          structure,
+          iterator,
+          maxOffset,
+          state: options,
+          fields
+        }));
+      },
+      segments: structure,
+      skipTo: null
+    });
+  }
+  if (result.type === "complete" && result.box) {
+    structure.boxes.push(result.box);
+  }
+  return parseRiffBody({
+    iterator,
+    maxOffset,
+    state: options,
+    structure,
+    fields
+  });
 };
 
 // src/boxes/riff/is-movi.ts
@@ -8508,7 +9260,8 @@ var parseIsft = ({
 var parseListBox = async ({
   iterator,
   size,
-  state
+  state,
+  fields
 }) => {
   const counter = iterator.counter.getOffset();
   const listType = iterator.getByteString(4, false);
@@ -8523,7 +9276,8 @@ var parseListBox = async ({
     structure,
     iterator,
     maxOffset: counter + size,
-    state
+    state,
+    fields
   });
   if (result.status === "incomplete") {
     throw new Error(`Should only parse complete boxes (${listType})`);
@@ -8663,13 +9417,14 @@ var parseRiffBox = ({
   size,
   id,
   boxes,
-  state
+  state,
+  fields
 }) => {
   if (id === "fmt") {
     return Promise.resolve(parseFmtBox({ iterator, boxes, size }));
   }
   if (id === "LIST") {
-    return parseListBox({ iterator, size, state });
+    return parseListBox({ iterator, size, state, fields });
   }
   if (id === "ISFT") {
     return Promise.resolve(parseIsft({ iterator, size }));
@@ -8696,13 +9451,14 @@ var parseRiffBox = ({
 var expectRiffBox = async ({
   iterator,
   state,
-  structure
+  structure,
+  fields
 }) => {
   if (iterator.bytesRemaining() < 16) {
     return {
       type: "incomplete",
       continueParsing() {
-        return expectRiffBox({ structure, iterator, state });
+        return expectRiffBox({ structure, iterator, state, fields });
       }
     };
   }
@@ -8722,7 +9478,7 @@ var expectRiffBox = async ({
     return {
       type: "incomplete",
       continueParsing: () => {
-        return expectRiffBox({ structure, iterator, state });
+        return expectRiffBox({ structure, iterator, state, fields });
       }
     };
   }
@@ -8733,52 +9489,27 @@ var expectRiffBox = async ({
       iterator,
       size: ckSize,
       boxes: structure.boxes,
-      state
+      state,
+      fields
     }),
     skipTo: null
   };
 };
 
-// src/boxes/riff/parse-box.ts
-var continueAfterRiffBoxResult = ({
-  result,
-  structure,
-  iterator,
-  maxOffset,
-  state: options
-}) => {
-  if (result.type === "incomplete") {
-    return Promise.resolve({
-      status: "incomplete",
-      async continueParsing() {
-        return Promise.resolve(continueAfterRiffBoxResult({
-          result: await result.continueParsing(),
-          structure,
-          iterator,
-          maxOffset,
-          state: options
-        }));
-      },
-      segments: structure,
-      skipTo: null
-    });
-  }
-  if (result.type === "complete" && result.box) {
-    structure.boxes.push(result.box);
-  }
-  return parseRiffBody({ iterator, maxOffset, state: options, structure });
-};
+// src/boxes/riff/parse-riff-body.ts
 var parseRiffBody = async ({
   iterator,
   structure,
   maxOffset,
-  state
+  state,
+  fields
 }) => {
-  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() < maxOffset) {
+  while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() < maxOffset && !hasAllInfo({ fields, state })) {
     const result = await expectRiffBox({
       iterator,
       state,
-      structure
+      structure,
+      fields
     });
     if (result.type === "complete" && result.skipTo !== null) {
       return {
@@ -8790,7 +9521,8 @@ var parseRiffBody = async ({
             maxOffset,
             state,
             result,
-            structure
+            structure,
+            fields
           }));
         }
       };
@@ -8804,7 +9536,8 @@ var parseRiffBody = async ({
             maxOffset,
             state,
             result: await result.continueParsing(),
-            structure
+            structure,
+            fields
           }));
         },
         skipTo: null
@@ -8859,6 +9592,8 @@ var parseRiffBody = async ({
     status: "done"
   };
 };
+
+// src/boxes/riff/parse-box.ts
 var parseRiff = ({
   iterator,
   state,
@@ -8888,7 +9623,8 @@ var parseRiff = ({
     iterator,
     maxOffset: Infinity,
     state,
-    structure
+    structure,
+    fields
   });
 };
 
@@ -9605,57 +10341,46 @@ var parseTransportStream = async ({
       structure
     });
     return Promise.resolve({
-      status: "done",
-      segments: structure
+      status: "done"
     });
   }
-  while (true) {
-    if (hasAllInfo({
-      fields,
-      state
-    })) {
-      break;
-    }
-    if (iterator.bytesRemaining() < 188) {
-      return Promise.resolve({
-        status: "incomplete",
-        segments: structure,
-        skipTo: null,
-        continueParsing: () => {
-          return parseTransportStream({
-            iterator,
-            state,
-            streamBuffers,
-            fields,
-            nextPesHeaderStore
-          });
-        }
-      });
-    }
-    const packet = await parsePacket({
+  const continueParsing = () => {
+    return parseTransportStream({
       iterator,
-      structure,
+      state,
       streamBuffers,
-      parserState: state,
+      fields,
       nextPesHeaderStore
     });
-    if (packet) {
-      structure.boxes.push(packet);
-      break;
-    }
+  };
+  if (hasAllInfo({
+    fields,
+    state
+  })) {
+    return Promise.resolve({
+      status: "done"
+    });
+  }
+  if (iterator.bytesRemaining() < 188) {
+    return Promise.resolve({
+      status: "incomplete",
+      continueParsing,
+      skipTo: null
+    });
+  }
+  const packet = await parsePacket({
+    iterator,
+    structure,
+    streamBuffers,
+    parserState: state,
+    nextPesHeaderStore
+  });
+  if (packet) {
+    structure.boxes.push(packet);
   }
   return Promise.resolve({
-    segments: structure,
     status: "incomplete",
-    continueParsing() {
-      return parseTransportStream({
-        iterator,
-        state,
-        streamBuffers,
-        fields,
-        nextPesHeaderStore
-      });
-    },
+    continueParsing,
     skipTo: null
   });
 };
@@ -9733,7 +10458,6 @@ var parseVideo = ({
       allowIncompleteBoxes: true,
       initialBoxes,
       state,
-      continueMdat: false,
       signal,
       logLevel,
       fields
@@ -9762,13 +10486,12 @@ var parseVideo = ({
     });
   }
   if (fileType.type === "mp3") {
-    return Promise.reject(new IsAnUnsupportedAudioTypeError({
-      message: "MP3 files are not yet supported",
-      mimeType,
-      sizeInBytes: contentLength,
-      fileName: name,
-      audioType: "mp3"
-    }));
+    const structure = {
+      boxes: [],
+      type: "mp3"
+    };
+    state.structure.setStructure(structure);
+    return parseMp3({ iterator, structure, state });
   }
   if (fileType.type === "wav") {
     return Promise.reject(new IsAnUnsupportedAudioTypeError({
@@ -9825,6 +10548,53 @@ var parseVideo = ({
   return Promise.reject(new Error("Unknown video format " + fileType));
 };
 
+// src/throttled-progress.ts
+var throttledStateUpdate = ({
+  updateFn,
+  everyMilliseconds,
+  signal
+}) => {
+  let currentState = {
+    bytes: 0,
+    percentage: null,
+    totalBytes: null
+  };
+  if (!updateFn) {
+    return {
+      get: () => currentState,
+      update: null,
+      stopAndGetLastProgress: () => {
+      }
+    };
+  }
+  let lastUpdated = null;
+  const callUpdateIfChanged = () => {
+    if (currentState === lastUpdated) {
+      return;
+    }
+    updateFn(currentState);
+    lastUpdated = currentState;
+  };
+  const interval = setInterval(() => {
+    callUpdateIfChanged();
+  }, everyMilliseconds);
+  const onAbort = () => {
+    clearInterval(interval);
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  return {
+    get: () => currentState,
+    update: (fn) => {
+      currentState = fn(currentState);
+    },
+    stopAndGetLastProgress: () => {
+      clearInterval(interval);
+      signal?.removeEventListener("abort", onAbort);
+      return currentState;
+    }
+  };
+};
+
 // src/parse-media.ts
 var parseMedia = async function({
   src,
@@ -9834,10 +10604,10 @@ var parseMedia = async function({
   onVideoTrack,
   signal,
   logLevel = "info",
-  onParseProgress,
+  onParseProgress: onParseProgressDoNotCallDirectly,
+  progressIntervalInMs,
   ...more
 }) {
-  let iterator = null;
   let parseResult = null;
   const fieldsInReturnValue = _fieldsInReturnValue ?? {};
   const fields = getFieldsFromCallback({
@@ -9851,6 +10621,7 @@ var parseMedia = async function({
     contentType,
     supportsContentRange: readerSupportsContentRange
   } = await readerInterface.read(src, null, signal);
+  const iterator = getArrayBufferIterator(new Uint8Array([]), contentLength ?? 1e9);
   const supportsContentRange = readerSupportsContentRange && !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DISABLE_CONTENT_RANGE === "true");
   const state = makeParserState({
     hasAudioTrackHandlers: Boolean(onAudioTrack),
@@ -9860,11 +10631,18 @@ var parseMedia = async function({
     fields,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
-    supportsContentRange
+    supportsContentRange,
+    contentLength
   });
   let currentReader = reader;
   const returnValue = {};
   const moreFields = more;
+  const throttledState = throttledStateUpdate({
+    updateFn: onParseProgressDoNotCallDirectly ?? null,
+    everyMilliseconds: progressIntervalInMs ?? 100,
+    signal,
+    totalBytes: contentLength
+  });
   const triggerInfoEmit = () => {
     const availableInfo = getAvailableInfo({
       fieldsToFetch: fields,
@@ -9882,38 +10660,44 @@ var parseMedia = async function({
       mimeType: contentType
     });
   };
-  triggerInfoEmit();
-  while (parseResult === null || parseResult.status === "incomplete") {
-    while (true) {
-      if (signal?.aborted) {
-        throw new Error("Aborted");
+  const checkIfDone = () => {
+    if (hasAllInfo({
+      fields,
+      state
+    })) {
+      Log.verbose(logLevel, "Got all info, skipping to the end.");
+      if (contentLength !== null) {
+        state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
       }
+      return true;
+    }
+    return false;
+  };
+  triggerInfoEmit();
+  let didProgress = false;
+  while (!checkIfDone() && (parseResult === null || parseResult.status === "incomplete")) {
+    if (signal?.aborted) {
+      throw new Error("Aborted");
+    }
+    const offsetBefore = iterator.counter.getOffset();
+    const fetchMoreData = async () => {
       const result = await currentReader.reader.read();
-      if (iterator) {
-        if (!result.done) {
-          iterator.addData(result.value);
-        }
-      } else {
-        if (result.done) {
-          throw new Error("Unexpectedly reached EOF");
-        }
-        iterator = getArrayBufferIterator(result.value, contentLength ?? 1e9);
-      }
-      if (iterator.bytesRemaining() >= 0) {
-        break;
-      }
-      if (result.done) {
-        break;
+      if (result.value) {
+        iterator.addData(result.value);
       }
+    };
+    while (iterator.bytesRemaining() < 0) {
+      await fetchMoreData();
     }
-    if (!iterator) {
-      throw new Error("Unexpected null");
+    const hasBigBuffer = iterator.bytesRemaining() > 1e5;
+    if (!didProgress || !hasBigBuffer) {
+      await fetchMoreData();
     }
-    await onParseProgress?.({
+    throttledState.update?.(() => ({
       bytes: iterator.counter.getOffset(),
       percentage: contentLength ? iterator.counter.getOffset() / contentLength : null,
       totalBytes: contentLength
-    });
+    }));
     triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
       Log.trace(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
@@ -9933,16 +10717,6 @@ var parseMedia = async function({
     if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
       state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
     }
-    if (hasAllInfo({
-      fields,
-      state
-    })) {
-      Log.verbose(logLevel, "Got all info, skipping to the end.");
-      if (contentLength !== null) {
-        state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
-      }
-      break;
-    }
     if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
       if (!supportsContentRange) {
         throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
@@ -9957,16 +10731,16 @@ var parseMedia = async function({
       currentReader = newReader;
       iterator.skipTo(parseResult.skipTo, true);
     }
+    didProgress = iterator.counter.getOffset() > offsetBefore;
   }
   Log.verbose(logLevel, "Finished parsing file");
-  const hasInfo = Object.keys(fields).reduce((acc, key) => {
-    if (fields?.[key]) {
-      acc[key] = true;
-    }
-    return acc;
-  }, {});
   emitAvailableInfo({
-    hasInfo,
+    hasInfo: Object.keys(fields).reduce((acc, key) => {
+      if (fields?.[key]) {
+        acc[key] = true;
+      }
+      return acc;
+    }, {}),
     callbacks: moreFields,
     fieldsInReturnValue,
     parseResult,
@@ -9982,7 +10756,7 @@ var parseMedia = async function({
   return returnValue;
 };
 // src/version.ts
-var VERSION = "4.0.248";
+var VERSION = "4.0.249";
 
 // src/index.ts
 var MediaParserInternals = {