@remotion/media-parser 4.0.240 → 4.0.242

package/dist/esm/index.mjs

@@ -83,6 +83,7 @@ var fetchReader = {
         }
       },
       contentLength,
+      contentType: res.headers.get("content-type"),
       name: name ?? fallbackName,
       supportsContentRange
     };
@@ -1366,7 +1367,7 @@ var createIsoBaseMediaFtyp = ({
 };
 
 // src/version.ts
-var VERSION = "4.0.240";
+var VERSION = "4.0.242";
 
 // src/create/iso-base-media/create-ilst.ts
 var createIlst = (items) => {
@@ -3529,6 +3530,120 @@ var createWav = async ({
   };
 };
 
+// src/errors.ts
+class IsAGifError extends Error {
+  mimeType;
+  sizeInBytes;
+  fileName;
+  constructor({
+    message,
+    mimeType,
+    sizeInBytes,
+    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/boxes/iso-base-media/traversal.ts
 var getMoovBox = (segments) => {
   const moovBox = segments.find((s) => s.type === "moov-box");
@@ -4012,19 +4127,22 @@ var getFps = (segments) => {
   }
   throw new Error("Cannot get fps, not implemented");
 };
-var hasFps = (boxes) => {
+var hasFpsSuitedForSlowFps = (boxes) => {
   try {
-    if (boxes.type === "matroska") {
-      return true;
-    }
-    if (boxes.type === "transport-stream") {
-      return true;
-    }
     return getFps(boxes) !== null;
   } catch {
     return false;
   }
 };
+var hasFps = (boxes) => {
+  if (boxes.type === "matroska") {
+    return true;
+  }
+  if (boxes.type === "transport-stream") {
+    return true;
+  }
+  return hasFpsSuitedForSlowFps(boxes);
+};
 
 // src/get-audio-codec.ts
 var getAudioCodec = (boxes, parserState) => {
@@ -4358,6 +4476,234 @@ var getPrimariesFromIndex = (index) => {
   return index === 1 ? "bt709" : index === 5 ? "bt470bg" : index === 6 ? "smpte170m" : index === 9 ? "bt2020" : null;
 };
 
+// src/file-types/detect-file-type.ts
+var matchesPattern = (pattern) => {
+  return (data) => {
+    return pattern.every((value, index) => data[index] === value);
+  };
+};
+var isRiffAvi2 = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  return new TextDecoder().decode(fileType) === "AVI ";
+};
+var isRiffWave = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  return new TextDecoder().decode(fileType) === "WAVE";
+};
+var isWebm = (data) => {
+  return matchesPattern(webmPattern)(data.subarray(0, 4));
+};
+var isIsoBaseMedia = (data) => {
+  const isoBaseMediaMp4Pattern = new TextEncoder().encode("ftyp");
+  return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+var isTransportStream = (data) => {
+  return data[0] === 71 && data[188] === 71;
+};
+var isMp3 = (data) => {
+  const mpegPattern = new Uint8Array([255, 243, 228, 100]);
+  const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+  const subarray = data.subarray(0, 4);
+  return matchesPattern(mpegPattern)(subarray) || matchesPattern(id3Pattern)(subarray);
+};
+var isGif = (data) => {
+  const gifPattern = new Uint8Array([71, 73, 70, 56]);
+  return matchesPattern(gifPattern)(data.subarray(0, 4));
+};
+var isAac = (data) => {
+  const aacPattern = new Uint8Array([255, 241]);
+  return matchesPattern(aacPattern)(data.subarray(0, 2));
+};
+
+// src/file-types/bmp.ts
+function getBmpDimensions(bmpData) {
+  if (bmpData.length < 26) {
+    return null;
+  }
+  const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+  return {
+    width: view.getUint32(18, true),
+    height: Math.abs(view.getInt32(22, true))
+  };
+}
+var isBmp = (data) => {
+  const bmpPattern = new Uint8Array([66, 77]);
+  if (matchesPattern(bmpPattern)(data.subarray(0, 2))) {
+    const bmp = getBmpDimensions(data);
+    return { dimensions: bmp, type: "bmp" };
+  }
+  return null;
+};
+
+// src/file-types/jpeg.ts
+function getJpegDimensions(data) {
+  let offset = 0;
+  function readUint16BE(o) {
+    return data[o] << 8 | data[o + 1];
+  }
+  if (readUint16BE(offset) !== 65496) {
+    return null;
+  }
+  offset += 2;
+  while (offset < data.length) {
+    if (data[offset] === 255) {
+      const marker = data[offset + 1];
+      if (marker === 192 || marker === 194) {
+        const height = readUint16BE(offset + 5);
+        const width = readUint16BE(offset + 7);
+        return { width, height };
+      }
+      const length = readUint16BE(offset + 2);
+      offset += length + 2;
+    } else {
+      offset++;
+    }
+  }
+  return null;
+}
+var isJpeg = (data) => {
+  const jpegPattern = new Uint8Array([255, 216]);
+  const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+  if (!jpeg) {
+    return null;
+  }
+  const dim = getJpegDimensions(data);
+  return { dimensions: dim, type: "jpeg" };
+};
+
+// src/file-types/pdf.ts
+var isPdf = (data) => {
+  if (data.length < 4) {
+    return null;
+  }
+  const pdfPattern = new Uint8Array([37, 80, 68, 70]);
+  return matchesPattern(pdfPattern)(data.subarray(0, 4)) ? { type: "pdf" } : null;
+};
+
+// src/file-types/png.ts
+function getPngDimensions(pngData) {
+  if (pngData.length < 24) {
+    return null;
+  }
+  const view = new DataView(pngData.buffer, pngData.byteOffset);
+  const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+  for (let i = 0;i < 8; i++) {
+    if (pngData[i] !== pngSignature[i]) {
+      return null;
+    }
+  }
+  return {
+    width: view.getUint32(16, false),
+    height: view.getUint32(20, false)
+  };
+}
+var isPng = (data) => {
+  const pngPattern = new Uint8Array([137, 80, 78, 71]);
+  if (matchesPattern(pngPattern)(data.subarray(0, 4))) {
+    const png = getPngDimensions(data);
+    return { dimensions: png, type: "png" };
+  }
+  return null;
+};
+
+// src/file-types/webp.ts
+function getWebPDimensions(bytes) {
+  if (bytes.length < 30) {
+    return null;
+  }
+  if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70 || bytes[8] !== 87 || bytes[9] !== 69 || bytes[10] !== 66 || bytes[11] !== 80) {
+    return null;
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56) {
+    if (bytes[15] === 32) {
+      return {
+        width: bytes[26] | bytes[27] << 8 & 16383,
+        height: bytes[28] | bytes[29] << 8 & 16383
+      };
+    }
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 76) {
+    return {
+      width: 1 + (bytes[21] | (bytes[22] & 63) << 8),
+      height: 1 + ((bytes[22] & 192) >> 6 | bytes[23] << 2 | (bytes[24] & 15) << 10)
+    };
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 88) {
+    return {
+      width: 1 + (bytes[24] | bytes[25] << 8 | bytes[26] << 16),
+      height: 1 + (bytes[27] | bytes[28] << 8 | bytes[29] << 16)
+    };
+  }
+  return null;
+}
+var isWebp = (data) => {
+  const webpPattern = new Uint8Array([82, 73, 70, 70]);
+  if (matchesPattern(webpPattern)(data.subarray(0, 4))) {
+    return {
+      type: "webp",
+      dimensions: getWebPDimensions(data)
+    };
+  }
+  return null;
+};
+
+// src/file-types/index.ts
+var detectFileType = (data) => {
+  if (isRiffWave(data)) {
+    return { type: "wav" };
+  }
+  if (isRiffAvi2(data)) {
+    return { type: "riff" };
+  }
+  if (isAac(data)) {
+    return { type: "aac" };
+  }
+  const webp = isWebp(data);
+  if (webp) {
+    return webp;
+  }
+  if (isWebm(data)) {
+    return { type: "webm" };
+  }
+  if (isIsoBaseMedia(data)) {
+    return { type: "iso-base-media" };
+  }
+  if (isTransportStream(data)) {
+    return { type: "transport-stream" };
+  }
+  if (isMp3(data)) {
+    return { type: "mp3" };
+  }
+  if (isGif(data)) {
+    return { type: "gif" };
+  }
+  const png = isPng(data);
+  if (png) {
+    return png;
+  }
+  const pdf = isPdf(data);
+  if (pdf) {
+    return pdf;
+  }
+  const bmp = isBmp(data);
+  if (bmp) {
+    return bmp;
+  }
+  const jpeg = isJpeg(data);
+  if (jpeg) {
+    return jpeg;
+  }
+  return { type: "unknown" };
+};
+
 // src/buffer-iterator.ts
 class OffsetCounter {
   #offset;
@@ -4394,14 +4740,6 @@ class OffsetCounter {
     this.#offset -= amount;
   }
 }
-var isoBaseMediaMp4Pattern = new TextEncoder().encode("ftyp");
-var mpegPattern = new Uint8Array([255, 243, 228, 100]);
-var riffPattern = new Uint8Array([82, 73, 70, 70]);
-var matchesPattern = (pattern) => {
-  return (data) => {
-    return pattern.every((value, index) => data[index] === value);
-  };
-};
 var makeOffsetCounter = () => {
   return new OffsetCounter(0);
 };
@@ -4542,21 +4880,6 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   const bytesRemaining = () => {
     return data.byteLength - counter.getDiscardedOffset();
   };
-  const isIsoBaseMedia = () => {
-    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
-  };
-  const isRiff = () => {
-    return matchesPattern(riffPattern)(data.subarray(0, 4));
-  };
-  const isWebm = () => {
-    return matchesPattern(webmPattern)(data.subarray(0, 4));
-  };
-  const isMp3 = () => {
-    return matchesPattern(mpegPattern)(data.subarray(0, 4));
-  };
-  const isTransportStream = () => {
-    return data[0] === 71;
-  };
   const removeBytesRead = () => {
     if (!discardAllowed) {
       return;
@@ -4671,10 +4994,8 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     getBits,
     byteLength,
     bytesRemaining,
-    isIsoBaseMedia,
     leb128,
     removeBytesRead,
-    isWebm,
     discard,
     getEightByteNumber,
     getFourByteNumber,
@@ -4683,7 +5004,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       const atom = getSlice(4);
       return new TextDecoder().decode(atom);
     },
-    isRiff,
+    detectFileType: () => {
+      return detectFileType(data);
+    },
     getPaddedFourByteNumber,
     getMatroskaSegmentId: () => {
       if (bytesRemaining() === 0) {
@@ -4836,11 +5159,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     getInt32Le,
     getInt32,
     destroy,
-    isMp3,
     disallowDiscard,
     allowDiscard,
     startBox,
-    isTransportStream,
     readExpGolomb
   };
 };
@@ -5136,14 +5457,19 @@ var makeBaseMediaTrack = (trakBox) => {
   return track;
 };
 
-// src/boxes/avc/codec-private.ts
-var getAvccBoxContent = (avc1Profile) => {
+// 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")}`;
+};
+
+// src/boxes/avc/create-sps-pps-data.ts
+var createSpsPpsData = (avc1Profile) => {
   return combineUint8Arrays([
     new Uint8Array([
       1,
-      avc1Profile.sps.spsData.level,
-      avc1Profile.sps.spsData.compatibility,
       avc1Profile.sps.spsData.profile,
+      avc1Profile.sps.spsData.compatibility,
+      avc1Profile.sps.spsData.level,
       255,
       225
     ]),
@@ -5155,11 +5481,6 @@ var getAvccBoxContent = (avc1Profile) => {
   ]);
 };
 
-// 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")}`;
-};
-
 // src/add-avc-profile-to-track.ts
 var addAvcProfileToTrack = (track, avc1Profile) => {
   if (avc1Profile === null) {
@@ -5168,7 +5489,7 @@ var addAvcProfileToTrack = (track, avc1Profile) => {
   return {
     ...track,
     codec: getCodecStringFromSpsAndPps(avc1Profile.sps),
-    codecPrivate: getAvccBoxContent(avc1Profile)
+    codecPrivate: createSpsPpsData(avc1Profile)
   };
 };
 
@@ -5257,7 +5578,7 @@ var getTracksFromAvi = (structure, state) => {
       continue;
     }
     if (strf.type === "strf-box-video") {
-      videoTracks.push(addAvcProfileToTrack(makeAviVideoTrack({ strh, strf, index: i }), state.getAvcProfile()));
+      videoTracks.push(addAvcProfileToTrack(makeAviVideoTrack({ strh, strf, index: i }), state.riff.getAvcProfile()));
     } else if (strh.fccType === "auds") {
       audioTracks.push(makeAviAudioTrack({ strf, index: i }));
     } else {
@@ -5309,7 +5630,7 @@ var getStreamForId = (structure, packetIdentifier) => {
 // src/boxes/transport-stream/get-tracks.ts
 var getTracksFromTransportStream = (structure, parserState) => {
   const programMapTable = findProgramMapTableOrThrow(structure);
-  const parserTracks = parserState.tracks.getTracks();
+  const parserTracks = parserState.callbacks.tracks.getTracks();
   const mapped = programMapTable.streams.map((stream) => {
     return parserTracks.find((track) => track.trackId === stream.pid);
   }).filter(truthy);
@@ -5711,6 +6032,15 @@ var getNumberOfTracks2 = (moovBox) => {
   }
   return mvHdBox.nextTrackId - 1;
 };
+var isoBaseMediaHasTracks = (structure) => {
+  const moovBox = getMoovBox(structure.boxes);
+  if (!moovBox) {
+    return false;
+  }
+  const numberOfTracks = getNumberOfTracks2(moovBox);
+  const tracks2 = getTraks(moovBox);
+  return tracks2.length === numberOfTracks;
+};
 var hasTracks = (structure, state) => {
   if (structure.type === "matroska") {
     const mainSegment = getMainSegment(structure.boxes);
@@ -5720,13 +6050,7 @@ var hasTracks = (structure, state) => {
     return getTracksSegment(mainSegment) !== null;
   }
   if (structure.type === "iso-base-media") {
-    const moovBox = getMoovBox(structure.boxes);
-    if (!moovBox) {
-      return false;
-    }
-    const numberOfTracks = getNumberOfTracks2(moovBox);
-    const tracks2 = getTraks(moovBox);
-    return tracks2.length === numberOfTracks;
+    return isoBaseMediaHasTracks(structure);
   }
   if (structure.type === "riff") {
     return hasAllTracksFromAvi(structure, state);
@@ -5744,7 +6068,7 @@ var getTracksFromMa = (segments, state) => {
   if (!mainSegment) {
     throw new Error("No main segment found");
   }
-  const matroskaTracks = getTracksFromMatroska(mainSegment, state.getTimescale());
+  const matroskaTracks = getTracksFromMatroska(mainSegment, state.webm.getTimescale());
   for (const track of matroskaTracks) {
     if (track.type === "video") {
       videoTracks.push(track);
@@ -6155,6 +6479,13 @@ var getDuration = (structure, parserState) => {
 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) => {
@@ -6168,6 +6499,43 @@ 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 {
+        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 hasTracks(structure, parserState);
+  }
+  return true;
+};
+
 // src/get-location.ts
 function parseLocation(locationString) {
   const locationPattern = /^([+-]\d{2}\.?\d{0,10})([+-]\d{3}\.?\d{0,10})([+-]\d+(\.\d+)?)?\/$/;
@@ -6205,145 +6573,282 @@ var getLocation = (structure) => {
 var emitAvailableInfo = ({
   hasInfo,
   parseResult,
-  moreFields,
+  callbacks,
   state,
   returnValue,
   contentLength,
-  name
+  name,
+  mimeType,
+  fieldsInReturnValue
 }) => {
   const keys = Object.keys(hasInfo);
+  const segments = state.structure.getStructureOrNull();
+  const { emittedFields } = state;
   for (const key of keys) {
     if (key === "structure") {
-      if (parseResult && hasInfo.structure && returnValue.structure === undefined) {
-        moreFields.onStructure?.(parseResult.segments);
-        returnValue.structure = parseResult.segments;
+      if (parseResult && hasInfo.structure && !emittedFields.structure && segments) {
+        callbacks.onStructure?.(segments);
+        if (fieldsInReturnValue.structure) {
+          returnValue.structure = segments;
+        }
+        emittedFields.structure = true;
       }
       continue;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined && parseResult) {
-        const durationInSeconds = getDuration(parseResult.segments, state);
-        moreFields.onDurationInSeconds?.(durationInSeconds);
-        returnValue.durationInSeconds = durationInSeconds;
+      if (hasInfo.durationInSeconds && parseResult && segments) {
+        if (!emittedFields.durationInSeconds) {
+          const durationInSeconds = getDuration(segments, state);
+          callbacks.onDurationInSeconds?.(durationInSeconds);
+          if (fieldsInReturnValue.durationInSeconds) {
+            returnValue.durationInSeconds = durationInSeconds;
+          }
+          emittedFields.durationInSeconds = true;
+        }
+        if (!emittedFields.slowDurationInSeconds) {
+          const durationInSeconds = getDuration(segments, state);
+          if (durationInSeconds !== null) {
+            callbacks.onSlowDurationInSeconds?.(durationInSeconds);
+            if (fieldsInReturnValue.slowDurationInSeconds) {
+              returnValue.slowDurationInSeconds = durationInSeconds;
+            }
+            emittedFields.slowDurationInSeconds = true;
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "slowDurationInSeconds") {
+      if (hasInfo.slowDurationInSeconds && !emittedFields.slowDurationInSeconds && parseResult && segments) {
+        const slowDurationInSeconds = state.slowDurationAndFps.getSlowDurationInSeconds();
+        callbacks.onSlowDurationInSeconds?.(slowDurationInSeconds);
+        if (fieldsInReturnValue.slowDurationInSeconds) {
+          returnValue.slowDurationInSeconds = slowDurationInSeconds;
+        }
+        emittedFields.slowDurationInSeconds = true;
+      }
+      continue;
+    }
+    if (key === "fps") {
+      if (hasInfo.fps && parseResult && segments) {
+        if (!emittedFields.fps) {
+          const fps = getFps(segments);
+          callbacks.onFps?.(fps);
+          if (fieldsInReturnValue.fps) {
+            returnValue.fps = fps;
+          }
+          emittedFields.fps = true;
+        }
+        if (!emittedFields.slowFps) {
+          const fps = getFps(segments);
+          if (fps) {
+            callbacks.onSlowFps?.(fps);
+            if (fieldsInReturnValue.slowFps) {
+              returnValue.slowFps = fps;
+            }
+            emittedFields.slowFps = true;
+          }
+        }
+      }
+      continue;
+    }
+    if (key === "slowFps") {
+      if (hasInfo.slowFps && !emittedFields.slowFps && parseResult && segments) {
+        const slowFps = state.slowDurationAndFps.getFps();
+        callbacks.onSlowFps?.(slowFps);
+        if (fieldsInReturnValue.slowFps) {
+          returnValue.slowFps = slowFps;
+        }
+        emittedFields.slowFps = true;
       }
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && returnValue.dimensions === undefined && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.dimensions && !emittedFields.dimensions && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
           width: dimensionsQueried.width
         };
-        moreFields.onDimensions?.(dimensions);
-        returnValue.dimensions = dimensions;
+        callbacks.onDimensions?.(dimensions);
+        if (fieldsInReturnValue.dimensions) {
+          returnValue.dimensions = dimensions;
+        }
+        emittedFields.dimensions = true;
       }
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.unrotatedDimensions && !emittedFields.unrotatedDimensions && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
           width: dimensionsQueried.unrotatedWidth
         };
-        moreFields.onUnrotatedDimensions?.(unrotatedDimensions);
-        returnValue.unrotatedDimensions = unrotatedDimensions;
+        callbacks.onUnrotatedDimensions?.(unrotatedDimensions);
+        if (fieldsInReturnValue.unrotatedDimensions) {
+          returnValue.unrotatedDimensions = unrotatedDimensions;
+        }
+        emittedFields.unrotatedDimensions = true;
       }
       continue;
     }
     if (key === "rotation") {
-      if (returnValue.rotation === undefined && hasInfo.rotation && parseResult) {
-        const dimensionsQueried = getDimensions(parseResult.segments, state);
+      if (hasInfo.rotation && !emittedFields.rotation && parseResult && segments) {
+        const dimensionsQueried = getDimensions(segments, state);
         const { rotation } = dimensionsQueried;
-        moreFields.onRotation?.(rotation);
-        returnValue.rotation = rotation;
-      }
-      continue;
-    }
-    if (key === "fps") {
-      if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
-        const fps = getFps(parseResult.segments);
-        moreFields.onFps?.(fps);
-        returnValue.fps = fps;
+        callbacks.onRotation?.(rotation);
+        if (fieldsInReturnValue.rotation) {
+          returnValue.rotation = rotation;
+        }
+        emittedFields.rotation = true;
       }
       continue;
     }
     if (key === "videoCodec") {
-      if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
-        const videoCodec = getVideoCodec(parseResult.segments, state);
-        moreFields.onVideoCodec?.(videoCodec);
-        returnValue.videoCodec = videoCodec;
+      if (!emittedFields.videoCodec && hasInfo.videoCodec && parseResult && segments) {
+        const videoCodec = getVideoCodec(segments, state);
+        callbacks.onVideoCodec?.(videoCodec);
+        if (fieldsInReturnValue.videoCodec) {
+          returnValue.videoCodec = videoCodec;
+        }
+        emittedFields.videoCodec = true;
       }
       continue;
     }
     if (key === "audioCodec") {
-      if (returnValue.audioCodec === undefined && hasInfo.audioCodec && parseResult) {
-        const audioCodec = getAudioCodec(parseResult.segments, state);
-        moreFields.onAudioCodec?.(audioCodec);
-        returnValue.audioCodec = audioCodec;
+      if (!emittedFields.audioCodec && hasInfo.audioCodec && parseResult && segments) {
+        const audioCodec = getAudioCodec(segments, state);
+        callbacks.onAudioCodec?.(audioCodec);
+        if (fieldsInReturnValue.audioCodec) {
+          returnValue.audioCodec = audioCodec;
+        }
+        emittedFields.audioCodec = true;
       }
       continue;
     }
     if (key === "tracks") {
-      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined && parseResult) {
-        const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
-        moreFields.onTracks?.({ videoTracks, audioTracks });
-        returnValue.videoTracks = videoTracks;
-        returnValue.audioTracks = audioTracks;
+      if (!emittedFields.tracks && hasInfo.tracks && parseResult && segments) {
+        const { videoTracks, audioTracks } = getTracks(segments, state);
+        callbacks.onTracks?.({ videoTracks, audioTracks });
+        if (fieldsInReturnValue.tracks) {
+          returnValue.tracks = { videoTracks, audioTracks };
+        }
+        emittedFields.tracks = true;
       }
       continue;
     }
     if (key === "internalStats") {
       if (hasInfo.internalStats) {
         const internalStats = state.getInternalStats();
-        returnValue.internalStats = internalStats;
+        if (fieldsInReturnValue.internalStats) {
+          returnValue.internalStats = internalStats;
+        }
+        emittedFields.internalStats = true;
       }
       continue;
     }
     if (key === "size") {
-      if (returnValue.size === undefined && hasInfo.size) {
-        moreFields.onSize?.(contentLength);
-        returnValue.size = contentLength;
+      if (!emittedFields.size && hasInfo.size) {
+        callbacks.onSize?.(contentLength);
+        if (fieldsInReturnValue.size) {
+          returnValue.size = contentLength;
+        }
+        emittedFields.size = true;
+      }
+      continue;
+    }
+    if (key === "mimeType") {
+      if (!emittedFields.mimeType && hasInfo.mimeType) {
+        callbacks.onMimeType?.(mimeType);
+        if (fieldsInReturnValue.mimeType) {
+          returnValue.mimeType = mimeType;
+        }
+        emittedFields.mimeType = true;
       }
       continue;
     }
     if (key === "name") {
-      if (returnValue.name === undefined && hasInfo.name) {
-        moreFields.onName?.(name);
-        returnValue.name = name;
+      if (!emittedFields.name && hasInfo.name) {
+        callbacks.onName?.(name);
+        if (fieldsInReturnValue.name) {
+          returnValue.name = name;
+        }
+        emittedFields.name = true;
       }
       continue;
     }
     if (key === "isHdr") {
-      if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
-        const isHdr = getIsHdr(parseResult.segments, state);
-        moreFields.onIsHdr?.(isHdr);
-        returnValue.isHdr = isHdr;
+      if (!returnValue.isHdr && hasInfo.isHdr && parseResult && segments) {
+        const isHdr = getIsHdr(segments, state);
+        callbacks.onIsHdr?.(isHdr);
+        if (fieldsInReturnValue.isHdr) {
+          returnValue.isHdr = isHdr;
+        }
+        emittedFields.isHdr = true;
       }
       continue;
     }
     if (key === "container") {
-      if (returnValue.container === undefined && hasInfo.container && parseResult) {
-        const container = getContainer(parseResult.segments);
-        moreFields.onContainer?.(container);
-        returnValue.container = container;
+      if (!returnValue.container && hasInfo.container && parseResult && segments) {
+        const container = getContainer(segments);
+        callbacks.onContainer?.(container);
+        if (fieldsInReturnValue.container) {
+          returnValue.container = container;
+        }
+        emittedFields.container = true;
       }
       continue;
     }
     if (key === "metadata") {
-      if (returnValue.metadata === undefined && hasInfo.metadata && parseResult) {
-        const metadata = getMetadata(parseResult.segments);
-        moreFields.onMetadata?.(metadata);
-        returnValue.metadata = metadata;
+      if (!emittedFields.metadata && hasInfo.metadata && parseResult && segments) {
+        const metadata = getMetadata(segments);
+        callbacks.onMetadata?.(metadata);
+        if (fieldsInReturnValue.metadata) {
+          returnValue.metadata = metadata;
+        }
+        emittedFields.metadata = true;
       }
       continue;
     }
     if (key === "location") {
-      if (returnValue.location === undefined && hasInfo.location && parseResult) {
-        const location = getLocation(parseResult.segments);
-        moreFields.onLocation?.(location);
-        returnValue.location = location;
+      if (!emittedFields.location && hasInfo.location && parseResult && segments) {
+        const location = getLocation(segments);
+        callbacks.onLocation?.(location);
+        if (fieldsInReturnValue.location) {
+          returnValue.location = location;
+        }
+        emittedFields.location = true;
+      }
+      continue;
+    }
+    if (key === "slowKeyframes") {
+      if (!emittedFields.slowKeyframes && hasInfo.slowKeyframes && parseResult) {
+        callbacks.onSlowKeyframes?.(state.keyframes.getKeyframes());
+        if (fieldsInReturnValue.slowKeyframes) {
+          returnValue.slowKeyframes = state.keyframes.getKeyframes();
+        }
+        emittedFields.slowKeyframes = true;
+      }
+      continue;
+    }
+    if (key === "slowNumberOfFrames") {
+      if (!emittedFields.slowNumberOfFrames && hasInfo.slowNumberOfFrames && parseResult) {
+        callbacks.onSlowNumberOfFrames?.(state.slowDurationAndFps.getSlowNumberOfFrames());
+        if (fieldsInReturnValue.slowNumberOfFrames) {
+          returnValue.slowNumberOfFrames = state.slowDurationAndFps.getSlowNumberOfFrames();
+        }
+        emittedFields.slowNumberOfFrames = true;
+      }
+      continue;
+    }
+    if (key === "keyframes") {
+      if (!emittedFields.keyframes && hasInfo.keyframes && parseResult) {
+        callbacks.onKeyframes?.(getKeyframes(state.structure.getStructure()));
+        if (fieldsInReturnValue.keyframes) {
+          returnValue.keyframes = getKeyframes(state.structure.getStructure());
+        }
+        emittedFields.keyframes = true;
       }
       continue;
     }
@@ -6351,9 +6856,88 @@ var emitAvailableInfo = ({
   }
 };
 
+// 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),
+    ...fields
+  };
+  return newFields;
+};
+
+// src/may-skip-video-data/need-samples-for-fields.ts
+var needsSamples = {
+  slowDurationInSeconds: true,
+  slowFps: true,
+  slowKeyframes: true,
+  slowNumberOfFrames: true,
+  audioCodec: false,
+  container: false,
+  dimensions: false,
+  durationInSeconds: false,
+  fps: false,
+  internalStats: false,
+  isHdr: false,
+  name: false,
+  rotation: false,
+  size: false,
+  structure: false,
+  tracks: false,
+  unrotatedDimensions: false,
+  videoCodec: false,
+  metadata: false,
+  location: false,
+  mimeType: false,
+  keyframes: false
+};
+var needsToIterateOverSamples = ({
+  fields,
+  emittedFields
+}) => {
+  const keys = Object.keys(fields ?? {});
+  const selectedKeys = keys.filter((k) => fields[k]);
+  return selectedKeys.some((k) => needsSamples[k] && !emittedFields[k]);
+};
+
+// src/may-skip-video-data/may-skip-video-data.ts
+var maySkipVideoData = ({ state }) => {
+  return state.callbacks.tracks.hasAllTracks() && Object.values(state.callbacks.videoSampleCallbacks).length === 0 && Object.values(state.callbacks.audioSampleCallbacks).length === 0 && !needsToIterateOverSamples({
+    emittedFields: state.emittedFields,
+    fields: state.fields
+  });
+};
+
 // src/has-all-info.ts
-var getAvailableInfo = (options, structure, state) => {
-  const keys = Object.entries(options).filter(([, value]) => value);
+var getAvailableInfo = ({
+  fieldsToFetch,
+  state
+}) => {
+  const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
+  const structure = state.structure.getStructureOrNull();
   const infos = keys.map(([_key]) => {
     const key = _key;
     if (key === "structure") {
@@ -6362,12 +6946,18 @@ var getAvailableInfo = (options, structure, state) => {
     if (key === "durationInSeconds") {
       return Boolean(structure && hasDuration(structure, state));
     }
+    if (key === "slowDurationInSeconds") {
+      return Boolean(structure && hasSlowDuration(structure, state));
+    }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
       return Boolean(structure && hasDimensions(structure, state));
     }
     if (key === "fps") {
       return Boolean(structure && hasFps(structure));
     }
+    if (key === "slowFps") {
+      return Boolean(structure && hasFpsSuitedForSlowFps(structure));
+    }
     if (key === "isHdr") {
       return Boolean(structure && hasHdr(structure, state));
     }
@@ -6380,12 +6970,18 @@ var getAvailableInfo = (options, structure, state) => {
     if (key === "tracks") {
       return Boolean(structure && hasTracks(structure, state));
     }
+    if (key === "keyframes") {
+      return Boolean(structure && hasKeyframes(structure, state));
+    }
     if (key === "internalStats") {
       return true;
     }
     if (key === "size") {
       return true;
     }
+    if (key === "mimeType") {
+      return true;
+    }
     if (key === "name") {
       return true;
     }
@@ -6395,6 +6991,12 @@ var getAvailableInfo = (options, structure, state) => {
     if (key === "metadata" || key === "location") {
       return false;
     }
+    if (key === "slowKeyframes") {
+      return false;
+    }
+    if (key === "slowNumberOfFrames") {
+      return false;
+    }
     throw new Error(`Unknown key: ${key}`);
   });
   const entries = [];
@@ -6406,42 +7008,44 @@ var getAvailableInfo = (options, structure, state) => {
 };
 var hasAllInfo = ({
   fields,
-  state,
-  structure
+  state
 }) => {
-  const availableInfo = getAvailableInfo(fields ?? {}, structure, state);
-  return Object.values(availableInfo).every(Boolean) && (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks());
+  const availableInfo = getAvailableInfo({
+    fieldsToFetch: fields ?? {},
+    state
+  });
+  return Object.values(availableInfo).every(Boolean) && (maySkipVideoData({ state }) || state.callbacks.canSkipTracksState.canSkipTracks());
 };
 
 // src/register-track.ts
 var registerTrack = async ({
-  options,
+  state,
   track,
   container
 }) => {
   if (track.type === "video") {
-    options.parserState.tracks.addTrack(track);
-    if (options.onVideoTrack) {
-      const callback = await options.onVideoTrack({ track, container });
-      await options.parserState.registerVideoSampleCallback(track.trackId, callback ?? null);
+    state.callbacks.tracks.addTrack(track);
+    if (state.onVideoTrack) {
+      const callback = await state.onVideoTrack({ track, container });
+      await state.callbacks.registerVideoSampleCallback(track.trackId, callback ?? null);
     }
   }
   if (track.type === "audio") {
-    options.parserState.tracks.addTrack(track);
-    if (options.onAudioTrack) {
-      const callback = await options.onAudioTrack({ track, container });
-      await options.parserState.registerAudioSampleCallback(track.trackId, callback ?? null);
+    state.callbacks.tracks.addTrack(track);
+    if (state.onAudioTrack) {
+      const callback = await state.onAudioTrack({ track, container });
+      await state.callbacks.registerAudioSampleCallback(track.trackId, callback ?? null);
     }
   }
 };
 var registerVideoTrackWhenProfileIsAvailable = ({
-  options,
+  state,
   track,
   container
 }) => {
-  options.parserState.registerOnAvcProfileCallback(async (profile) => {
+  state.riff.registerOnAvcProfileCallback(async (profile) => {
     await registerTrack({
-      options,
+      state,
       track: addAvcProfileToTrack(track, profile),
       container
     });
@@ -6616,7 +7220,9 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale2) => {
     duration: (sample.duration ?? 0) * 1e6 / timescale2,
     data: sample.data,
     trackId: sample.trackId,
-    type: sample.type
+    type: sample.type,
+    offset: sample.offset,
+    timescale: 1e6
   };
 };
 
@@ -6626,14 +7232,14 @@ var parseMdat = async ({
   size,
   fileOffset,
   existingBoxes,
-  options,
+  state,
   signal,
   maySkipSampleProcessing
 }) => {
   const alreadyHas = hasTracks({
     type: "iso-base-media",
     boxes: existingBoxes
-  }, options.parserState);
+  }, state);
   if (!alreadyHas) {
     if (maySkipSampleProcessing) {
       data.discard(size - (data.counter.getOffset() - fileOffset));
@@ -6653,7 +7259,7 @@ var parseMdat = async ({
       fileOffset
     });
   }
-  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, options.parserState);
+  const tracks2 = getTracks({ type: "iso-base-media", boxes: existingBoxes }, state);
   const allTracks = [
     ...tracks2.videoTracks,
     ...tracks2.audioTracks,
@@ -6695,25 +7301,29 @@ var parseMdat = async ({
     const bytes = data.getSlice(samplesWithIndex.samplePosition.size);
     const { cts, dts, duration: duration2 } = samplesWithIndex.samplePosition;
     if (samplesWithIndex.track.type === "audio") {
-      await options.parserState.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
         timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
+        offset: samplesWithIndex.samplePosition.offset,
+        timescale: samplesWithIndex.track.timescale
       }, samplesWithIndex.track.timescale));
     }
     if (samplesWithIndex.track.type === "video") {
-      await options.parserState.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+      await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
         data: bytes,
         timestamp: cts,
         duration: duration2,
         cts,
         dts,
         trackId: samplesWithIndex.track.trackId,
-        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta"
+        type: samplesWithIndex.samplePosition.isKeyframe ? "key" : "delta",
+        offset: samplesWithIndex.samplePosition.offset,
+        timescale: samplesWithIndex.track.timescale
       }, samplesWithIndex.track.timescale));
     }
     const remaining = size - (data.counter.getOffset() - fileOffset);
@@ -6878,17 +7488,18 @@ var parseMoov = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   logLevel,
   fields
 }) => {
+  const boxes = [];
   const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: size - (iterator.counter.getOffset() - offset),
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes: boxes,
+    state,
     continueMdat: false,
     signal,
     logLevel,
@@ -6901,7 +7512,7 @@ var parseMoov = async ({
     offset,
     boxSize: size,
     type: "moov-box",
-    children: children.segments.boxes
+    children: boxes
   };
 };
 
@@ -7234,18 +7845,19 @@ var parseMebx = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   fields
 }) => {
   iterator.discard(6);
   const dataReferenceIndex = iterator.getUint16();
+  const boxes = [];
   const children = await parseIsoBaseMediaBoxes({
     iterator,
     maxBytes: iterator.counter.getOffset() - offset,
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes: boxes,
+    state,
     continueMdat: false,
     signal,
     logLevel: "info",
@@ -7260,7 +7872,7 @@ var parseMebx = async ({
     offset,
     dataReferenceIndex,
     format: "mebx",
-    children: children.segments.boxes
+    children: boxes
   };
 };
 
@@ -7413,7 +8025,7 @@ var audioTags = [
 ];
 var processSample = async ({
   iterator,
-  options,
+  state: options,
   signal,
   logLevel,
   fields
@@ -7453,12 +8065,13 @@ var processSample = async ({
       const packetSize = iterator.getUint16();
       const sampleRate = iterator.getFixedPointUnsigned1616Number();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+      const initialBoxes = [];
       const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
-        initialBoxes: [],
-        options,
+        initialBoxes,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7486,7 +8099,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame: null,
           bitsPerSample: null,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -7501,12 +8114,13 @@ var processSample = async ({
       const bytesPerFrame = iterator.getUint32();
       const bytesPerSample = iterator.getUint32();
       const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+      const initialBoxes = [];
       const children = await parseIsoBaseMediaBoxes({
         iterator,
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
-        initialBoxes: [],
-        options,
+        initialBoxes,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7534,7 +8148,7 @@ var processSample = async ({
           bytesPerPacket,
           bytesPerFrame,
           bitsPerSample: bytesPerSample,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -7558,7 +8172,7 @@ var processSample = async ({
         allowIncompleteBoxes: false,
         maxBytes: bytesRemainingInBox,
         initialBoxes: [],
-        options,
+        state: options,
         continueMdat: false,
         signal,
         logLevel,
@@ -7567,6 +8181,7 @@ var processSample = async ({
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
       }
+      const initialBoxes = [];
       return {
         sample: {
           format: boxFormat,
@@ -7586,7 +8201,7 @@ var processSample = async ({
           bytesPerPacket: null,
           bytesPerFrame,
           bitsPerSample: bitsPerChannel,
-          children: children.segments.boxes
+          children: initialBoxes
         }
       };
     }
@@ -7608,17 +8223,18 @@ var processSample = async ({
     const depth = iterator.getUint16();
     const colorTableId = iterator.getInt16();
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
+    const initialBoxes = [];
     const children = bytesRemainingInBox > 8 ? await parseIsoBaseMediaBoxes({
       iterator,
       allowIncompleteBoxes: false,
       maxBytes: bytesRemainingInBox,
-      initialBoxes: [],
-      options,
+      initialBoxes,
+      state: options,
       continueMdat: false,
       signal,
       logLevel,
       fields
-    }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: { boxes: [], type: "iso-base-media" } });
+    }) : (iterator.discard(bytesRemainingInBox), { status: "done" });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
@@ -7643,7 +8259,7 @@ var processSample = async ({
         compressorName,
         depth,
         colorTableId,
-        descriptors: children.segments.boxes
+        descriptors: initialBoxes
       }
     };
   }
@@ -7652,7 +8268,7 @@ var processSample = async ({
 var parseSamples = async ({
   iterator,
   maxBytes,
-  options,
+  state,
   signal,
   logLevel,
   fields
@@ -7662,7 +8278,7 @@ var parseSamples = async ({
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() - initialOffset < maxBytes) {
     const { sample } = await processSample({
       iterator,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -7679,7 +8295,7 @@ var parseStsd = async ({
   iterator,
   offset,
   size,
-  options,
+  state,
   signal,
   fields
 }) => {
@@ -7693,7 +8309,7 @@ var parseStsd = async ({
   const boxes = await parseSamples({
     iterator,
     maxBytes: bytesRemainingInBox,
-    options,
+    state,
     signal,
     logLevel: "info",
     fields
@@ -7965,30 +8581,31 @@ var parseTrak = async ({
   data,
   size,
   offsetAtStart,
-  options,
+  state: options,
   signal,
   logLevel,
   fields
 }) => {
-  const children = await parseIsoBaseMediaBoxes({
+  const initialBoxes = [];
+  const result = await parseIsoBaseMediaBoxes({
     iterator: data,
     maxBytes: size - (data.counter.getOffset() - offsetAtStart),
     allowIncompleteBoxes: false,
-    initialBoxes: [],
-    options,
+    initialBoxes,
+    state: options,
     continueMdat: false,
     signal,
     logLevel,
     fields
   });
-  if (children.status === "incomplete") {
+  if (result.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
   }
   return {
     offset: offsetAtStart,
     boxSize: size,
     type: "trak-box",
-    children: children.segments.boxes
+    children: initialBoxes
   };
 };
 
@@ -8039,19 +8656,20 @@ var getChildren = async ({
   boxType,
   iterator,
   bytesRemainingInBox,
-  options,
+  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: [],
-      options,
+      initialBoxes: boxes,
+      state,
       continueMdat: false,
       signal,
       logLevel,
@@ -8060,7 +8678,7 @@ var getChildren = async ({
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
     }
-    return parsed.segments.boxes;
+    return boxes;
   }
   if (bytesRemainingInBox < 0) {
     throw new Error("Box size is too big " + JSON.stringify({ boxType }));
@@ -8073,7 +8691,7 @@ var parseMdatPartially = async ({
   boxSize,
   fileOffset,
   parsedBoxes,
-  options,
+  state,
   signal
 }) => {
   const box = await parseMdat({
@@ -8081,9 +8699,9 @@ var parseMdatPartially = async ({
     size: boxSize,
     fileOffset,
     existingBoxes: parsedBoxes,
-    options,
+    state,
     signal,
-    maySkipSampleProcessing: options.supportsContentRange
+    maySkipSampleProcessing: state.supportsContentRange
   });
   if ((box.status === "samples-processed" || box.status === "samples-buffered") && box.fileOffset + boxSize === iterator.counter.getOffset()) {
     return {
@@ -8103,7 +8721,7 @@ var processBox = async ({
   iterator,
   allowIncompleteBoxes,
   parsedBoxes,
-  options,
+  state,
   signal,
   logLevel,
   fields
@@ -8135,7 +8753,7 @@ var processBox = async ({
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
-      const shouldSkip = options.parserState.maySkipVideoData() || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, options.parserState) && options.supportsContentRange;
+      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();
@@ -8158,7 +8776,7 @@ var processBox = async ({
           boxSize,
           fileOffset,
           parsedBoxes,
-          options,
+          state,
           signal
         });
       }
@@ -8233,7 +8851,7 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       fields
     });
@@ -8328,7 +8946,7 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       fields
     });
@@ -8375,12 +8993,12 @@ var processBox = async ({
       iterator,
       offset: fileOffset,
       size: boxSize,
-      options,
+      state,
       signal,
       logLevel,
       fields
     });
-    options.parserState.tracks.setIsDone();
+    state.callbacks.tracks.setIsDone();
     return {
       type: "complete",
       box,
@@ -8393,7 +9011,7 @@ var processBox = async ({
       data: iterator,
       size: boxSize,
       offsetAtStart: fileOffset,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -8401,7 +9019,7 @@ var processBox = async ({
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
       await registerTrack({
-        options,
+        state,
         track: transformedTrack,
         container: "mp4"
       });
@@ -8508,9 +9126,9 @@ var processBox = async ({
       size: boxSize,
       fileOffset,
       existingBoxes: parsedBoxes,
-      options,
+      state,
       signal,
-      maySkipSampleProcessing: options.supportsContentRange
+      maySkipSampleProcessing: state.supportsContentRange
     });
     if (box === null) {
       throw new Error("Unexpected null");
@@ -8527,7 +9145,7 @@ var processBox = async ({
     boxType,
     iterator,
     bytesRemainingInBox,
-    options,
+    state,
     signal,
     logLevel,
     fields
@@ -8550,31 +9168,27 @@ var parseIsoBaseMediaBoxes = async ({
   maxBytes,
   allowIncompleteBoxes,
   initialBoxes,
-  options,
+  state,
   continueMdat,
   signal,
   logLevel,
   fields
 }) => {
-  const structure = {
-    type: "iso-base-media",
-    boxes: initialBoxes
-  };
   const initialOffset = iterator.counter.getOffset();
-  const alreadyHasMdat = structure.boxes.find((b) => b.type === "mdat-box");
+  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({
       iterator,
       boxSize: continueMdat.boxSize,
       fileOffset: continueMdat.fileOffset,
       parsedBoxes: initialBoxes,
-      options,
+      state,
       signal
     }) : await processBox({
       iterator,
       allowIncompleteBoxes,
       parsedBoxes: initialBoxes,
-      options,
+      state,
       signal,
       logLevel,
       fields
@@ -8585,14 +9199,13 @@ var parseIsoBaseMediaBoxes = async ({
       }
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -8605,14 +9218,13 @@ var parseIsoBaseMediaBoxes = async ({
     if (result.type === "partial-mdat-box") {
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return Promise.resolve(parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: result,
             signal,
             logLevel,
@@ -8623,36 +9235,34 @@ var parseIsoBaseMediaBoxes = async ({
       };
     }
     if (result.box.type === "mdat-box" && alreadyHasMdat) {
-      structure.boxes = structure.boxes.filter((b) => b.type !== "mdat-box");
-      structure.boxes.push(result.box);
+      initialBoxes = initialBoxes.filter((b) => b.type !== "mdat-box");
+      initialBoxes.push(result.box);
       iterator.allowDiscard();
       if (result.box.status !== "samples-processed") {
         throw new Error("unexpected");
       }
       break;
     } else {
-      structure.boxes.push(result.box);
-      if (hasAllInfo({ fields, state: options.parserState, structure })) {
+      initialBoxes.push(result.box);
+      if (hasAllInfo({ fields, state })) {
         return {
-          status: "done",
-          segments: structure
+          status: "done"
         };
       }
     }
     if (result.skipTo !== null) {
-      if (!options.supportsContentRange) {
+      if (!state.supportsContentRange) {
         throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
       }
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -8665,14 +9275,13 @@ var parseIsoBaseMediaBoxes = async ({
     if (iterator.bytesRemaining() < 0) {
       return {
         status: "incomplete",
-        segments: structure,
         continueParsing: () => {
           return parseIsoBaseMediaBoxes({
             iterator,
             maxBytes,
             allowIncompleteBoxes,
-            initialBoxes: structure.boxes,
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
@@ -8684,13 +9293,12 @@ var parseIsoBaseMediaBoxes = async ({
     }
     iterator.removeBytesRead();
   }
-  const mdatState = getMdatBox(structure.boxes);
-  const skipped = mdatState?.status === "samples-skipped" && !options.parserState.maySkipVideoData() && options.supportsContentRange;
-  const buffered = mdatState?.status === "samples-buffered" && !options.parserState.maySkipVideoData();
+  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",
-      segments: structure,
       continueParsing: () => {
         if (buffered) {
           iterator.skipTo(mdatState.fileOffset, false);
@@ -8699,8 +9307,8 @@ var parseIsoBaseMediaBoxes = async ({
           iterator,
           maxBytes,
           allowIncompleteBoxes: false,
-          initialBoxes: structure.boxes,
-          options,
+          initialBoxes,
+          state,
           continueMdat: false,
           signal,
           logLevel,
@@ -8711,8 +9319,7 @@ var parseIsoBaseMediaBoxes = async ({
     };
   }
   return {
-    status: "done",
-    segments: structure
+    status: "done"
   };
 };
 
@@ -8980,37 +9587,39 @@ var getStrhForIndex = (structure, trackId) => {
 };
 var handleChunk = async ({
   iterator,
-  options,
+  state,
   structure,
   ckId,
   ckSize
 }) => {
+  const offset = iterator.counter.getOffset();
   const videoChunk = ckId.match(/^([0-9]{2})dc$/);
   if (videoChunk) {
     const trackId = parseInt(videoChunk[1], 10);
     const strh = getStrhForIndex(structure, trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = options.parserState.getSamplesForTrack(trackId);
+    const nthSample = state.callbacks.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = Math.floor(timeInSec);
-    const duration2 = Math.floor(1 / samplesPerSecond);
+    const timestamp = timeInSec;
     const data = iterator.getSlice(ckSize);
     const infos = parseAvc(data);
     const keyOrDelta = getKeyFrameOrDeltaFromAvcInfo(infos);
     const avcProfile = infos.find((i) => i.type === "avc-profile");
     const ppsProfile = infos.find((i) => i.type === "avc-pps");
     if (avcProfile && ppsProfile) {
-      await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
-      options.parserState.tracks.setIsDone();
+      await state.riff.onProfile({ pps: ppsProfile, sps: avcProfile });
+      state.callbacks.tracks.setIsDone();
     }
-    await options.parserState.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+    await state.callbacks.onVideoSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
       data,
-      duration: duration2,
+      duration: undefined,
       timestamp,
       trackId,
-      type: keyOrDelta
+      type: keyOrDelta,
+      offset,
+      timescale: samplesPerSecond
     }, 1));
     return;
   }
@@ -9019,25 +9628,27 @@ var handleChunk = async ({
     const trackId = parseInt(audioChunk[1], 10);
     const strh = getStrhForIndex(structure, trackId);
     const samplesPerSecond = strh.rate / strh.scale;
-    const nthSample = options.parserState.getSamplesForTrack(trackId);
+    const nthSample = state.callbacks.getSamplesForTrack(trackId);
     const timeInSec = nthSample / samplesPerSecond;
     const timestamp = timeInSec;
-    const duration2 = 1 / samplesPerSecond;
-    await options.parserState.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
+    const data = iterator.getSlice(ckSize);
+    await state.callbacks.onAudioSample(trackId, convertAudioOrVideoSampleToWebCodecsTimestamps({
       cts: timestamp,
       dts: timestamp,
-      data: iterator.getSlice(ckSize),
-      duration: duration2,
+      data,
+      duration: undefined,
       timestamp,
       trackId,
-      type: "key"
+      type: "key",
+      offset,
+      timescale: samplesPerSecond
     }, 1));
   }
 };
 var parseMovi = async ({
   iterator,
   maxOffset,
-  options,
+  state,
   structure
 }) => {
   while (iterator.counter.getOffset() < maxOffset) {
@@ -9045,13 +9656,15 @@ var parseMovi = async ({
       return {
         type: "incomplete",
         continueParsing: () => {
-          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+          return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
         }
       };
     }
     const ckId = iterator.getByteString(4);
     const ckSize = iterator.getUint32Le();
-    if (options.parserState.maySkipVideoData() && options.parserState.getAvcProfile()) {
+    if (maySkipVideoData({
+      state
+    }) && state.riff.getAvcProfile()) {
       return {
         type: "complete",
         box: {
@@ -9065,11 +9678,11 @@ var parseMovi = async ({
       return {
         type: "incomplete",
         continueParsing: () => {
-          return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+          return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
         }
       };
     }
-    await handleChunk({ iterator, options, structure, ckId, ckSize });
+    await handleChunk({ iterator, state, structure, ckId, ckSize });
     while (iterator.counter.getOffset() < maxOffset && iterator.bytesRemaining() > 0) {
       if (iterator.getUint8() !== 0) {
         iterator.counter.decrement(1);
@@ -9092,7 +9705,7 @@ var parseMovi = async ({
   return {
     type: "incomplete",
     continueParsing: () => {
-      return Promise.resolve(parseMovi({ iterator, maxOffset, options, structure }));
+      return Promise.resolve(parseMovi({ iterator, maxOffset, state, structure }));
     }
   };
 };
@@ -9187,7 +9800,7 @@ var parseIsft = ({
 var parseListBox = async ({
   iterator,
   size,
-  options
+  state
 }) => {
   const counter = iterator.counter.getOffset();
   const listType = iterator.getByteString(4);
@@ -9202,7 +9815,7 @@ var parseListBox = async ({
     structure,
     iterator,
     maxOffset: counter + size,
-    options
+    state
   });
   if (result.status === "incomplete") {
     throw new Error(`Should only parse complete boxes (${listType})`);
@@ -9342,13 +9955,13 @@ var parseRiffBox = ({
   size,
   id,
   boxes,
-  options
+  state
 }) => {
   if (id === "fmt") {
     return Promise.resolve(parseFmtBox({ iterator, boxes, size }));
   }
   if (id === "LIST") {
-    return parseListBox({ iterator, size, options });
+    return parseListBox({ iterator, size, state });
   }
   if (id === "ISFT") {
     return Promise.resolve(parseIsft({ iterator, size }));
@@ -9374,14 +9987,14 @@ var parseRiffBox = ({
 // src/boxes/riff/expect-riff-box.ts
 var expectRiffBox = async ({
   iterator,
-  options,
+  state,
   structure
 }) => {
   if (iterator.bytesRemaining() < 16) {
     return {
       type: "incomplete",
       continueParsing() {
-        return expectRiffBox({ structure, iterator, options });
+        return expectRiffBox({ structure, iterator, state });
       }
     };
   }
@@ -9392,7 +10005,7 @@ var expectRiffBox = async ({
     return parseMovi({
       iterator,
       maxOffset: ckSize + iterator.counter.getOffset() - 4,
-      options,
+      state,
       structure
     });
   }
@@ -9401,7 +10014,7 @@ var expectRiffBox = async ({
     return {
       type: "incomplete",
       continueParsing: () => {
-        return expectRiffBox({ structure, iterator, options });
+        return expectRiffBox({ structure, iterator, state });
       }
     };
   }
@@ -9412,7 +10025,7 @@ var expectRiffBox = async ({
       iterator,
       size: ckSize,
       boxes: structure.boxes,
-      options
+      state
     }),
     skipTo: null
   };
@@ -9424,7 +10037,7 @@ var continueAfterRiffBoxResult = ({
   structure,
   iterator,
   maxOffset,
-  options
+  state: options
 }) => {
   if (result.type === "incomplete") {
     return Promise.resolve({
@@ -9435,7 +10048,7 @@ var continueAfterRiffBoxResult = ({
           structure,
           iterator,
           maxOffset,
-          options
+          state: options
         }));
       },
       segments: structure,
@@ -9445,30 +10058,29 @@ var continueAfterRiffBoxResult = ({
   if (result.type === "complete" && result.box) {
     structure.boxes.push(result.box);
   }
-  return parseRiffBody({ iterator, maxOffset, options, structure });
+  return parseRiffBody({ iterator, maxOffset, state: options, structure });
 };
 var parseRiffBody = async ({
   iterator,
   structure,
   maxOffset,
-  options
+  state
 }) => {
   while (iterator.bytesRemaining() > 0 && iterator.counter.getOffset() < maxOffset) {
     const result = await expectRiffBox({
       iterator,
-      options,
+      state,
       structure
     });
     if (result.type === "complete" && result.skipTo !== null) {
       return {
         status: "incomplete",
         skipTo: result.skipTo,
-        segments: structure,
         continueParsing() {
           return Promise.resolve(continueAfterRiffBoxResult({
             iterator,
             maxOffset,
-            options,
+            state,
             result,
             structure
           }));
@@ -9482,12 +10094,11 @@ var parseRiffBody = async ({
           return Promise.resolve(continueAfterRiffBoxResult({
             iterator,
             maxOffset,
-            options,
+            state,
             result: await result.continueParsing(),
             structure
           }));
         },
-        segments: structure,
         skipTo: null
       };
     }
@@ -9496,13 +10107,13 @@ var parseRiffBody = async ({
     }
     structure.boxes.push(result.box);
     if (result.box.type === "list-box" && result.box.listType === "hdrl") {
-      const tracks2 = getTracks(structure, options.parserState);
+      const tracks2 = getTracks(structure, state);
       if (!tracks2.videoTracks.some((t) => t.codec === TO_BE_OVERRIDDEN_LATER)) {
-        options.parserState.tracks.setIsDone();
+        state.callbacks.tracks.setIsDone();
       }
     }
     if (result.box.type === "wave-format-box") {
-      options.parserState.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
     if (result.box.type === "strf-box-video" || result.box.type === "strf-box-audio") {
       const strh = getStrhBox(structure.boxes);
@@ -9510,60 +10121,67 @@ var parseRiffBody = async ({
       if (!strh || !strf) {
         throw new Error("strh or strf box missing");
       }
-      if (strf.type === "strf-box-audio" && options.onAudioTrack) {
+      if (strf.type === "strf-box-audio" && state.onAudioTrack) {
         const audioTrack = makeAviAudioTrack({
-          index: options.nextTrackIndex,
+          index: state.riff.getNextTrackIndex(),
           strf
         });
         await registerTrack({
-          options,
+          state,
           track: audioTrack,
           container: "avi"
         });
       }
-      if (options.onVideoTrack && strf.type === "strf-box-video") {
+      if (state.onVideoTrack && strf.type === "strf-box-video") {
         const videoTrack = makeAviVideoTrack({
           strh,
-          index: options.nextTrackIndex,
+          index: state.riff.getNextTrackIndex(),
           strf
         });
         registerVideoTrackWhenProfileIsAvailable({
-          options,
+          state,
           track: videoTrack,
           container: "avi"
         });
       }
-      options.nextTrackIndex++;
+      state.riff.incrementNextTrackIndex();
     }
   }
   return {
-    status: "done",
-    segments: structure
+    status: "done"
   };
 };
 var parseRiff = ({
   iterator,
-  options,
+  state,
   fields
 }) => {
-  const structure = { type: "riff", boxes: [] };
   const riff = iterator.getByteString(4);
   if (riff !== "RIFF") {
     throw new Error("Not a RIFF file");
   }
+  const structure = state.structure.getStructure();
+  if (structure.type !== "riff") {
+    throw new Error("Structure is not a RIFF structure");
+  }
   const size = iterator.getUint32Le();
   const fileType = iterator.getByteString(4);
   if (fileType !== "WAVE" && fileType !== "AVI") {
     throw new Error(`File type ${fileType} not supported`);
   }
   structure.boxes.push({ type: "riff-header", fileSize: size, fileType });
-  if (hasAllInfo({ fields, structure, state: options.parserState })) {
+  if (hasAllInfo({ fields, state })) {
     return Promise.resolve({
       status: "done",
       segments: structure
     });
   }
-  return parseRiffBody({ iterator, structure, maxOffset: Infinity, options });
+  return parseRiffBody({
+    iterator,
+    maxOffset: Infinity,
+    state,
+    structure
+  });
 };
 
 // src/boxes/transport-stream/next-pes-header-store.ts
@@ -9903,10 +10521,11 @@ var MPEG_TIMESCALE = 90000;
 var handleAvcPacket = async ({
   streamBuffer,
   programId,
-  options
+  state,
+  offset
 }) => {
   const avc = parseAvc(streamBuffer.buffer);
-  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
   if (!isTrackRegistered) {
@@ -9919,7 +10538,7 @@ var handleAvcPacket = async ({
       type: "video",
       timescale: MPEG_TIMESCALE,
       codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
-      codecPrivate: getAvccBoxContent(spsAndPps),
+      codecPrivate: createSpsPpsData(spsAndPps),
       fps: null,
       codedWidth: dimensions.width,
       codedHeight: dimensions.height,
@@ -9936,7 +10555,7 @@ var handleAvcPacket = async ({
       },
       color: getVideoColorFromSps(spsAndPps.sps.spsData)
     };
-    await registerTrack({ track, options, container: "transport-stream" });
+    await registerTrack({ track, state, container: "transport-stream" });
   }
   const sample = {
     cts: streamBuffer.pesHeader.pts,
@@ -9945,23 +10564,26 @@ var handleAvcPacket = async ({
     duration: undefined,
     data: new Uint8Array(streamBuffer.buffer),
     trackId: programId,
-    type: getKeyFrameOrDeltaFromAvcInfo(avc)
+    type: getKeyFrameOrDeltaFromAvcInfo(avc),
+    offset,
+    timescale: MPEG_TIMESCALE
   };
-  await options.parserState.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await state.callbacks.onVideoSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
 };
 
 // src/boxes/transport-stream/handle-aac-packet.ts
 var handleAacPacket = async ({
   streamBuffer,
-  options,
-  programId
+  state,
+  programId,
+  offset
 }) => {
   const adtsHeader = readAdtsHeader(streamBuffer.buffer);
   if (!adtsHeader) {
     throw new Error("Invalid ADTS header - too short");
   }
   const { channelConfiguration, codecPrivate: codecPrivate2, sampleRate, audioObjectType } = adtsHeader;
-  const isTrackRegistered = options.parserState.tracks.getTracks().find((t) => {
+  const isTrackRegistered = state.callbacks.tracks.getTracks().find((t) => {
     return t.trackId === programId;
   });
   if (!isTrackRegistered) {
@@ -9979,7 +10601,7 @@ var handleAacPacket = async ({
     };
     await registerTrack({
       track,
-      options,
+      state,
       container: "transport-stream"
     });
   }
@@ -9990,15 +10612,17 @@ var handleAacPacket = async ({
     duration: undefined,
     data: new Uint8Array(streamBuffer.buffer),
     trackId: programId,
-    type: "key"
+    type: "key",
+    offset,
+    timescale: MPEG_TIMESCALE
   };
-  await options.parserState.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
+  await state.callbacks.onAudioSample(programId, convertAudioOrVideoSampleToWebCodecsTimestamps(sample, MPEG_TIMESCALE));
 };
 
 // src/boxes/transport-stream/process-stream-buffers.ts
 var processStreamBuffer = async ({
   streamBuffer,
-  options,
+  state,
   programId,
   structure
 }) => {
@@ -10007,28 +10631,38 @@ var processStreamBuffer = async ({
     throw new Error("No stream found");
   }
   if (stream.streamType === 27) {
-    await handleAvcPacket({ programId, streamBuffer, options });
+    await handleAvcPacket({
+      programId,
+      streamBuffer,
+      state,
+      offset: streamBuffer.offset
+    });
   } else if (stream.streamType === 15) {
-    await handleAacPacket({ streamBuffer, options, programId });
+    await handleAacPacket({
+      streamBuffer,
+      state,
+      programId,
+      offset: streamBuffer.offset
+    });
   }
-  if (!options.parserState.tracks.hasAllTracks()) {
-    const tracksRegistered = options.parserState.tracks.getTracks().length;
+  if (!state.callbacks.tracks.hasAllTracks()) {
+    const tracksRegistered = state.callbacks.tracks.getTracks().length;
     const { streams } = findProgramMapTableOrThrow(structure);
     if (streams.length === tracksRegistered) {
-      options.parserState.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
   }
 };
 var processFinalStreamBuffers = async ({
   streamBufferMap,
-  parserContext,
+  state,
   structure
 }) => {
   for (const [programId, buffer] of streamBufferMap) {
     if (buffer.buffer.byteLength > 0) {
       await processStreamBuffer({
         streamBuffer: buffer,
-        options: parserContext,
+        state,
         programId,
         structure
       });
@@ -10043,14 +10677,16 @@ var parseAdtsStream = async ({
   transportStreamEntry,
   streamBuffers,
   nextPesHeader,
-  options,
-  structure
+  state,
+  structure,
+  offset
 }) => {
   const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
   if (!streamBuffer) {
     streamBuffers.set(transportStreamEntry.pid, {
       buffer: restOfPacket,
-      pesHeader: nextPesHeader
+      pesHeader: nextPesHeader,
+      offset
     });
     return;
   }
@@ -10064,13 +10700,14 @@ var parseAdtsStream = async ({
     await processStreamBuffer({
       streamBuffer,
       programId: transportStreamEntry.pid,
-      options,
+      state,
       structure
     });
     const rest = restOfPacket.slice(bytesToTake);
     streamBuffers.set(transportStreamEntry.pid, {
       buffer: rest,
-      pesHeader: nextPesHeader
+      pesHeader: nextPesHeader,
+      offset
     });
   }
 };
@@ -10080,8 +10717,9 @@ var parseAvcStream = async ({
   streamBuffers,
   nextPesHeader,
   programId,
-  parserContext,
-  structure
+  state,
+  structure,
+  offset
 }) => {
   const indexOfSeparator = findNextSeparator(restOfPacket, transportStreamEntry);
   const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
@@ -10095,7 +10733,8 @@ var parseAvcStream = async ({
     }
     streamBuffers.set(programId, {
       pesHeader: nextPesHeader,
-      buffer: restOfPacket
+      buffer: restOfPacket,
+      offset
     });
     return;
   }
@@ -10103,7 +10742,7 @@ var parseAvcStream = async ({
     const packet = restOfPacket.slice(0, indexOfSeparator);
     streamBuffer.buffer = combineUint8Arrays([streamBuffer.buffer, packet]);
     await processStreamBuffer({
-      options: parserContext,
+      state,
       streamBuffer,
       programId,
       structure
@@ -10111,7 +10750,8 @@ var parseAvcStream = async ({
     const rest = restOfPacket.slice(indexOfSeparator);
     streamBuffers.set(programId, {
       pesHeader: nextPesHeader,
-      buffer: rest
+      buffer: rest,
+      offset
     });
     return;
   }
@@ -10120,14 +10760,15 @@ var parseAvcStream = async ({
   }
   streamBuffers.set(programId, {
     pesHeader: nextPesHeader,
-    buffer: restOfPacket.slice(indexOfSeparator)
+    buffer: restOfPacket.slice(indexOfSeparator),
+    offset
   });
 };
 var parseStream = ({
   iterator,
   transportStreamEntry,
   streamBuffers,
-  parserContext,
+  state,
   programId,
   structure,
   nextPesHeader
@@ -10139,9 +10780,10 @@ var parseStream = ({
       transportStreamEntry,
       streamBuffers,
       nextPesHeader,
-      parserContext,
+      state,
       programId,
-      structure
+      structure,
+      offset: iterator.counter.getOffset()
     });
   }
   if (transportStreamEntry.streamType === 15) {
@@ -10150,8 +10792,9 @@ var parseStream = ({
       transportStreamEntry,
       streamBuffers,
       nextPesHeader,
-      options: parserContext,
-      structure
+      state,
+      structure,
+      offset: iterator.counter.getOffset()
     });
   }
   throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
@@ -10162,7 +10805,7 @@ var parsePacket = async ({
   iterator,
   structure,
   streamBuffers,
-  parserContext,
+  parserState,
   nextPesHeaderStore
 }) => {
   const offset = iterator.counter.getOffset();
@@ -10226,7 +10869,7 @@ var parsePacket = async ({
       transportStreamEntry: stream,
       streamBuffers,
       nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
-      parserContext,
+      state: parserState,
       programId,
       structure
     });
@@ -10238,16 +10881,19 @@ var parsePacket = async ({
 // src/boxes/transport-stream/parse-transport-stream.ts
 var parseTransportStream = async ({
   iterator,
-  parserContext,
-  structure,
+  state,
   streamBuffers,
   fields,
   nextPesHeaderStore
 }) => {
+  const structure = state.structure.getStructure();
+  if (structure.type !== "transport-stream") {
+    throw new Error("Invalid structure type");
+  }
   if (iterator.bytesRemaining() === 0) {
     await processFinalStreamBuffers({
       streamBufferMap: streamBuffers,
-      parserContext,
+      state,
       structure
     });
     return Promise.resolve({
@@ -10258,8 +10904,7 @@ var parseTransportStream = async ({
   while (true) {
     if (hasAllInfo({
       fields,
-      state: parserContext.parserState,
-      structure
+      state
     })) {
       break;
     }
@@ -10271,8 +10916,7 @@ var parseTransportStream = async ({
         continueParsing: () => {
           return parseTransportStream({
             iterator,
-            parserContext,
-            structure,
+            state,
             streamBuffers,
             fields,
             nextPesHeaderStore
@@ -10284,7 +10928,7 @@ var parseTransportStream = async ({
       iterator,
       structure,
       streamBuffers,
-      parserContext,
+      parserState: state,
       nextPesHeaderStore
     });
     if (packet) {
@@ -10298,8 +10942,7 @@ var parseTransportStream = async ({
     continueParsing() {
       return parseTransportStream({
         iterator,
-        parserContext,
-        structure,
+        state,
         streamBuffers,
         fields,
         nextPesHeaderStore
@@ -10342,7 +10985,7 @@ var parseBlockFlags = (iterator, type) => {
 };
 
 // src/boxes/webm/get-sample-from-block.ts
-var getSampleFromBlock = (ebml, parserContext, offset) => {
+var getSampleFromBlock = (ebml, state, offset) => {
   const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
   if (trackNumber2 === null) {
@@ -10350,9 +10993,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
   }
   const timecodeRelativeToCluster = iterator.getInt16();
   const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
-  const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber2);
-  const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-  const timescale2 = parserContext.parserState.getTimescale();
+  const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber2);
+  const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
+  const timescale2 = state.webm.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
@@ -10369,7 +11012,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       dts: timecodeInMicroseconds,
       duration: undefined,
       trackId: trackNumber2,
-      timestamp: timecodeInMicroseconds
+      timestamp: timecodeInMicroseconds,
+      offset,
+      timescale: timescale2
     };
     if (keyframe === null) {
       iterator.destroy();
@@ -10396,7 +11041,9 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
       type: "key",
       duration: undefined,
       cts: timecodeInMicroseconds,
-      dts: timecodeInMicroseconds
+      dts: timecodeInMicroseconds,
+      offset,
+      timescale: timescale2
     };
     iterator.destroy();
     return {
@@ -10411,7 +11058,7 @@ var getSampleFromBlock = (ebml, parserContext, offset) => {
 };
 
 // src/boxes/webm/parse-ebml.ts
-var parseEbml = async (iterator, parserContext) => {
+var parseEbml = async (iterator, state) => {
   const hex = iterator.getMatroskaSegmentId();
   if (hex === null) {
     throw new Error("Not enough bytes left to parse EBML - this should not happen");
@@ -10480,11 +11127,11 @@ var parseEbml = async (iterator, parserContext) => {
         break;
       }
       const offset = iterator.counter.getOffset();
-      const value = await parseEbml(iterator, parserContext);
+      const value = await parseEbml(iterator, state);
       const remapped = await postprocessEbml({
         offset,
         ebml: value,
-        parserContext
+        state
       });
       children.push(remapped);
       const offsetNow = iterator.counter.getOffset();
@@ -10502,47 +11149,47 @@ var parseEbml = async (iterator, parserContext) => {
 var postprocessEbml = async ({
   offset,
   ebml,
-  parserContext
+  state
 }) => {
   if (ebml.type === "TimestampScale") {
-    parserContext.parserState.setTimescale(ebml.value.value);
+    state.webm.setTimescale(ebml.value.value);
   }
   if (ebml.type === "TrackEntry") {
-    parserContext.parserState.onTrackEntrySegment(ebml);
+    state.webm.onTrackEntrySegment(ebml);
     const track = getTrack({
       track: ebml,
-      timescale: parserContext.parserState.getTimescale()
+      timescale: state.webm.getTimescale()
     });
     if (track) {
       await registerTrack({
-        options: parserContext,
+        state,
         track,
         container: "webm"
       });
     }
   }
   if (ebml.type === "Timestamp") {
-    parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
+    state.webm.setTimestampOffset(offset, ebml.value.value);
   }
   if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
-    const sample = getSampleFromBlock(ebml, parserContext, offset);
-    if (sample.type === "video-sample" && parserContext.nullifySamples) {
-      await parserContext.parserState.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+    const sample = getSampleFromBlock(ebml, state, offset);
+    if (sample.type === "video-sample" && state.nullifySamples) {
+      await state.callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
         minVintWidth: ebml.minVintWidth
       };
     }
-    if (sample.type === "audio-sample" && parserContext.nullifySamples) {
-      await parserContext.parserState.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+    if (sample.type === "audio-sample" && state.nullifySamples) {
+      await state.callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
         minVintWidth: ebml.minVintWidth
       };
     }
-    if (sample.type === "no-sample" && parserContext.nullifySamples) {
+    if (sample.type === "no-sample" && state.nullifySamples) {
       return {
         type: "Block",
         value: new Uint8Array([]),
@@ -10556,15 +11203,15 @@ var postprocessEbml = async ({
       throw new Error("Expected block segment");
     }
     const hasReferenceBlock = ebml.value.find((c) => c.type === "ReferenceBlock");
-    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, parserContext, offset);
+    const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, state, offset);
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
         ...sample.partialVideoSample,
         type: hasReferenceBlock ? "delta" : "key"
       };
-      await parserContext.parserState.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+      await state.callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
     }
-    if (parserContext.nullifySamples) {
+    if (state.nullifySamples) {
       return {
         type: "BlockGroup",
         value: [],
@@ -10579,7 +11226,7 @@ var postprocessEbml = async ({
 var continueAfterMatroskaParseResult = async ({
   result,
   iterator,
-  parserContext,
+  state,
   segment
 }) => {
   if (result.status === "done") {
@@ -10597,7 +11244,7 @@ var continueAfterMatroskaParseResult = async ({
       return continueAfterMatroskaParseResult({
         result: proceeded,
         iterator,
-        parserContext,
+        state,
         segment
       });
     },
@@ -10607,7 +11254,7 @@ var continueAfterMatroskaParseResult = async ({
 };
 var expectSegment = async ({
   iterator,
-  parserContext,
+  state,
   offset,
   children,
   fields,
@@ -10620,7 +11267,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectAndProcessSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -10638,7 +11285,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectAndProcessSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -10658,7 +11305,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -10679,7 +11326,7 @@ var expectSegment = async ({
       iterator,
       length,
       children: newSegment.value,
-      parserContext,
+      state,
       startOffset: iterator.counter.getOffset(),
       fields,
       topLevelStructure
@@ -10690,7 +11337,7 @@ var expectSegment = async ({
         continueParsing: () => {
           return continueAfterMatroskaParseResult({
             iterator,
-            parserContext,
+            state,
             result: main,
             segment: newSegment
           });
@@ -10712,7 +11359,7 @@ var expectSegment = async ({
       continueParsing: () => {
         return expectSegment({
           iterator,
-          parserContext,
+          state,
           offset,
           children,
           fields,
@@ -10725,7 +11372,7 @@ var expectSegment = async ({
     segmentId,
     iterator,
     length,
-    parserContext,
+    state,
     headerReadSoFar: iterator.counter.getOffset() - offset
   });
   return {
@@ -10737,7 +11384,7 @@ var parseSegment = async ({
   segmentId,
   iterator,
   length,
-  parserContext,
+  state,
   headerReadSoFar
 }) => {
   if (length < 0) {
@@ -10745,8 +11392,8 @@ var parseSegment = async ({
   }
   iterator.counter.decrement(headerReadSoFar);
   const offset = iterator.counter.getOffset();
-  const ebml = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml, parserContext });
+  const ebml = await parseEbml(iterator, state);
+  const remapped = await postprocessEbml({ offset, ebml, state });
   return remapped;
 };
 
@@ -10760,14 +11407,14 @@ var processParseResult = ({
 }) => {
   if (parseResult.segment && !children.includes(parseResult.segment)) {
     children.push(parseResult.segment);
-    if (hasAllInfo({ fields, state, structure: topLevelStructure })) {
+    if (hasAllInfo({ fields, state })) {
       return {
         status: "done",
         segment: parseResult.segment
       };
     }
     if (parseResult.segment.type === "Tracks") {
-      state.tracks.setIsDone();
+      state.callbacks.tracks.setIsDone();
     }
   }
   if (parseResult.status === "incomplete") {
@@ -10793,7 +11440,7 @@ var processParseResult = ({
 };
 var expectAndProcessSegment = async ({
   iterator,
-  parserContext,
+  state,
   offset,
   children,
   fields,
@@ -10801,7 +11448,7 @@ var expectAndProcessSegment = async ({
 }) => {
   const segment = await expectSegment({
     iterator,
-    parserContext,
+    state,
     offset,
     children,
     fields,
@@ -10810,7 +11457,7 @@ var expectAndProcessSegment = async ({
   return processParseResult({
     children,
     parseResult: segment,
-    state: parserContext.parserState,
+    state,
     fields,
     topLevelStructure
   });
@@ -10819,7 +11466,7 @@ var continueAfterSegmentResult = async ({
   result,
   length,
   children,
-  parserContext,
+  state,
   iterator,
   startOffset,
   fields,
@@ -10837,7 +11484,7 @@ var continueAfterSegmentResult = async ({
           children,
           iterator,
           length,
-          parserContext,
+          state,
           startOffset,
           fields,
           topLevelStructure
@@ -10854,7 +11501,7 @@ var continueAfterSegmentResult = async ({
         children,
         iterator,
         length,
-        parserContext,
+        state,
         startOffset,
         fields,
         topLevelStructure
@@ -10867,7 +11514,7 @@ var expectChildren = async ({
   iterator,
   length,
   children,
-  parserContext,
+  state,
   startOffset,
   fields,
   topLevelStructure
@@ -10879,7 +11526,7 @@ var expectChildren = async ({
     const currentOffset = iterator.counter.getOffset();
     const child = await expectAndProcessSegment({
       iterator,
-      parserContext,
+      state,
       offset: currentOffset,
       children,
       fields,
@@ -10887,8 +11534,7 @@ var expectChildren = async ({
     });
     if (hasAllInfo({
       fields,
-      state: parserContext.parserState,
-      structure: topLevelStructure
+      state
     })) {
       return {
         status: "done"
@@ -10903,7 +11549,7 @@ var expectChildren = async ({
             children,
             iterator,
             length: length - (currentOffset - startOffset),
-            parserContext,
+            state,
             startOffset: currentOffset,
             fields,
             topLevelStructure
@@ -10922,13 +11568,11 @@ var expectChildren = async ({
 var continueAfterMatroskaResult = (result, structure) => {
   if (result.status === "done") {
     return {
-      status: "done",
-      segments: structure
+      status: "done"
     };
   }
   return {
     status: "incomplete",
-    segments: structure,
     continueParsing: async () => {
       const newResult = await result.continueParsing();
       return continueAfterMatroskaResult(newResult, structure);
@@ -10938,15 +11582,18 @@ var continueAfterMatroskaResult = (result, structure) => {
 };
 var parseWebm = async ({
   counter,
-  parserContext,
+  state,
   fields
 }) => {
-  const structure = { type: "matroska", boxes: [] };
+  const structure = state.structure.getStructure();
+  if (structure.type !== "matroska") {
+    throw new Error("Invalid structure type");
+  }
   const results = await expectChildren({
     iterator: counter,
     length: Infinity,
     children: structure.boxes,
-    parserContext,
+    state,
     startOffset: counter.counter.getOffset(),
     fields,
     topLevelStructure: structure
@@ -10957,53 +11604,201 @@ var parseWebm = async ({
 // src/parse-video.ts
 var parseVideo = ({
   iterator,
-  options,
+  state,
   signal,
   logLevel,
-  fields
+  fields,
+  mimeType,
+  contentLength,
+  name
 }) => {
   if (iterator.bytesRemaining() === 0) {
     return Promise.reject(new Error("no bytes"));
   }
-  if (iterator.isRiff()) {
+  const fileType = iterator.detectFileType();
+  if (fileType.type === "riff") {
     Log.verbose(logLevel, "Detected RIFF container");
-    return Promise.resolve(parseRiff({ iterator, options, fields }));
+    state.structure.setStructure({
+      type: "riff",
+      boxes: []
+    });
+    return Promise.resolve(parseRiff({ iterator, state, fields }));
   }
-  if (iterator.isIsoBaseMedia()) {
+  if (fileType.type === "iso-base-media") {
     Log.verbose(logLevel, "Detected ISO Base Media container");
+    const initialBoxes = [];
+    state.structure.setStructure({
+      type: "iso-base-media",
+      boxes: initialBoxes
+    });
     return parseIsoBaseMediaBoxes({
       iterator,
       maxBytes: Infinity,
       allowIncompleteBoxes: true,
-      initialBoxes: [],
-      options,
+      initialBoxes,
+      state,
       continueMdat: false,
       signal,
       logLevel,
       fields
     });
   }
-  if (iterator.isWebm()) {
+  if (fileType.type === "webm") {
     Log.verbose(logLevel, "Detected Matroska container");
-    return parseWebm({ counter: iterator, parserContext: options, fields });
+    state.structure.setStructure({
+      boxes: [],
+      type: "matroska"
+    });
+    return parseWebm({ counter: iterator, state, fields });
   }
-  if (iterator.isTransportStream()) {
+  if (fileType.type === "transport-stream") {
+    Log.verbose(logLevel, "Detected MPEG-2 Transport Stream");
+    state.structure.setStructure({
+      boxes: [],
+      type: "transport-stream"
+    });
     return parseTransportStream({
       iterator,
-      parserContext: options,
-      structure: {
-        type: "transport-stream",
-        boxes: []
-      },
+      state,
       streamBuffers: new Map,
       fields,
       nextPesHeaderStore: makeNextPesHeaderStore()
     });
   }
-  if (iterator.isMp3()) {
-    return Promise.reject(new Error("MP3 files are not yet supported"));
-  }
-  return Promise.reject(new Error("Unknown video format"));
+  if (fileType.type === "mp3") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "MP3 files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "mp3"
+    }));
+  }
+  if (fileType.type === "wav") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "WAV files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "wav"
+    }));
+  }
+  if (fileType.type === "aac") {
+    return Promise.reject(new IsAnUnsupportedAudioTypeError({
+      message: "AAC files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name,
+      audioType: "aac"
+    }));
+  }
+  if (fileType.type === "gif") {
+    return Promise.reject(new IsAGifError({
+      message: "GIF files are not yet supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "pdf") {
+    return Promise.reject(new IsAPdfError({
+      message: "GIF files are not supported",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "bmp" || fileType.type === "jpeg" || fileType.type === "png" || fileType.type === "webp") {
+    return Promise.reject(new IsAnImageError({
+      message: "Image files are not supported",
+      imageType: fileType.type,
+      dimensions: fileType.dimensions,
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  if (fileType.type === "unknown") {
+    return Promise.reject(new IsAnUnsupportedFileTypeError({
+      message: "Unknown file format",
+      mimeType,
+      sizeInBytes: contentLength,
+      fileName: name
+    }));
+  }
+  return Promise.reject(new Error("Unknown video format " + fileType));
+};
+
+// src/state/emitted-fields.ts
+var emittedState = () => {
+  const emittedFields = {
+    audioCodec: false,
+    container: false,
+    dimensions: false,
+    durationInSeconds: false,
+    fps: false,
+    internalStats: false,
+    isHdr: false,
+    location: false,
+    metadata: false,
+    mimeType: false,
+    name: false,
+    rotation: false,
+    size: false,
+    structure: false,
+    tracks: false,
+    videoCodec: false,
+    unrotatedDimensions: false,
+    slowDurationInSeconds: false,
+    slowFps: false,
+    slowKeyframes: false,
+    slowNumberOfFrames: false,
+    keyframes: false
+  };
+  return emittedFields;
+};
+
+// src/state/keyframes.ts
+var keyframesState = () => {
+  const keyframes = [];
+  return {
+    addKeyframe: (keyframe) => {
+      keyframes.push(keyframe);
+    },
+    getKeyframes: () => {
+      return keyframes;
+    }
+  };
+};
+
+// src/state/riff.ts
+var riffSpecificState = () => {
+  let avcProfile = null;
+  let nextTrackIndex = 0;
+  const profileCallbacks = [];
+  const registerOnAvcProfileCallback = (callback) => {
+    profileCallbacks.push(callback);
+  };
+  const onProfile = async (profile) => {
+    avcProfile = profile;
+    for (const callback of profileCallbacks) {
+      await callback(profile);
+    }
+    profileCallbacks.length = 0;
+  };
+  return {
+    getAvcProfile: () => {
+      return avcProfile;
+    },
+    onProfile,
+    registerOnAvcProfileCallback,
+    getNextTrackIndex: () => {
+      return nextTrackIndex;
+    },
+    incrementNextTrackIndex: () => {
+      nextTrackIndex++;
+    }
+  };
 };
 
 // src/state/can-skip-tracks.ts
@@ -11012,6 +11807,8 @@ var needsTracksField = {
   container: false,
   dimensions: true,
   durationInSeconds: true,
+  slowDurationInSeconds: true,
+  slowFps: true,
   fps: true,
   internalStats: false,
   isHdr: true,
@@ -11023,7 +11820,11 @@ var needsTracksField = {
   unrotatedDimensions: true,
   videoCodec: true,
   metadata: true,
-  location: true
+  location: true,
+  mimeType: false,
+  slowKeyframes: true,
+  slowNumberOfFrames: true,
+  keyframes: true
 };
 var makeCanSkipTracksState = ({
   hasAudioTrackHandlers,
@@ -11066,92 +11867,28 @@ var makeTracksSectionState = (canSkipTracksState) => {
   };
 };
 
-// src/state/parser-state.ts
-var makeParserState = ({
+// src/state/sample-callbacks.ts
+var sampleCallback = ({
+  signal,
   hasAudioTrackHandlers,
   hasVideoTrackHandlers,
-  signal,
-  getIterator,
-  fields
+  fields,
+  keyframes,
+  emittedFields,
+  slowDurationAndFpsState
 }) => {
-  const trackEntries = {};
-  const onTrackEntrySegment = (trackEntry2) => {
-    const trackId = getTrackId(trackEntry2);
-    if (!trackId) {
-      throw new Error("Expected track id");
-    }
-    if (trackEntries[trackId]) {
-      return;
-    }
-    const codec = getTrackCodec(trackEntry2);
-    if (!codec) {
-      throw new Error("Expected codec");
-    }
-    const trackTimescale = getTrackTimestampScale(trackEntry2);
-    trackEntries[trackId] = {
-      codec: codec.value,
-      trackTimescale: trackTimescale?.value ?? null
-    };
-  };
   const videoSampleCallbacks = {};
   const audioSampleCallbacks = {};
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
-  let timescale2 = null;
-  let skippedBytes = 0;
-  const getTimescale = () => {
-    if (timescale2 === null) {
-      return 1e6;
-    }
-    return timescale2;
-  };
-  const increaseSkippedBytes = (bytes) => {
-    skippedBytes += bytes;
-  };
-  const setTimescale = (newTimescale) => {
-    timescale2 = newTimescale;
-  };
-  const timestampMap = new Map;
-  const setTimestampOffset = (byteOffset, timestamp) => {
-    timestampMap.set(byteOffset, timestamp);
-  };
-  const getTimestampOffsetForByteOffset = (byteOffset) => {
-    const entries = Array.from(timestampMap.entries());
-    const sortedByByteOffset = entries.sort((a, b) => {
-      return a[0] - b[0];
-    }).reverse();
-    for (const [offset, timestamp] of sortedByByteOffset) {
-      if (offset >= byteOffset) {
-        continue;
-      }
-      return timestamp;
-    }
-    return timestampMap.get(byteOffset);
-  };
-  const samplesForTrack = {};
-  const profileCallbacks = [];
-  const registerOnAvcProfileCallback = (callback) => {
-    profileCallbacks.push(callback);
-  };
-  let avcProfile = null;
-  const onProfile = async (profile) => {
-    avcProfile = profile;
-    for (const callback of profileCallbacks) {
-      await callback(profile);
-    }
-    profileCallbacks.length = 0;
-  };
   const canSkipTracksState = makeCanSkipTracksState({
     hasAudioTrackHandlers,
     fields,
     hasVideoTrackHandlers
   });
   const tracksState = makeTracksSectionState(canSkipTracksState);
+  const samplesForTrack = {};
   return {
-    onTrackEntrySegment,
-    onProfile,
-    registerOnAvcProfileCallback,
-    getTrackInfoByNumber: (id) => trackEntries[id],
     registerVideoSampleCallback: async (id, callback) => {
       if (callback === null) {
         delete videoSampleCallbacks[id];
@@ -11163,19 +11900,6 @@ var makeParserState = ({
       }
       queuedVideoSamples[id] = [];
     },
-    setTimestampOffset,
-    getTimestampOffsetForByteOffset,
-    registerAudioSampleCallback: async (id, callback) => {
-      if (callback === null) {
-        delete audioSampleCallbacks[id];
-        return;
-      }
-      audioSampleCallbacks[id] = callback;
-      for (const queued of queuedAudioSamples[id] ?? []) {
-        await callback(queued);
-      }
-      queuedAudioSamples[id] = [];
-    },
     onAudioSample: async (trackId, audioSample) => {
       if (signal?.aborted) {
         throw new Error("Aborted");
@@ -11189,6 +11913,9 @@ var makeParserState = ({
         await callback(audioSample);
       }
     },
+    getSamplesForTrack: (trackId) => {
+      return samplesForTrack[trackId] ?? 0;
+    },
     onVideoSample: async (trackId, videoSample) => {
       if (signal?.aborted) {
         throw new Error("Aborted");
@@ -11198,36 +11925,207 @@ var makeParserState = ({
       }
       samplesForTrack[trackId]++;
       const callback = videoSampleCallbacks[trackId];
-      if (callback) {
+      if (callback && videoSample.data.length > 0) {
         await callback(videoSample);
       }
+      if (needsToIterateOverSamples({
+        fields,
+        emittedFields
+      })) {
+        if (fields.slowKeyframes && videoSample.type === "key") {
+          keyframes.addKeyframe({
+            trackId,
+            decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+            positionInBytes: videoSample.offset,
+            presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+            sizeInBytes: videoSample.data.length
+          });
+        }
+        slowDurationAndFpsState.addSample(videoSample);
+      }
     },
-    getTimescale,
-    setTimescale,
-    getSamplesForTrack: (trackId) => {
-      return samplesForTrack[trackId] ?? 0;
+    canSkipTracksState,
+    registerAudioSampleCallback: async (id, callback) => {
+      if (callback === null) {
+        delete audioSampleCallbacks[id];
+        return;
+      }
+      audioSampleCallbacks[id] = callback;
+      for (const queued of queuedAudioSamples[id] ?? []) {
+        await callback(queued);
+      }
+      queuedAudioSamples[id] = [];
     },
-    getAvcProfile: () => {
-      return avcProfile;
+    tracks: tracksState,
+    audioSampleCallbacks,
+    videoSampleCallbacks
+  };
+};
+
+// src/state/slow-duration-fps.ts
+var slowDurationAndFpsState = () => {
+  let smallestSample;
+  let largestSample;
+  let samples = 0;
+  const getSlowDurationInSeconds = () => {
+    if (smallestSample !== undefined && largestSample !== undefined) {
+      const startingTimestampDifference = largestSample - smallestSample;
+      const timeBetweenSamples = startingTimestampDifference / (samples - 1);
+      return timeBetweenSamples * samples;
+    }
+    throw new Error("No samples");
+  };
+  return {
+    addSample: (videoSample) => {
+      samples++;
+      const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+      if (largestSample === undefined || presentationTimeInSeconds > largestSample) {
+        largestSample = presentationTimeInSeconds;
+      }
+      if (smallestSample === undefined || presentationTimeInSeconds < smallestSample) {
+        smallestSample = presentationTimeInSeconds;
+      }
+    },
+    getSlowDurationInSeconds,
+    getFps: () => {
+      return samples / getSlowDurationInSeconds();
+    },
+    getSlowNumberOfFrames: () => samples
+  };
+};
+
+// src/state/structure.ts
+var structureState = () => {
+  let structure = null;
+  return {
+    getStructureOrNull: () => {
+      return structure;
     },
+    getStructure: () => {
+      if (structure === null) {
+        throw new Error("Expected structure");
+      }
+      return structure;
+    },
+    setStructure: (value) => {
+      structure = value;
+    }
+  };
+};
+
+// src/state/webm.ts
+var webmState = () => {
+  const trackEntries = {};
+  const onTrackEntrySegment = (trackEntry2) => {
+    const trackId = getTrackId(trackEntry2);
+    if (!trackId) {
+      throw new Error("Expected track id");
+    }
+    if (trackEntries[trackId]) {
+      return;
+    }
+    const codec = getTrackCodec(trackEntry2);
+    if (!codec) {
+      throw new Error("Expected codec");
+    }
+    const trackTimescale = getTrackTimestampScale(trackEntry2);
+    trackEntries[trackId] = {
+      codec: codec.value,
+      trackTimescale: trackTimescale?.value ?? null
+    };
+  };
+  const timestampMap = new Map;
+  const getTimestampOffsetForByteOffset = (byteOffset) => {
+    const entries = Array.from(timestampMap.entries());
+    const sortedByByteOffset = entries.sort((a, b) => {
+      return a[0] - b[0];
+    }).reverse();
+    for (const [offset, timestamp] of sortedByByteOffset) {
+      if (offset >= byteOffset) {
+        continue;
+      }
+      return timestamp;
+    }
+    return timestampMap.get(byteOffset);
+  };
+  const setTimestampOffset = (byteOffset, timestamp) => {
+    timestampMap.set(byteOffset, timestamp);
+  };
+  let timescale2 = null;
+  const setTimescale = (newTimescale) => {
+    timescale2 = newTimescale;
+  };
+  const getTimescale = () => {
+    if (timescale2 === null) {
+      return 1e6;
+    }
+    return timescale2;
+  };
+  return {
+    onTrackEntrySegment,
+    getTrackInfoByNumber: (id) => trackEntries[id],
+    setTimestampOffset,
+    getTimestampOffsetForByteOffset,
+    timescale: timescale2,
+    getTimescale,
+    setTimescale
+  };
+};
+
+// src/state/parser-state.ts
+var makeParserState = ({
+  hasAudioTrackHandlers,
+  hasVideoTrackHandlers,
+  signal,
+  getIterator,
+  fields,
+  nullifySamples,
+  onAudioTrack,
+  onVideoTrack,
+  supportsContentRange
+}) => {
+  let skippedBytes = 0;
+  const increaseSkippedBytes = (bytes) => {
+    skippedBytes += bytes;
+  };
+  const structure = structureState();
+  const keyframes = keyframesState();
+  const emittedFields = emittedState();
+  const slowDurationAndFps = slowDurationAndFpsState();
+  return {
+    riff: riffSpecificState(),
+    callbacks: sampleCallback({
+      signal,
+      hasAudioTrackHandlers,
+      hasVideoTrackHandlers,
+      fields,
+      keyframes,
+      emittedFields,
+      slowDurationAndFpsState: slowDurationAndFps
+    }),
     getInternalStats: () => ({
       skippedBytes,
       finalCursorOffset: getIterator()?.counter.getOffset() ?? 0
     }),
     getSkipBytes: () => skippedBytes,
     increaseSkippedBytes,
-    maySkipVideoData: () => {
-      return tracksState.hasAllTracks() && Object.values(videoSampleCallbacks).length === 0 && Object.values(audioSampleCallbacks).length === 0;
-    },
-    tracks: tracksState,
-    canSkipTracksState
+    keyframes,
+    structure,
+    nullifySamples,
+    onAudioTrack,
+    onVideoTrack,
+    supportsContentRange,
+    webm: webmState(),
+    emittedFields,
+    fields,
+    slowDurationAndFps
   };
 };
 
 // src/parse-media.ts
-var parseMedia = async ({
+var parseMedia = async function({
   src,
-  fields,
+  fields: _fieldsInReturnValue,
   reader: readerInterface = fetchReader,
   onAudioTrack,
   onVideoTrack,
@@ -11235,44 +12133,51 @@ var parseMedia = async ({
   logLevel = "info",
   onParseProgress,
   ...more
-}) => {
+}) {
   let iterator = null;
   let parseResult = null;
-  const state = makeParserState({
-    hasAudioTrackHandlers: Boolean(onAudioTrack),
-    hasVideoTrackHandlers: Boolean(onVideoTrack),
-    signal,
-    getIterator: () => iterator,
-    fields: fields ?? {}
+  const fieldsInReturnValue = _fieldsInReturnValue ?? {};
+  const fields = getFieldsFromCallback({
+    fields: fieldsInReturnValue,
+    callbacks: more
   });
   const {
     reader,
     contentLength,
     name,
+    contentType,
     supportsContentRange: readerSupportsContentRange
   } = await readerInterface.read(src, null, signal);
-  let currentReader = reader;
   const supportsContentRange = readerSupportsContentRange && !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DISABLE_CONTENT_RANGE === "true");
-  const returnValue = {};
-  const moreFields = more;
-  const options = {
+  const state = makeParserState({
+    hasAudioTrackHandlers: Boolean(onAudioTrack),
+    hasVideoTrackHandlers: Boolean(onVideoTrack),
+    signal,
+    getIterator: () => iterator,
+    fields,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
-    parserState: state,
     nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
-    supportsContentRange,
-    nextTrackIndex: 0
-  };
+    supportsContentRange
+  });
+  let currentReader = reader;
+  const returnValue = {};
+  const moreFields = more;
   const triggerInfoEmit = () => {
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult?.segments ?? null, state);
+    const availableInfo = getAvailableInfo({
+      fieldsToFetch: fields,
+      state
+    });
     emitAvailableInfo({
       hasInfo: availableInfo,
-      moreFields,
+      callbacks: moreFields,
+      fieldsInReturnValue,
       parseResult,
       state,
       returnValue,
       contentLength,
-      name
+      name,
+      mimeType: contentType
     });
   };
   triggerInfoEmit();
@@ -11309,23 +12214,25 @@ var parseMedia = async ({
     });
     triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
-      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
+      Log.trace(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset());
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
         iterator,
-        options,
+        state,
         signal: signal ?? null,
         logLevel,
-        fields: fields ?? {}
+        fields,
+        mimeType: contentType,
+        contentLength,
+        name
       });
     }
     if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
       state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
     }
     if (hasAllInfo({
-      fields: fields ?? {},
-      structure: parseResult.segments,
+      fields,
       state
     })) {
       Log.verbose(logLevel, "Got all info, skipping to the end.");
@@ -11350,23 +12257,26 @@ var parseMedia = async ({
     }
   }
   Log.verbose(logLevel, "Finished parsing file");
+  const hasInfo = Object.keys(fields).reduce((acc, key) => {
+    if (fields?.[key]) {
+      acc[key] = true;
+    }
+    return acc;
+  }, {});
   emitAvailableInfo({
-    hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
-      if (fields?.[key]) {
-        acc[key] = true;
-      }
-      return acc;
-    }, {}),
-    moreFields,
+    hasInfo,
+    callbacks: moreFields,
+    fieldsInReturnValue,
     parseResult,
     state,
     returnValue,
     contentLength,
+    mimeType: contentType,
     name
   });
   currentReader.abort();
   iterator?.destroy();
-  state.tracks.ensureHasTracksAtEnd();
+  state.callbacks.tracks.ensureHasTracksAtEnd();
   return returnValue;
 };
 // src/index.ts
@@ -11384,5 +12294,10 @@ var MediaParserInternals = {
 export {
   parseMedia,
   VERSION,
-  MediaParserInternals
+  MediaParserInternals,
+  IsAnUnsupportedFileTypeError,
+  IsAnUnsupportedAudioTypeError,
+  IsAnImageError,
+  IsAPdfError,
+  IsAGifError
 };