@remotion/media-parser 4.0.233 → 4.0.235

package/dist/esm/index.mjs

@@ -105,6 +105,115 @@ var fetchReader = {
   }
 };
 
+// src/aac-codecprivate.ts
+var getConfigForSampleRate = (sampleRate) => {
+  if (sampleRate === 96000) {
+    return 0;
+  }
+  if (sampleRate === 88200) {
+    return 1;
+  }
+  if (sampleRate === 64000) {
+    return 2;
+  }
+  if (sampleRate === 48000) {
+    return 3;
+  }
+  if (sampleRate === 44100) {
+    return 4;
+  }
+  if (sampleRate === 32000) {
+    return 5;
+  }
+  if (sampleRate === 24000) {
+    return 6;
+  }
+  if (sampleRate === 22050) {
+    return 7;
+  }
+  if (sampleRate === 16000) {
+    return 8;
+  }
+  if (sampleRate === 12000) {
+    return 9;
+  }
+  if (sampleRate === 11025) {
+    return 10;
+  }
+  if (sampleRate === 8000) {
+    return 11;
+  }
+  if (sampleRate === 7350) {
+    return 12;
+  }
+  throw new Error(`Unexpected sample rate ${sampleRate}`);
+};
+var createAacCodecPrivate = ({
+  audioObjectType,
+  sampleRate,
+  channelConfiguration
+}) => {
+  const bits = `${audioObjectType.toString(2).padStart(5, "0")}${getConfigForSampleRate(sampleRate).toString(2).padStart(4, "0")}${channelConfiguration.toString(2).padStart(4, "0")}000`;
+  if (bits.length !== 16) {
+    throw new Error("Invalid AAC codec private " + bits.length);
+  }
+  if (channelConfiguration === 0 || channelConfiguration > 7) {
+    throw new Error("Invalid channel configuration " + channelConfiguration);
+  }
+  const firstByte = parseInt(bits.slice(0, 8), 2);
+  const secondByte = parseInt(bits.slice(8, 16), 2);
+  return new Uint8Array([firstByte, secondByte]);
+};
+var parseAacCodecPrivate = (bytes) => {
+  if (bytes.length < 2) {
+    throw new Error("Invalid AAC codec private length");
+  }
+  const bits = `${bytes[0].toString(2).padStart(8, "0")}${bytes[1].toString(2).padStart(8, "0")}`;
+  if (bits.length !== 16) {
+    throw new Error("Invalid AAC codec private bits length");
+  }
+  const audioObjectType = parseInt(bits.slice(0, 5), 2);
+  const samplingFrequencyIndex = parseInt(bits.slice(5, 9), 2);
+  const channelConfiguration = parseInt(bits.slice(9, 13), 2);
+  const sampleRate = (() => {
+    switch (samplingFrequencyIndex) {
+      case 0:
+        return 96000;
+      case 1:
+        return 88200;
+      case 2:
+        return 64000;
+      case 3:
+        return 48000;
+      case 4:
+        return 44100;
+      case 5:
+        return 32000;
+      case 6:
+        return 24000;
+      case 7:
+        return 22050;
+      case 8:
+        return 16000;
+      case 9:
+        return 12000;
+      case 10:
+        return 11025;
+      case 11:
+        return 8000;
+      case 12:
+        return 7350;
+      default:
+        throw new Error(`Unexpected sampling frequency index ${samplingFrequencyIndex}`);
+    }
+  })();
+  return {
+    audioObjectType,
+    sampleRate,
+    channelConfiguration
+  };
+};
+
 // src/create/event-emitter.ts
 class IoEventEmitter {
   listeners = {
@@ -574,6 +683,10 @@ var titleType = {
   name: "Title",
   type: "string"
 };
+var tagTrackUidType = {
+  name: "TagTrackUID",
+  type: "hex-string"
+};
 var samplingFrequency = {
   name: "SamplingFrequency",
   type: "float"
@@ -608,7 +721,7 @@ var flagLacing = {
 };
 var tagSegment = {
   name: "Tag",
-  type: "uint8array"
+  type: "children"
 };
 var tags = {
   name: "Tags",
@@ -714,9 +827,29 @@ var blockGroup = {
   name: "BlockGroup",
   type: "children"
 };
+var targetsType = {
+  name: "Targets",
+  type: "children"
+};
+var simpleTagType = {
+  name: "SimpleTag",
+  type: "children"
+};
+var tagNameType = {
+  name: "TagName",
+  type: "string"
+};
+var tagStringType = {
+  name: "TagString",
+  type: "string"
+};
 var ebmlMap = {
   [matroskaElements.Header]: matroskaHeader,
   [matroskaElements.DocType]: docType,
+  [matroskaElements.Targets]: targetsType,
+  [matroskaElements.SimpleTag]: simpleTagType,
+  [matroskaElements.TagName]: tagNameType,
+  [matroskaElements.TagString]: tagStringType,
   [matroskaElements.DocTypeVersion]: docTypeVersion,
   [matroskaElements.DocTypeReadVersion]: docTypeReadVersion,
   [matroskaElements.EBMLVersion]: ebmlVersion,
@@ -786,6 +919,7 @@ var ebmlMap = {
     name: "SliceDuration",
     type: "uint8array"
   },
+  [matroskaElements.TagTrackUID]: tagTrackUidType,
   [matroskaElements.SeekHead]: seekHead,
   [matroskaElements.Seek]: seek,
   [matroskaElements.SeekID]: seekId,
@@ -1208,6 +1342,9 @@ var createIsoBaseMediaFtyp = ({
   return createFtyp({ compatibleBrands, majorBrand, minorBrand });
 };
 
+// src/version.ts
+var VERSION = "4.0.235";
+
 // src/create/iso-base-media/create-ilst.ts
 var createIlst = (items) => {
   return addSize(combineUint8Arrays([
@@ -1975,7 +2112,7 @@ var createPaddedMoovAtom = ({
       hdlr: createHdlr("mdir"),
       ilst: createIlst([
         createToo("WebCodecs"),
-        createCmt("Made with @remotion/webcodecs")
+        createCmt(`Made with @remotion/webcodecs ${VERSION}`)
       ])
     }))
   }), HEADER_LENGTH);
@@ -2583,11 +2720,25 @@ var getDisplayWidthSegment = (track) => {
 };
 var getTracksSegment = (segment) => {
   const tracksSegment = segment.value.find((b) => b.type === "Tracks");
-  if (!tracksSegment || tracksSegment.type !== "Tracks") {
+  if (!tracksSegment) {
     return null;
   }
   return tracksSegment;
 };
+var getTrackWithUid = (segment, trackUid) => {
+  const tracksSegment = getTracksSegment(segment);
+  if (!tracksSegment) {
+    return null;
+  }
+  const trackEntries = tracksSegment.value.filter((t) => t.type === "TrackEntry");
+  const trackEntry2 = trackEntries.find((entry) => {
+    return entry?.value.find((t) => t.type === "TrackUID" && t.value === trackUid);
+  });
+  if (!trackEntry2) {
+    return null;
+  }
+  return trackEntry2.value.find((t) => t.type === "TrackNumber")?.value.value ?? null;
+};
 var getVideoSegment = (track) => {
   const videoSegment2 = track.value.find((b) => b.type === "Video");
   if (!videoSegment2 || videoSegment2.type !== "Video") {
@@ -3483,6 +3634,194 @@ var getMdatBox = (anySegment) => {
   return mdat;
 };
 
+// src/metadata/metadata-from-iso.ts
+var mapToKey = (index) => {
+  if (index === 2839630420) {
+    return "artist";
+  }
+  if (index === 2841734242) {
+    return "album";
+  }
+  if (index === 2841865588) {
+    return "comment";
+  }
+  if (index === 2841928057) {
+    return "releaseDate";
+  }
+  if (index === 2842125678) {
+    return "genre";
+  }
+  if (index === 2842583405) {
+    return "title";
+  }
+  if (index === 2842980207) {
+    return "encoder";
+  }
+  if (index === 2843177588) {
+    return "writer";
+  }
+  if (index === 2841866361) {
+    return "copyright";
+  }
+  if (index === 2841930098) {
+    return "director";
+  }
+  if (index === 2842718820) {
+    return "producer";
+  }
+  if (index === 2841929075) {
+    return "description";
+  }
+  return null;
+};
+var parseIlstBoxWithoutKeys = (ilstBox) => {
+  return ilstBox.entries.map((entry) => {
+    const key = mapToKey(entry.index);
+    if (!key) {
+      return null;
+    }
+    if (entry.value.type === "unknown") {
+      return null;
+    }
+    return {
+      trackId: null,
+      key,
+      value: entry.value.value
+    };
+  }).filter(truthy);
+};
+var parseIsoMetaBox = (meta, trackId) => {
+  const ilstBox = meta.children.find((b) => b.type === "ilst-box");
+  const keysBox = meta.children.find((b) => b.type === "keys-box");
+  if (!ilstBox || !keysBox) {
+    if (ilstBox) {
+      return parseIlstBoxWithoutKeys(ilstBox);
+    }
+    return [];
+  }
+  const entries = [];
+  for (let i = 0;i < ilstBox.entries.length; i++) {
+    const ilstEntry = ilstBox.entries[i];
+    const keysEntry = keysBox.entries[i];
+    if (ilstEntry.value.type !== "unknown") {
+      const value = typeof ilstEntry.value.value === "string" && ilstEntry.value.value.endsWith("\x00") ? ilstEntry.value.value.slice(0, -1) : ilstEntry.value.value;
+      entries.push({
+        key: keysEntry.value,
+        value,
+        trackId
+      });
+    }
+  }
+  return entries;
+};
+var getMetadataFromIsoBase = (isoBase) => {
+  const moov = getMoovBox(isoBase.boxes);
+  if (!moov) {
+    return [];
+  }
+  const traks = getTraks(moov);
+  const meta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "meta");
+  const udta = moov.children.find((b) => b.type === "regular-box" && b.boxType === "udta");
+  const metaInUdta = udta?.children.find((b) => {
+    return b.type === "regular-box" && b.boxType === "meta";
+  });
+  const metaInTracks = traks.map((t) => {
+    const metaBox = t.children.find((child) => child.type === "regular-box" && child.boxType === "meta");
+    if (metaBox) {
+      const tkhd = getTkhdBox(t);
+      if (!tkhd) {
+        throw new Error("No tkhd box found");
+      }
+      return parseIsoMetaBox(metaBox, tkhd.trackId);
+    }
+    return null;
+  }).filter(truthy);
+  return [
+    ...meta ? parseIsoMetaBox(meta, null) : [],
+    ...metaInUdta ? parseIsoMetaBox(metaInUdta, null) : [],
+    ...metaInTracks.flat(1)
+  ];
+};
+
+// src/metadata/metadata-from-matroska.ts
+var removeEndZeroes = (value) => {
+  return value.endsWith("\x00") ? removeEndZeroes(value.slice(0, -1)) : value;
+};
+var parseSimpleTagIntoEbml = (children, trackId) => {
+  const tagName = children.find((c) => c.type === "TagName");
+  const tagString = children.find((c) => c.type === "TagString");
+  if (!tagName || !tagString) {
+    return null;
+  }
+  return {
+    trackId,
+    key: tagName.value.toLowerCase(),
+    value: removeEndZeroes(tagString.value)
+  };
+};
+var getMetadataFromMatroska = (structure) => {
+  const entries = [];
+  for (const segment of structure.boxes) {
+    if (segment.type !== "Segment") {
+      continue;
+    }
+    const tags2 = segment.value.filter((s) => s.type === "Tags");
+    for (const tag of tags2) {
+      for (const child of tag.value) {
+        if (child.type !== "Tag") {
+          continue;
+        }
+        let trackId = null;
+        const target = child.value.find((c) => c.type === "Targets");
+        if (target) {
+          const tagTrackId = target.value.find((c) => c.type === "TagTrackUID")?.value;
+          if (tagTrackId) {
+            trackId = getTrackWithUid(segment, tagTrackId);
+          }
+        }
+        const simpleTags = child.value.filter((s) => s.type === "SimpleTag");
+        for (const simpleTag of simpleTags) {
+          const parsed = parseSimpleTagIntoEbml(simpleTag.value, trackId);
+          if (parsed) {
+            entries.push(parsed);
+          }
+        }
+      }
+    }
+  }
+  return entries;
+};
+
+// src/metadata/metadata-from-riff.ts
+var getMetadataFromRiff = (structure) => {
+  const boxes = structure.boxes.find((b) => b.type === "list-box" && b.listType === "INFO");
+  if (!boxes) {
+    return [];
+  }
+  const { children } = boxes;
+  return children.map((child) => {
+    if (child.type !== "isft-box") {
+      return null;
+    }
+    return {
+      trackId: null,
+      key: "encoder",
+      value: child.software
+    };
+  }).filter(truthy);
+};
+
+// src/metadata/get-metadata.ts
+var getMetadata = (structure) => {
+  if (structure.type === "matroska") {
+    return getMetadataFromMatroska(structure);
+  }
+  if (structure.type === "riff") {
+    return getMetadataFromRiff(structure);
+  }
+  return getMetadataFromIsoBase(structure);
+};
+
 // src/boxes/riff/traversal.ts
 var isRiffAvi = (structure) => {
   return structure.boxes.some((box) => box.type === "riff-header" && box.fileType === "AVI");
@@ -4012,6 +4351,15 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   const discard = (length) => {
     counter.increment(length);
   };
+  const readUntilNullTerminator = () => {
+    const bytes = [];
+    let byte;
+    while ((byte = getUint8()) !== 0) {
+      bytes.push(byte);
+    }
+    counter.decrement(1);
+    return new TextDecoder().decode(new Uint8Array(bytes));
+  };
   const getUint8 = () => {
     const val = view.getUint8(counter.getDiscardedOffset());
     counter.increment(1);
@@ -4067,6 +4415,11 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     counter.increment(8);
     return val;
   };
+  const getInt64 = (littleEndian = false) => {
+    const val = view.getBigInt64(counter.getDiscardedOffset(), littleEndian);
+    counter.increment(8);
+    return val;
+  };
   const startBox = (size) => {
     const startOffset = counter.getOffset();
     return {
@@ -4328,6 +4681,13 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       counter.increment(3);
       return val1 << 16 | val2 << 8 | val3;
     },
+    getInt24: () => {
+      const val1 = view.getInt8(counter.getDiscardedOffset());
+      const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
+      const val3 = view.getUint8(counter.getDiscardedOffset() + 2);
+      counter.increment(3);
+      return val1 << 16 | val2 << 8 | val3;
+    },
     getInt16: () => {
       const val = view.getInt16(counter.getDiscardedOffset());
       counter.increment(2);
@@ -4335,6 +4695,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     },
     getUint32,
     getUint64,
+    getInt64,
     getFixedPointUnsigned1616Number: () => {
       const val = getUint32();
       return val / 2 ** 16;
@@ -4365,6 +4726,7 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
       counter.increment(8);
       return val;
     },
+    readUntilNullTerminator,
     getFloat32: () => {
       const val = view.getFloat32(counter.getDiscardedOffset());
       counter.increment(4);
@@ -4615,6 +4977,27 @@ var getVideoCodecString = (trakBox) => {
   return videoSample.format;
 };
 
+// src/boxes/iso-base-media/get-actual-number-of-channels.ts
+var getActualDecoderParameters = ({
+  audioCodec,
+  codecPrivate: codecPrivate2,
+  numberOfChannels,
+  sampleRate
+}) => {
+  if (audioCodec !== "aac") {
+    return { numberOfChannels, sampleRate, codecPrivate: codecPrivate2 };
+  }
+  if (codecPrivate2 === null) {
+    return { numberOfChannels, sampleRate, codecPrivate: codecPrivate2 };
+  }
+  const parsed = parseAacCodecPrivate(codecPrivate2);
+  return {
+    numberOfChannels: parsed.channelConfiguration,
+    sampleRate: parsed.sampleRate,
+    codecPrivate: createAacCodecPrivate(parsed)
+  };
+};
+
 // src/boxes/iso-base-media/make-track.ts
 var makeBaseMediaTrack = (trakBox) => {
   const tkhdBox = getTkhdBox(trakBox);
@@ -4636,17 +5019,25 @@ var makeBaseMediaTrack = (trakBox) => {
       throw new Error("Could not find sample rate");
     }
     const { codecString, description } = getAudioCodecStringFromTrak(trakBox);
+    const codecPrivate2 = getCodecPrivateFromTrak(trakBox) ?? description ?? null;
+    const codecWithoutConfig = getAudioCodecFromTrack(trakBox);
+    const actual = getActualDecoderParameters({
+      audioCodec: codecWithoutConfig,
+      codecPrivate: codecPrivate2,
+      numberOfChannels,
+      sampleRate
+    });
     return {
       type: "audio",
       trackId: tkhdBox.trackId,
       timescale: timescaleAndDuration.timescale,
       codec: codecString,
-      numberOfChannels,
-      sampleRate,
-      description,
+      numberOfChannels: actual.numberOfChannels,
+      sampleRate: actual.sampleRate,
+      description: actual.codecPrivate ?? undefined,
       trakBox,
-      codecPrivate: getCodecPrivateFromTrak(trakBox) ?? description ?? null,
-      codecWithoutConfig: getAudioCodecFromTrack(trakBox)
+      codecPrivate: actual.codecPrivate,
+      codecWithoutConfig
     };
   }
   if (!trakBoxContainsVideo(trakBox)) {
@@ -4734,6 +5125,7 @@ var addAvcProfileToTrack = (track, avc1Profile) => {
 var MEDIA_PARSER_RIFF_TIMESCALE = 1e6;
 
 // src/boxes/riff/get-tracks-from-avi.ts
+var TO_BE_OVERRIDDEN_LATER = "to-be-overriden-later";
 var getNumberOfTracks = (structure) => {
   const avihBox = getAvihBox(structure);
   if (avihBox) {
@@ -4771,7 +5163,7 @@ var makeAviVideoTrack = ({
   }
   return {
     codecPrivate: null,
-    codec: "to-be-overriden-later",
+    codec: TO_BE_OVERRIDDEN_LATER,
     codecWithoutConfig: "h264",
     codedHeight: strf.height,
     codedWidth: strf.width,
@@ -4828,9 +5220,13 @@ var hasAllTracksFromAvi = (structure, state) => {
   if (!isRiffAvi(structure)) {
     throw new Error("Not an AVI file");
   }
-  const numberOfTracks = getNumberOfTracks(structure);
-  const tracks2 = getTracksFromAvi(structure, state);
-  return tracks2.videoTracks.length + tracks2.audioTracks.length + tracks2.otherTracks.length === numberOfTracks;
+  try {
+    const numberOfTracks = getNumberOfTracks(structure);
+    const tracks2 = getTracksFromAvi(structure, state);
+    return tracks2.videoTracks.length + tracks2.audioTracks.length + tracks2.otherTracks.length === numberOfTracks;
+  } catch {
+    return false;
+  }
 };
 
 // src/make-hvc1-codec-strings.ts
@@ -5217,7 +5613,7 @@ var hasTracks = (structure, state) => {
   if (structure.type === "matroska") {
     const mainSegment = getMainSegment(structure.boxes);
     if (!mainSegment) {
-      throw new Error("No main segment found");
+      return false;
     }
     return getTracksSegment(mainSegment) !== null;
   }
@@ -5752,9 +6148,8 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "internalStats") {
-      if (hasInfo.internalStats && returnValue.internalStats === undefined) {
+      if (hasInfo.internalStats) {
         const internalStats = state.getInternalStats();
-        moreFields.onInternalStats?.(internalStats);
         returnValue.internalStats = internalStats;
       }
       continue;
@@ -5789,41 +6184,49 @@ var emitAvailableInfo = ({
       }
       continue;
     }
+    if (key === "metadata") {
+      if (returnValue.metadata === undefined && hasInfo.metadata && parseResult) {
+        const metadata = getMetadata(parseResult.segments);
+        moreFields.onMetadata?.(metadata);
+        returnValue.metadata = metadata;
+      }
+      continue;
+    }
     throw new Error(`Unhandled key: ${key}`);
   }
 };
 
 // src/has-all-info.ts
-var getAvailableInfo = (options, parseResult, state) => {
+var getAvailableInfo = (options, structure, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
   const infos = keys.map(([_key]) => {
     const key = _key;
     if (key === "structure") {
-      return Boolean(parseResult && parseResult.status === "done");
+      return false;
     }
     if (key === "durationInSeconds") {
-      return Boolean(parseResult && hasDuration(parseResult.segments, state));
+      return Boolean(structure && hasDuration(structure, state));
     }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
-      return Boolean(parseResult && hasDimensions(parseResult.segments, state));
+      return Boolean(structure && hasDimensions(structure, state));
     }
     if (key === "fps") {
-      return Boolean(parseResult && hasFps(parseResult.segments));
+      return Boolean(structure && hasFps(structure));
     }
     if (key === "isHdr") {
-      return Boolean(parseResult && hasHdr(parseResult.segments, state));
+      return Boolean(structure && hasHdr(structure, state));
     }
     if (key === "videoCodec") {
-      return Boolean(parseResult && hasVideoCodec(parseResult.segments, state));
+      return Boolean(structure && hasVideoCodec(structure, state));
     }
     if (key === "audioCodec") {
-      return Boolean(parseResult && hasAudioCodec(parseResult.segments, state));
+      return Boolean(structure && hasAudioCodec(structure, state));
     }
     if (key === "tracks") {
-      return Boolean(parseResult && hasTracks(parseResult.segments, state));
+      return Boolean(structure && hasTracks(structure, state));
     }
     if (key === "internalStats") {
-      return false;
+      return true;
     }
     if (key === "size") {
       return true;
@@ -5832,7 +6235,10 @@ var getAvailableInfo = (options, parseResult, state) => {
       return true;
     }
     if (key === "container") {
-      return Boolean(parseResult && hasContainer(parseResult.segments));
+      return Boolean(structure && hasContainer(structure));
+    }
+    if (key === "metadata") {
+      return false;
     }
     throw new Error(`Unknown key: ${key}`);
   });
@@ -5843,6 +6249,14 @@ var getAvailableInfo = (options, parseResult, state) => {
   }
   return Object.fromEntries(entries);
 };
+var hasAllInfo = ({
+  fields,
+  state,
+  structure
+}) => {
+  const availableInfo = getAvailableInfo(fields ?? {}, structure, state);
+  return Object.values(availableInfo).every(Boolean) && (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks());
+};
 
 // src/register-track.ts
 var registerTrack = async ({
@@ -6174,6 +6588,119 @@ var parseMdhd = ({
   };
 };
 
+// src/boxes/iso-base-media/meta/hdlr.ts
+var parseHdlr = ({
+  iterator,
+  size,
+  offset
+}) => {
+  const box = iterator.startBox(size - 8);
+  const version = iterator.getUint8();
+  if (version !== 0) {
+    throw new Error(`Unsupported hdlr version: ${version}`);
+  }
+  iterator.discard(3);
+  iterator.discard(4);
+  const hdlrType = iterator.getByteString(4);
+  iterator.discard(4);
+  iterator.discard(4);
+  iterator.discard(4);
+  const componentName = iterator.readUntilNullTerminator();
+  box.discardRest();
+  return Promise.resolve({
+    type: "hdlr-box",
+    boxSize: size,
+    offset,
+    hdlrType,
+    componentName
+  });
+};
+
+// src/boxes/iso-base-media/meta/ilst.ts
+var parseFromWellKnownType = (wellKnownType, iterator, size) => {
+  if (wellKnownType === 1) {
+    const value = iterator.getByteString(size);
+    return { type: "text", value };
+  }
+  if (wellKnownType === 21) {
+    if (size === 1) {
+      return { type: "number", value: iterator.getInt8() };
+    }
+    if (size === 2) {
+      return { type: "number", value: iterator.getInt16() };
+    }
+    if (size === 3) {
+      return { type: "number", value: iterator.getInt24() };
+    }
+    if (size === 4) {
+      return { type: "number", value: iterator.getInt32() };
+    }
+    if (size === 8) {
+      return { type: "number", value: Number(iterator.getInt64()) };
+    }
+    throw new Error(`Weird size for number ${size}`);
+  }
+  if (wellKnownType === 22) {
+    if (size === 1) {
+      return { type: "number", value: iterator.getUint8() };
+    }
+    if (size === 2) {
+      return { type: "number", value: iterator.getUint16() };
+    }
+    if (size === 3) {
+      return { type: "number", value: iterator.getUint24() };
+    }
+    if (size === 4) {
+      return { type: "number", value: iterator.getUint32() };
+    }
+    throw new Error(`Weird size for number ${size}`);
+  }
+  if (wellKnownType === 23) {
+    if (size === 4) {
+      return { type: "number", value: iterator.getFloat32() };
+    }
+    if (size === 8) {
+      return { type: "number", value: iterator.getFloat64() };
+    }
+    throw new Error(`Weird size for number ${size}`);
+  }
+  iterator.discard(size);
+  return { type: "unknown", value: null };
+};
+var parseIlstBox = ({
+  iterator,
+  size,
+  offset
+}) => {
+  const box = iterator.startBox(size - 8);
+  const entries = [];
+  while (iterator.counter.getOffset() < size + offset) {
+    const metadataSize = iterator.getUint32();
+    const index = iterator.getUint32();
+    if (index === 1936419184) {
+      iterator.discard(metadataSize - 8);
+      continue;
+    }
+    const innerSize = iterator.getUint32();
+    const type = iterator.getAtom();
+    const typeIndicator = iterator.getUint8();
+    if (typeIndicator !== 0) {
+      throw new Error("Expected type indicator to be 0");
+    }
+    const wellKnownType = iterator.getUint24();
+    iterator.discard(4);
+    const value = parseFromWellKnownType(wellKnownType, iterator, innerSize - 16);
+    entries.push({ index, type, wellKnownType, value });
+  }
+  box.discardRest();
+  return {
+    type: "ilst-box",
+    boxSize: size,
+    offset,
+    entries
+  };
+};
+
 // src/boxes/iso-base-media/moov/moov.ts
 var parseMoov = async ({
   iterator,
@@ -6181,7 +6708,8 @@ var parseMoov = async ({
   size,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const children = await parseIsoBaseMediaBoxes({
     iterator,
@@ -6191,7 +6719,8 @@ var parseMoov = async ({
     options,
     continueMdat: false,
     signal,
-    logLevel
+    logLevel,
+    fields
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -6495,13 +7024,47 @@ var parseHvcc = ({
   };
 };
 
+// src/boxes/iso-base-media/stsd/keys.ts
+var parseKeys = ({
+  iterator,
+  offset,
+  size
+}) => {
+  const box = iterator.startBox(size - 8);
+  const version = iterator.getUint8();
+  iterator.discard(3);
+  const entryCount = iterator.getUint32();
+  const entries = [];
+  for (let i = 0;i < entryCount; i++) {
+    const keySize = iterator.getUint32();
+    const namespace = iterator.getAtom();
+    const value = iterator.getByteString(keySize - 8);
+    const entry = {
+      keySize,
+      namespace,
+      value
+    };
+    entries.push(entry);
+  }
+  box.discardRest();
+  return {
+    type: "keys-box",
+    boxSize: size,
+    offset,
+    version,
+    entryCount,
+    entries
+  };
+};
+
 // src/boxes/iso-base-media/stsd/mebx.ts
 var parseMebx = async ({
   iterator,
   offset,
   size,
   options,
-  signal
+  signal,
+  fields
 }) => {
   iterator.discard(6);
   const dataReferenceIndex = iterator.getUint16();
@@ -6513,7 +7076,8 @@ var parseMebx = async ({
     options,
     continueMdat: false,
     signal,
-    logLevel: "info"
+    logLevel: "info",
+    fields
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -6679,7 +7243,8 @@ var processSample = async ({
   iterator,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
@@ -6724,7 +7289,8 @@ var processSample = async ({
         options,
         continueMdat: false,
         signal,
-        logLevel
+        logLevel,
+        fields
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -6771,7 +7337,8 @@ var processSample = async ({
         options,
         continueMdat: false,
         signal,
-        logLevel
+        logLevel,
+        fields
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -6822,7 +7389,8 @@ var processSample = async ({
         options,
         continueMdat: false,
         signal,
-        logLevel
+        logLevel,
+        fields
       });
       if (children.status === "incomplete") {
         throw new Error("Incomplete boxes are not allowed");
@@ -6876,7 +7444,8 @@ var processSample = async ({
       options,
       continueMdat: false,
       signal,
-      logLevel
+      logLevel,
+      fields
     }) : (iterator.discard(bytesRemainingInBox), { status: "done", segments: { boxes: [], type: "iso-base-media" } });
     if (children.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -6913,7 +7482,8 @@ var parseSamples = async ({
   maxBytes,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const samples = [];
   const initialOffset = iterator.counter.getOffset();
@@ -6922,7 +7492,8 @@ var parseSamples = async ({
       iterator,
       options,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
     if (sample) {
       samples.push(sample);
@@ -6937,7 +7508,8 @@ var parseStsd = async ({
   offset,
   size,
   options,
-  signal
+  signal,
+  fields
 }) => {
   const version = iterator.getUint8();
   if (version !== 0) {
@@ -6951,7 +7523,8 @@ var parseStsd = async ({
     maxBytes: bytesRemainingInBox,
     options,
     signal,
-    logLevel: "info"
+    logLevel: "info",
+    fields
   });
   if (boxes.length !== numberOfEntries) {
     throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
@@ -7222,7 +7795,8 @@ var parseTrak = async ({
   offsetAtStart,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const children = await parseIsoBaseMediaBoxes({
     iterator: data,
@@ -7232,7 +7806,8 @@ var parseTrak = async ({
     options,
     continueMdat: false,
     signal,
-    logLevel
+    logLevel,
+    fields
   });
   if (children.status === "incomplete") {
     throw new Error("Incomplete boxes are not allowed");
@@ -7294,9 +7869,10 @@ var getChildren = async ({
   bytesRemainingInBox,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
-  const parseChildren = boxType === "mdia" || boxType === "minf" || boxType === "stbl" || boxType === "moof" || boxType === "dims" || boxType === "wave" || boxType === "traf" || boxType === "stsb";
+  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 parsed = await parseIsoBaseMediaBoxes({
       iterator,
@@ -7306,7 +7882,8 @@ var getChildren = async ({
       options,
       continueMdat: false,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
     if (parsed.status === "incomplete") {
       throw new Error("Incomplete boxes are not allowed");
@@ -7356,7 +7933,8 @@ var processBox = async ({
   parsedBoxes,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const fileOffset = iterator.counter.getOffset();
   const bytesRemaining = iterator.bytesRemaining();
@@ -7385,7 +7963,7 @@ var processBox = async ({
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
-      const shouldSkip = (options.canSkipVideoData || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, options.parserState)) && options.supportsContentRange;
+      const shouldSkip = options.parserState.maySkipVideoData() || !hasTracks({ type: "iso-base-media", boxes: parsedBoxes }, options.parserState) && options.supportsContentRange;
       if (shouldSkip) {
         const skipTo = fileOffset + boxSize;
         const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -7484,7 +8062,8 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      signal
+      signal,
+      fields
     });
     return {
       type: "complete",
@@ -7578,7 +8157,39 @@ var processBox = async ({
       offset: fileOffset,
       size: boxSize,
       options,
-      signal
+      signal,
+      fields
+    });
+    return {
+      type: "complete",
+      box,
+      size: boxSize,
+      skipTo: null
+    };
+  }
+  if (boxType === "hdlr") {
+    const box = await parseHdlr({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "complete",
+      box,
+      size: boxSize,
+      skipTo: null
+    };
+  }
+  if (boxType === "keys") {
+    const box = parseKeys({ iterator, size: boxSize, offset: fileOffset });
+    return {
+      type: "complete",
+      box,
+      size: boxSize,
+      skipTo: null
+    };
+  }
+  if (boxType === "ilst") {
+    const box = parseIlstBox({
+      iterator,
+      offset: fileOffset,
+      size: boxSize
     });
     return {
       type: "complete",
@@ -7594,8 +8205,10 @@ var processBox = async ({
       size: boxSize,
       options,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
+    options.parserState.tracks.setIsDone();
     return {
       type: "complete",
       box,
@@ -7610,7 +8223,8 @@ var processBox = async ({
       offsetAtStart: fileOffset,
       options,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
     const transformedTrack = makeBaseMediaTrack(box);
     if (transformedTrack) {
@@ -7743,7 +8357,8 @@ var processBox = async ({
     bytesRemainingInBox,
     options,
     signal,
-    logLevel
+    logLevel,
+    fields
   });
   return {
     type: "complete",
@@ -7766,7 +8381,8 @@ var parseIsoBaseMediaBoxes = async ({
   options,
   continueMdat,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   const structure = {
     type: "iso-base-media",
@@ -7788,7 +8404,8 @@ var parseIsoBaseMediaBoxes = async ({
       parsedBoxes: initialBoxes,
       options,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
     if (result.type === "incomplete") {
       if (Number.isFinite(maxBytes)) {
@@ -7806,7 +8423,8 @@ var parseIsoBaseMediaBoxes = async ({
             options,
             continueMdat: false,
             signal,
-            logLevel
+            logLevel,
+            fields
           });
         },
         skipTo: null
@@ -7825,7 +8443,8 @@ var parseIsoBaseMediaBoxes = async ({
             options,
             continueMdat: result,
             signal,
-            logLevel
+            logLevel,
+            fields
           }));
         },
         skipTo: null
@@ -7841,6 +8460,12 @@ var parseIsoBaseMediaBoxes = async ({
       break;
     } else {
       structure.boxes.push(result.box);
+      if (hasAllInfo({ fields, state: options.parserState, structure })) {
+        return {
+          status: "done",
+          segments: structure
+        };
+      }
     }
     if (result.skipTo !== null) {
       if (!options.supportsContentRange) {
@@ -7858,7 +8483,8 @@ var parseIsoBaseMediaBoxes = async ({
             options,
             continueMdat: false,
             signal,
-            logLevel
+            logLevel,
+            fields
           });
         },
         skipTo: result.skipTo
@@ -7877,7 +8503,8 @@ var parseIsoBaseMediaBoxes = async ({
             options,
             continueMdat: false,
             signal,
-            logLevel
+            logLevel,
+            fields
           });
         },
         skipTo: null
@@ -7886,8 +8513,8 @@ var parseIsoBaseMediaBoxes = async ({
     iterator.removeBytesRead();
   }
   const mdatState = getMdatBox(structure.boxes);
-  const skipped = mdatState?.status === "samples-skipped" && !options.canSkipVideoData && options.supportsContentRange;
-  const buffered = mdatState?.status === "samples-buffered" && !options.canSkipVideoData;
+  const skipped = mdatState?.status === "samples-skipped" && !options.parserState.maySkipVideoData() && options.supportsContentRange;
+  const buffered = mdatState?.status === "samples-buffered" && !options.parserState.maySkipVideoData();
   if (skipped || buffered) {
     return {
       status: "incomplete",
@@ -7904,7 +8531,8 @@ var parseIsoBaseMediaBoxes = async ({
           options,
           continueMdat: false,
           signal,
-          logLevel
+          logLevel,
+          fields
         });
       },
       skipTo: skipped ? mdatState.fileOffset : null
@@ -8057,6 +8685,7 @@ var handleChunk = async ({
     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 options.parserState.onVideoSample(trackId, {
       cts: timestamp,
@@ -8067,26 +8696,26 @@ var handleChunk = async ({
       trackId,
       type: keyOrDelta.type === "keyframe" ? "key" : "delta"
     });
-  } else {
-    const audioChunk = ckId.match(/^([0-9]{2})wb$/);
-    if (audioChunk) {
-      const trackId = parseInt(audioChunk[1], 10);
-      const strh = getStrhForIndex(structure, trackId);
-      const samplesPerSecond = strh.rate / strh.scale;
-      const nthSample = options.parserState.getSamplesForTrack(trackId);
-      const timeInSec = nthSample / samplesPerSecond;
-      const timestamp = timeInSec * MEDIA_PARSER_RIFF_TIMESCALE;
-      const duration2 = 1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE;
-      await options.parserState.onAudioSample(trackId, {
-        cts: timestamp,
-        dts: timestamp,
-        data: iterator.getSlice(ckSize),
-        duration: duration2,
-        timestamp,
-        trackId,
-        type: "key"
-      });
-    }
+    return;
+  }
+  const audioChunk = ckId.match(/^([0-9]{2})wb$/);
+  if (audioChunk) {
+    const trackId = parseInt(audioChunk[1], 10);
+    const strh = getStrhForIndex(structure, trackId);
+    const samplesPerSecond = strh.rate / strh.scale;
+    const nthSample = options.parserState.getSamplesForTrack(trackId);
+    const timeInSec = nthSample / samplesPerSecond;
+    const timestamp = timeInSec * MEDIA_PARSER_RIFF_TIMESCALE;
+    const duration2 = 1 / samplesPerSecond * MEDIA_PARSER_RIFF_TIMESCALE;
+    await options.parserState.onAudioSample(trackId, {
+      cts: timestamp,
+      dts: timestamp,
+      data: iterator.getSlice(ckSize),
+      duration: duration2,
+      timestamp,
+      trackId,
+      type: "key"
+    });
   }
 };
 var parseMovi = async ({
@@ -8106,6 +8735,15 @@ var parseMovi = async ({
     }
     const ckId = iterator.getByteString(4);
     const ckSize = iterator.getUint32Le();
+    if (options.parserState.maySkipVideoData() && options.parserState.getAvcProfile()) {
+      return {
+        type: "complete",
+        box: {
+          type: "movi-box"
+        },
+        skipTo: maxOffset
+      };
+    }
     if (iterator.bytesRemaining() < ckSize) {
       iterator.counter.decrement(8);
       return {
@@ -8128,7 +8766,8 @@ var parseMovi = async ({
       type: "complete",
       box: {
         type: "movi-box"
-      }
+      },
+      skipTo: null
     };
   }
   if (iterator.counter.getOffset() > maxOffset) {
@@ -8210,6 +8849,24 @@ var parseFmtBox = ({
   };
 };
 
+// src/boxes/riff/parse-isft.ts
+var parseIsft = ({
+  iterator,
+  size
+}) => {
+  const { expectNoMoreBytes } = iterator.startBox(size);
+  const software = iterator.getByteString(size - 1);
+  const last = iterator.getUint8();
+  if (last !== 0) {
+    throw new Error(`Expected 0 byte, got ${last}`);
+  }
+  expectNoMoreBytes();
+  return {
+    type: "isft-box",
+    software
+  };
+};
+
 // src/boxes/riff/parse-list-box.ts
 var parseListBox = async ({
   iterator,
@@ -8377,6 +9034,9 @@ var parseRiffBox = ({
   if (id === "LIST") {
     return parseListBox({ iterator, size, options });
   }
+  if (id === "ISFT") {
+    return Promise.resolve(parseIsft({ iterator, size }));
+  }
   if (id === "avih") {
     return Promise.resolve(parseAvih({ iterator, size }));
   }
@@ -8437,7 +9097,8 @@ var expectRiffBox = async ({
       size: ckSize,
       boxes: structure.boxes,
       options
-    })
+    }),
+    skipTo: null
   };
 };
 
@@ -8465,10 +9126,8 @@ var continueAfterRiffBoxResult = ({
       skipTo: null
     });
   }
-  if (result.type === "complete") {
-    if (result.box) {
-      structure.boxes.push(result.box);
-    }
+  if (result.type === "complete" && result.box) {
+    structure.boxes.push(result.box);
   }
   return parseRiffBody({ iterator, maxOffset, options, structure });
 };
@@ -8484,6 +9143,22 @@ var parseRiffBody = async ({
       options,
       structure
     });
+    if (result.type === "complete" && result.skipTo !== null) {
+      return {
+        status: "incomplete",
+        skipTo: result.skipTo,
+        segments: structure,
+        continueParsing() {
+          return Promise.resolve(continueAfterRiffBoxResult({
+            iterator,
+            maxOffset,
+            options,
+            result,
+            structure
+          }));
+        }
+      };
+    }
     if (result.type === "incomplete") {
       return {
         status: "incomplete",
@@ -8504,6 +9179,15 @@ var parseRiffBody = async ({
       continue;
     }
     structure.boxes.push(result.box);
+    if (result.box.type === "list-box" && result.box.listType === "hdrl") {
+      const tracks2 = getTracks(structure, options.parserState);
+      if (!tracks2.videoTracks.some((t) => t.codec === TO_BE_OVERRIDDEN_LATER)) {
+        options.parserState.tracks.setIsDone();
+      }
+    }
+    if (result.box.type === "wave-format-box") {
+      options.parserState.tracks.setIsDone();
+    }
     if (result.box.type === "strf-box-video" || result.box.type === "strf-box-audio") {
       const strh = getStrhBox(structure.boxes);
       const strf = getStrfBox(structure.boxes);
@@ -8543,7 +9227,8 @@ var parseRiffBody = async ({
 };
 var parseRiff = ({
   iterator,
-  options
+  options,
+  fields
 }) => {
   const structure = { type: "riff", boxes: [] };
   const riff = iterator.getByteString(4);
@@ -8556,6 +9241,12 @@ var parseRiff = ({
     throw new Error(`File type ${fileType} not supported`);
   }
   structure.boxes.push({ type: "riff-header", fileSize: size, fileType });
+  if (hasAllInfo({ fields, structure, state: options.parserState })) {
+    return Promise.resolve({
+      status: "done",
+      segments: structure
+    });
+  }
   return parseRiffBody({ iterator, structure, maxOffset: Infinity, options });
 };
 
@@ -8711,7 +9402,7 @@ var parseEbml = async (iterator, parserContext) => {
   if (hasInMap.type === "hex-string") {
     return {
       type: hasInMap.name,
-      value: "0x" + [...iterator.getSlice(size)].map((b) => b.toString(16).padStart(2, "0")).join(""),
+      value: "0x" + [...iterator.getSlice(size)].map((b) => b.toString(16).padStart(2, "0")).join("").replace(new RegExp("^" + hex), ""),
       minVintWidth
     };
   }
@@ -8859,7 +9550,9 @@ var expectSegment = async ({
   iterator,
   parserContext,
   offset,
-  children
+  children,
+  fields,
+  topLevelStructure
 }) => {
   iterator.counter.decrement(iterator.counter.getOffset() - offset);
   if (iterator.bytesRemaining() === 0) {
@@ -8870,7 +9563,9 @@ var expectSegment = async ({
           iterator,
           parserContext,
           offset,
-          children
+          children,
+          fields,
+          topLevelStructure
         });
       },
       segment: null
@@ -8886,7 +9581,9 @@ var expectSegment = async ({
           iterator,
           parserContext,
           offset,
-          children
+          children,
+          fields,
+          topLevelStructure
         });
       },
       segment: null
@@ -8900,7 +9597,14 @@ var expectSegment = async ({
     return {
       status: "incomplete",
       continueParsing: () => {
-        return expectSegment({ iterator, parserContext, offset, children });
+        return expectSegment({
+          iterator,
+          parserContext,
+          offset,
+          children,
+          fields,
+          topLevelStructure
+        });
       },
       segment: null
     };
@@ -8917,7 +9621,9 @@ var expectSegment = async ({
       length,
       children: newSegment.value,
       parserContext,
-      startOffset: iterator.counter.getOffset()
+      startOffset: iterator.counter.getOffset(),
+      fields,
+      topLevelStructure
     });
     if (main.status === "incomplete") {
       return {
@@ -8945,7 +9651,14 @@ var expectSegment = async ({
       status: "incomplete",
       segment: null,
       continueParsing: () => {
-        return expectSegment({ iterator, parserContext, offset, children });
+        return expectSegment({
+          iterator,
+          parserContext,
+          offset,
+          children,
+          fields,
+          topLevelStructure
+        });
       }
     };
   }
@@ -8981,10 +9694,22 @@ var parseSegment = async ({
 // src/boxes/webm/segments/parse-children.ts
 var processParseResult = ({
   parseResult,
-  children
+  children,
+  state,
+  fields,
+  topLevelStructure
 }) => {
   if (parseResult.segment && !children.includes(parseResult.segment)) {
     children.push(parseResult.segment);
+    if (hasAllInfo({ fields, state, structure: topLevelStructure })) {
+      return {
+        status: "done",
+        segment: parseResult.segment
+      };
+    }
+    if (parseResult.segment.type === "Tracks") {
+      state.tracks.setIsDone();
+    }
   }
   if (parseResult.status === "incomplete") {
     return {
@@ -8994,7 +9719,10 @@ var processParseResult = ({
         const newParseResult = await parseResult.continueParsing();
         return processParseResult({
           children,
-          parseResult: newParseResult
+          parseResult: newParseResult,
+          state,
+          fields,
+          topLevelStructure
         });
       }
     };
@@ -9008,17 +9736,24 @@ var expectAndProcessSegment = async ({
   iterator,
   parserContext,
   offset,
-  children
+  children,
+  fields,
+  topLevelStructure
 }) => {
   const segment = await expectSegment({
     iterator,
     parserContext,
     offset,
-    children
+    children,
+    fields,
+    topLevelStructure
   });
   return processParseResult({
     children,
-    parseResult: segment
+    parseResult: segment,
+    state: parserContext.parserState,
+    fields,
+    topLevelStructure
   });
 };
 var continueAfterSegmentResult = async ({
@@ -9027,7 +9762,9 @@ var continueAfterSegmentResult = async ({
   children,
   parserContext,
   iterator,
-  startOffset
+  startOffset,
+  fields,
+  topLevelStructure
 }) => {
   if (result.status === "done") {
     throw new Error("Should not continue after done");
@@ -9042,7 +9779,9 @@ var continueAfterSegmentResult = async ({
           iterator,
           length,
           parserContext,
-          startOffset
+          startOffset,
+          fields,
+          topLevelStructure
         });
       },
       skipTo: null
@@ -9057,7 +9796,9 @@ var continueAfterSegmentResult = async ({
         iterator,
         length,
         parserContext,
-        startOffset
+        startOffset,
+        fields,
+        topLevelStructure
       });
     },
     skipTo: null
@@ -9068,7 +9809,9 @@ var expectChildren = async ({
   length,
   children,
   parserContext,
-  startOffset
+  startOffset,
+  fields,
+  topLevelStructure
 }) => {
   while (iterator.counter.getOffset() < startOffset + length) {
     if (iterator.bytesRemaining() === 0) {
@@ -9079,8 +9822,19 @@ var expectChildren = async ({
       iterator,
       parserContext,
       offset: currentOffset,
-      children
+      children,
+      fields,
+      topLevelStructure
     });
+    if (hasAllInfo({
+      fields,
+      state: parserContext.parserState,
+      structure: topLevelStructure
+    })) {
+      return {
+        status: "done"
+      };
+    }
     if (child.status === "incomplete") {
       return {
         status: "incomplete",
@@ -9091,7 +9845,9 @@ var expectChildren = async ({
             iterator,
             length: length - (currentOffset - startOffset),
             parserContext,
-            startOffset: currentOffset
+            startOffset: currentOffset,
+            fields,
+            topLevelStructure
           });
         },
         skipTo: null
@@ -9121,14 +9877,20 @@ var continueAfterMatroskaResult = (result, structure) => {
     skipTo: null
   };
 };
-var parseWebm = async (counter, parserContext) => {
+var parseWebm = async ({
+  counter,
+  parserContext,
+  fields
+}) => {
   const structure = { type: "matroska", boxes: [] };
   const results = await expectChildren({
     iterator: counter,
     length: Infinity,
     children: structure.boxes,
     parserContext,
-    startOffset: counter.counter.getOffset()
+    startOffset: counter.counter.getOffset(),
+    fields,
+    topLevelStructure: structure
   });
   return continueAfterMatroskaResult(results, structure);
 };
@@ -9138,13 +9900,15 @@ var parseVideo = ({
   iterator,
   options,
   signal,
-  logLevel
+  logLevel,
+  fields
 }) => {
   if (iterator.bytesRemaining() === 0) {
     return Promise.reject(new Error("no bytes"));
   }
   if (iterator.isRiff()) {
-    return Promise.resolve(parseRiff({ iterator, options }));
+    Log.verbose(logLevel, "Detected RIFF container");
+    return Promise.resolve(parseRiff({ iterator, options, fields }));
   }
   if (iterator.isIsoBaseMedia()) {
     Log.verbose(logLevel, "Detected ISO Base Media container");
@@ -9156,12 +9920,13 @@ var parseVideo = ({
       options,
       continueMdat: false,
       signal,
-      logLevel
+      logLevel,
+      fields
     });
   }
   if (iterator.isWebm()) {
     Log.verbose(logLevel, "Detected Matroska container");
-    return parseWebm(iterator, options);
+    return parseWebm({ counter: iterator, parserContext: options, fields });
   }
   if (iterator.isMp3()) {
     return Promise.reject(new Error("MP3 files are not yet supported"));
@@ -9169,11 +9934,67 @@ var parseVideo = ({
   return Promise.reject(new Error("Unknown video format"));
 };
 
-// src/parser-state.ts
+// src/state/can-skip-tracks.ts
+var needsTracksField = {
+  audioCodec: true,
+  container: false,
+  dimensions: true,
+  durationInSeconds: true,
+  fps: true,
+  internalStats: false,
+  isHdr: true,
+  name: false,
+  rotation: true,
+  size: false,
+  structure: true,
+  tracks: true,
+  unrotatedDimensions: true,
+  videoCodec: true,
+  metadata: true
+};
+var makeCanSkipTracksState = ({
+  hasAudioTrackHandlers,
+  fields,
+  hasVideoTrackHandlers
+}) => {
+  return {
+    canSkipTracks: () => {
+      if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
+        return false;
+      }
+      const keys = Object.keys(fields ?? {});
+      const selectedKeys = keys.filter((k) => fields[k]);
+      return !selectedKeys.some((k) => needsTracksField[k]);
+    }
+  };
+};
+
+// src/state/has-tracks-section.ts
+var makeTracksSectionState = (canSkipTracksState) => {
+  let doneWithTracks = false;
+  return {
+    hasAllTracks: () => doneWithTracks,
+    setIsDone: () => {
+      doneWithTracks = true;
+    },
+    ensureHasTracksAtEnd: () => {
+      if (canSkipTracksState.canSkipTracks()) {
+        return;
+      }
+      if (!doneWithTracks) {
+        throw new Error("Error in Media Parser: End of parsing has been reached, but no tracks have been found");
+      }
+    }
+  };
+};
+
+// src/state/parser-state.ts
 var makeParserState = ({
-  hasAudioCallbacks,
-  hasVideoCallbacks,
-  signal
+  hasAudioTrackHandlers,
+  hasVideoTrackHandlers,
+  signal,
+  getIterator,
+  fields
 }) => {
   const trackEntries = {};
   const onTrackEntrySegment = (trackEntry2) => {
@@ -9198,14 +10019,17 @@ var makeParserState = ({
   const audioSampleCallbacks = {};
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
-  const declinedTrackNumbers = [];
   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;
   };
@@ -9239,6 +10063,12 @@ var makeParserState = ({
     }
     profileCallbacks.length = 0;
   };
+  const canSkipTracksState = makeCanSkipTracksState({
+    hasAudioTrackHandlers,
+    fields,
+    hasVideoTrackHandlers
+  });
+  const tracksState = makeTracksSectionState(canSkipTracksState);
   return {
     onTrackEntrySegment,
     onProfile,
@@ -9247,7 +10077,6 @@ var makeParserState = ({
     registerVideoSampleCallback: async (id, callback) => {
       if (callback === null) {
         delete videoSampleCallbacks[id];
-        declinedTrackNumbers.push(id);
         return;
       }
       videoSampleCallbacks[id] = callback;
@@ -9261,7 +10090,6 @@ var makeParserState = ({
     registerAudioSampleCallback: async (id, callback) => {
       if (callback === null) {
         delete audioSampleCallbacks[id];
-        declinedTrackNumbers.push(id);
         return;
       }
       audioSampleCallbacks[id] = callback;
@@ -9281,13 +10109,6 @@ var makeParserState = ({
       const callback = audioSampleCallbacks[trackId];
       if (callback) {
         await callback(audioSample);
-      } else {
-        if (declinedTrackNumbers.includes(trackId)) {
-          return;
-        }
-        if (!hasAudioCallbacks) {
-          throw new Error("No audio callbacks registered");
-        }
       }
     },
     onVideoSample: async (trackId, videoSample) => {
@@ -9301,16 +10122,8 @@ var makeParserState = ({
       const callback = videoSampleCallbacks[trackId];
       if (callback) {
         await callback(videoSample);
-      } else {
-        if (declinedTrackNumbers.includes(trackId)) {
-          return;
-        }
-        if (!hasVideoCallbacks) {
-          throw new Error("No video callbacks registered");
-        }
       }
     },
-    getInternalStats: () => ({}),
     getTimescale,
     setTimescale,
     getSamplesForTrack: (trackId) => {
@@ -9318,7 +10131,18 @@ var makeParserState = ({
     },
     getAvcProfile: () => {
       return avcProfile;
-    }
+    },
+    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
   };
 };
 
@@ -9334,10 +10158,14 @@ var parseMedia = async ({
   onParseProgress,
   ...more
 }) => {
+  let iterator = null;
+  let parseResult = null;
   const state = makeParserState({
-    hasAudioCallbacks: onAudioTrack !== null,
-    hasVideoCallbacks: onVideoTrack !== null,
-    signal
+    hasAudioTrackHandlers: Boolean(onAudioTrack),
+    hasVideoTrackHandlers: Boolean(onVideoTrack),
+    signal,
+    getIterator: () => iterator,
+    fields: fields ?? {}
   });
   const {
     reader,
@@ -9349,16 +10177,7 @@ var parseMedia = async ({
   const supportsContentRange = readerSupportsContentRange && !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.DISABLE_CONTENT_RANGE === "true");
   const returnValue = {};
   const moreFields = more;
-  let iterator = null;
-  let parseResult = null;
-  const canSkipVideoData = !onVideoTrack && !onAudioTrack;
-  if (canSkipVideoData) {
-    Log.verbose(logLevel, "Only parsing metadata, because no onVideoTrack and onAudioTrack callbacks were passed.");
-  } else {
-    Log.verbose(logLevel, "Parsing video data, because onVideoTrack/onAudioTrack callbacks were passed.");
-  }
   const options = {
-    canSkipVideoData,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
     parserState: state,
@@ -9366,15 +10185,8 @@ var parseMedia = async ({
     supportsContentRange,
     nextTrackIndex: 0
   };
-  const hasAllInfo = () => {
-    if (parseResult === null) {
-      return false;
-    }
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
-    return Object.values(availableInfo).every(Boolean);
-  };
   const triggerInfoEmit = () => {
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
+    const availableInfo = getAvailableInfo(fields ?? {}, parseResult?.segments ?? null, state);
     emitAvailableInfo({
       hasInfo: availableInfo,
       moreFields,
@@ -9426,16 +10238,33 @@ var parseMedia = async ({
         iterator,
         options,
         signal: signal ?? null,
-        logLevel
+        logLevel,
+        fields: fields ?? {}
       });
     }
-    if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
+    if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
+      state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
+    }
+    if (hasAllInfo({
+      fields: fields ?? {},
+      structure: parseResult.segments,
+      state
+    })) {
+      Log.verbose(logLevel, "Got all info, skipping to the end.");
+      if (contentLength !== null) {
+        state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
+      }
       break;
     }
-    if (parseResult && parseResult.status === "incomplete" && parseResult.skipTo !== null) {
+    if (parseResult.status === "incomplete" && parseResult.skipTo !== null) {
       if (!supportsContentRange) {
         throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
       }
+      if (parseResult.skipTo === contentLength) {
+        Log.verbose(logLevel, "Skipped to end of file, not fetching.");
+        break;
+      }
+      Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}`);
       currentReader.abort();
       const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
       currentReader = newReader;
@@ -9445,7 +10274,9 @@ var parseMedia = async ({
   Log.verbose(logLevel, "Finished parsing file");
   emitAvailableInfo({
     hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
-      acc[key] = true;
+      if (fields?.[key]) {
+        acc[key] = true;
+      }
       return acc;
     }, {}),
     moreFields,
@@ -9457,11 +10288,9 @@ var parseMedia = async ({
   });
   currentReader.abort();
   iterator?.destroy();
+  state.tracks.ensureHasTracksAtEnd();
   return returnValue;
 };
-// src/version.ts
-var VERSION = "4.0.233";
-
 // src/index.ts
 var MediaParserInternals = {
   createMatroskaMedia,
@@ -9471,7 +10300,8 @@ var MediaParserInternals = {
   IoEventEmitter,
   makeProgressTracker,
   withResolvers,
-  withResolversAndWaitForReturn
+  withResolversAndWaitForReturn,
+  createAacCodecPrivate
 };
 export {
   parseMedia,