@remotion/media-parser 4.0.210 → 4.0.212

package/dist/esm/index.mjs

@@ -1,4 +1,32 @@
 // src/readers/from-fetch.ts
+function parseContentRange(input) {
+  const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
+  if (!matches)
+    return null;
+  const [, unit, , start, end, size] = matches;
+  const range = {
+    unit,
+    start: start != null ? Number(start) : null,
+    end: end != null ? Number(end) : null,
+    size: size === "*" ? null : Number(size)
+  };
+  if (range.start === null && range.end === null && range.size === null) {
+    return null;
+  }
+  return range;
+}
+var validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange) => {
+  if (typeof actualRange === "number" && parsedContentRange?.start !== actualRange) {
+    if (actualRange === 0) {
+      return { supportsContentRange: false };
+    }
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  if (actualRange !== null && typeof actualRange !== "number" && (parsedContentRange?.start !== actualRange[0] || parsedContentRange?.end !== actualRange[1])) {
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  return { supportsContentRange: true };
+};
 var fetchReader = {
   read: async (src, range, signal) => {
     if (typeof src !== "string") {
@@ -9,20 +37,25 @@ var fetchReader = {
       return Promise.reject(new Error(resolvedUrl + " is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass `reader: nodeReader` to parseMedia()."));
     }
     const controller = new AbortController;
+    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
+    const actualRange = range === null ? 0 : range;
     const res = await fetch(resolvedUrl, {
-      headers: range === null ? {} : typeof range === "number" ? {
-        Range: `bytes=${range}`
+      headers: typeof actualRange === "number" ? {
+        Range: `bytes=${actualRange}-`
       } : {
-        Range: `bytes=${`${range[0]}-${range[1]}`}`
+        Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
       },
       signal: controller.signal,
-      cache: "no-store"
+      cache
     });
+    const contentRange = res.headers.get("content-range");
+    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange);
     signal?.addEventListener("abort", () => {
       controller.abort();
     }, { once: true });
     if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
-      throw new Error(`Server returned status code ${res.status} for ${src}`);
+      throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
     }
     if (!res.body) {
       throw new Error("No body");
@@ -47,7 +80,8 @@ var fetchReader = {
         }
       },
       contentLength,
-      name: name ?? fallbackName
+      name: name ?? fallbackName,
+      supportsContentRange
     };
   },
   getLength: async (src) => {
@@ -1060,11 +1094,16 @@ var makeCluster = async (w, timestamp) => {
     clusterSize += simpleBlock2.byteLength;
     await w.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
     await w.write(simpleBlock2);
+    return { timecodeRelativeToCluster };
   };
-  const shouldMakeNewCluster = (newT, keyframe) => {
+  const shouldMakeNewCluster = ({
+    isVideo,
+    keyframe,
+    newT
+  }) => {
     const newTimestamp = timestampToClusterTimestamp(newT);
     const oldTimestamp = timestampToClusterTimestamp(timestamp);
-    return newTimestamp - oldTimestamp >= 2000 && keyframe;
+    return newTimestamp - oldTimestamp >= 2000 && keyframe && isVideo;
   };
   return { addSample, shouldMakeNewCluster };
 };
@@ -1094,18 +1133,18 @@ var createMatroskaCues = (cues) => {
             type: "CueTime",
             minVintWidth: null,
             value: {
-              value: timestampToClusterTimestamp(cue.time),
+              value: cue.time,
               byteLength: null
             }
           },
-          ...cue.trackNumbers.map((trackNumber2) => ({
+          {
             type: "CueTrackPositions",
             value: [
               {
                 type: "CueTrack",
                 minVintWidth: null,
                 value: {
-                  value: trackNumber2,
+                  value: cue.trackNumber,
                   byteLength: null
                 }
               },
@@ -1119,7 +1158,7 @@ var createMatroskaCues = (cues) => {
               }
             ],
             minVintWidth: null
-          }))
+          }
         ],
         minVintWidth: null
       };
@@ -1258,6 +1297,11 @@ var createMatroskaSegment = (children) => {
   });
 };
 
+// src/truthy.ts
+function truthy(value) {
+  return Boolean(value);
+}
+
 // src/boxes/webm/traversal.ts
 var getMainSegment = (segments) => {
   return segments.find((s) => s.type === "Segment");
@@ -1484,7 +1528,7 @@ var makeMatroskaColorBytes = ({
     type: "Colour",
     minVintWidth: null,
     value: [
-      {
+      transferChracteristicsValue === 2 ? null : {
         type: "TransferCharacteristics",
         value: {
           value: transferChracteristicsValue,
@@ -1492,7 +1536,7 @@ var makeMatroskaColorBytes = ({
         },
         minVintWidth: null
       },
-      {
+      matrixCoefficientsValue === 2 ? null : {
         type: "MatrixCoefficients",
         value: {
           value: matrixCoefficientsValue,
@@ -1500,7 +1544,7 @@ var makeMatroskaColorBytes = ({
         },
         minVintWidth: null
       },
-      {
+      primariesValue === 2 ? null : {
         type: "Primaries",
         value: {
           value: primariesValue,
@@ -1516,7 +1560,7 @@ var makeMatroskaColorBytes = ({
         },
         minVintWidth: null
       }
-    ]
+    ].filter(truthy)
   });
 };
 
@@ -1644,14 +1688,6 @@ var makeMatroskaAudioTrackEntryBytes = ({
         },
         minVintWidth: null
       },
-      {
-        type: "TrackTimestampScale",
-        value: {
-          value: 1,
-          size: "64"
-        },
-        minVintWidth: null
-      },
       {
         type: "CodecID",
         value: makeAudioCodecId(codec),
@@ -1788,13 +1824,15 @@ var createMedia = async (writer) => {
   const cues = [];
   const trackNumbers = [];
   const matroskaSegment = createMatroskaSegment([
-    matroskaInfo,
     ...createMatroskaSeekHead(seeks),
+    matroskaInfo,
     ...makeMatroskaTracks(currentTracks)
   ]);
-  const durationOffset = (matroskaSegment.offsets.children[0].children.find((c) => c.field === "Duration")?.offset ?? 0) + w.getWrittenByteCount();
+  const infoSegment = matroskaSegment.offsets.children.find((o) => o.field === "Info");
+  const durationOffset = (infoSegment?.children.find((c) => c.field === "Duration")?.offset ?? 0) + w.getWrittenByteCount();
   const tracksOffset = (matroskaSegment.offsets.children.find((o) => o.field === "Tracks")?.offset ?? 0) + w.getWrittenByteCount();
   const seekHeadOffset = (matroskaSegment.offsets.children.find((o) => o.field === "SeekHead")?.offset ?? 0) + w.getWrittenByteCount();
+  const infoOffset = (infoSegment?.offset ?? 0) + w.getWrittenByteCount();
   if (!seekHeadOffset) {
     throw new Error("could not get seek offset");
   }
@@ -1804,6 +1842,13 @@ var createMedia = async (writer) => {
   if (!tracksOffset) {
     throw new Error("could not get tracks offset");
   }
+  if (!infoOffset) {
+    throw new Error("could not get tracks offset");
+  }
+  seeks.push({
+    hexString: matroskaElements.Info,
+    byte: infoOffset - seekHeadOffset
+  });
   seeks.push({
     hexString: matroskaElements.Tracks,
     byte: tracksOffset - seekHeadOffset
@@ -1812,10 +1857,10 @@ var createMedia = async (writer) => {
     const updatedSeek = createMatroskaSeekHead(seeks);
     await w.updateDataAt(seekHeadOffset, combineUint8Arrays(updatedSeek.map((b) => b.bytes)));
   };
-  const segmentOffset = w.getWrittenByteCount() + matroskaToHex(matroskaElements.Segment).byteLength;
+  const segmentOffset = w.getWrittenByteCount();
   const updateSegmentSize = async (size) => {
     const data = getVariableInt(size, MATROSKA_SEGMENT_MIN_VINT_WIDTH);
-    await w.updateDataAt(segmentOffset, data);
+    await w.updateDataAt(segmentOffset + matroskaToHex(matroskaElements.Segment).byteLength, data);
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
@@ -1824,32 +1869,39 @@ var createMedia = async (writer) => {
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
   });
-  cues.push({
-    time: 0,
-    clusterPosition: clusterOffset - seekHeadOffset,
-    trackNumbers
-  });
   const trackNumberProgresses = {};
-  const getClusterOrMakeNew = async (chunk) => {
+  const getClusterOrMakeNew = async ({
+    chunk,
+    isVideo
+  }) => {
     const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
-    if (!currentCluster.shouldMakeNewCluster(smallestProgress, chunk.type === "key")) {
-      return currentCluster;
-    }
-    const newCluster = w.getWrittenByteCount();
-    cues.push({
-      time: smallestProgress,
-      clusterPosition: newCluster - seekHeadOffset,
-      trackNumbers
-    });
+    if (!currentCluster.shouldMakeNewCluster({
+      newT: smallestProgress,
+      keyframe: chunk.type === "key",
+      isVideo
+    })) {
+      return { cluster: currentCluster, isNew: false, smallestProgress };
+    }
     currentCluster = await makeCluster(w, smallestProgress);
-    return currentCluster;
+    return { cluster: currentCluster, isNew: true, smallestProgress };
   };
-  const addSample = async (chunk, trackNumber2) => {
+  const addSample = async (chunk, trackNumber2, isVideo) => {
     trackNumberProgresses[trackNumber2] = chunk.timestamp;
-    const cluster3 = await getClusterOrMakeNew(chunk);
+    const { cluster: cluster2, isNew, smallestProgress } = await getClusterOrMakeNew({
+      chunk,
+      isVideo
+    });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
-    return cluster3.addSample(chunk, trackNumber2);
+    const { timecodeRelativeToCluster } = await cluster2.addSample(chunk, trackNumber2);
+    if (isNew) {
+      const newCluster = w.getWrittenByteCount();
+      cues.push({
+        time: timestampToClusterTimestamp(smallestProgress) + timecodeRelativeToCluster,
+        clusterPosition: newCluster - seekHeadOffset,
+        trackNumber: trackNumber2
+      });
+    }
   };
   const updateDuration = async (newDuration) => {
     const blocks = makeDurationWithPadding(newDuration);
@@ -1870,8 +1922,8 @@ var createMedia = async (writer) => {
     remove: async () => {
       await w.remove();
     },
-    addSample: (chunk, trackNumber2) => {
-      operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber2));
+    addSample: (chunk, trackNumber2, isVideo) => {
+      operationProm.current = operationProm.current.then(() => addSample(chunk, trackNumber2, isVideo));
       return operationProm.current;
     },
     updateDuration: (duration2) => {
@@ -1897,8 +1949,8 @@ var createMedia = async (writer) => {
       });
       await updateSeekWrite();
       await w.write(createMatroskaCues(cues).bytes);
-      const segmentSize = w.getWrittenByteCount() - segmentOffset;
       await w.waitForFinish();
+      const segmentSize = w.getWrittenByteCount() - segmentOffset - matroskaToHex(matroskaElements.Segment).byteLength - MATROSKA_SEGMENT_MIN_VINT_WIDTH;
       await updateSegmentSize(segmentSize);
     }
   };
@@ -2058,25 +2110,15 @@ var getTrunBoxes = (segment) => {
   const trunBoxes = segment.children.filter((c) => c.type === "trun-box");
   return trunBoxes;
 };
-var hasSkippedMdatProcessing = (anySegment) => {
+var getMdatBox = (anySegment) => {
   const mdat = anySegment.find((b) => b.type === "mdat-box");
   if (!mdat) {
-    return {
-      skipped: false
-    };
+    return null;
   }
   if (mdat.type !== "mdat-box") {
     throw new Error("Expected mdat-box");
   }
-  if (mdat.samplesProcessed) {
-    return {
-      skipped: false
-    };
-  }
-  return {
-    skipped: true,
-    fileOffset: mdat.fileOffset
-  };
+  return mdat;
 };
 
 // src/get-fps.ts
@@ -2270,6 +2312,9 @@ var getAudioCodecStringFromTrak = (trak) => {
   };
 };
 var getAudioCodecFromAudioCodecInfo = (codec) => {
+  if (codec.format === "twos") {
+    return "pcm-s16";
+  }
   if (codec.format === "sowt") {
     return "aiff";
   }
@@ -2285,7 +2330,7 @@ var getAudioCodecFromAudioCodecInfo = (codec) => {
     }
     throw new Error("Unknown mp4a codec: " + codec.primarySpecificator);
   }
-  throw new Error("Unknown audio format: " + codec.format);
+  throw new Error(`Unknown audio format: ${codec.format}`);
 };
 var getAudioCodecFromTrack = (track) => {
   const audioSample = getAudioCodecFromTrak(track);
@@ -2464,6 +2509,9 @@ class OffsetCounter {
   setDiscardedOffset(offset) {
     this.#discardedBytes = offset;
   }
+  getDiscardedBytes() {
+    return this.#discardedBytes;
+  }
   discardBytes(amount) {
     this.#discardedBytes += amount;
   }
@@ -2496,11 +2544,18 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
   data.set(initialData);
   let view = new DataView(data.buffer);
   const counter = makeOffsetCounter();
+  let discardAllowed = true;
   const getSlice = (amount) => {
     const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
     counter.increment(amount);
     return value;
   };
+  const disallowDiscard = () => {
+    discardAllowed = false;
+  };
+  const allowDiscard = () => {
+    discardAllowed = true;
+  };
   const getUint8 = () => {
     const val = view.getUint8(counter.getDiscardedOffset());
     counter.increment(1);
@@ -2606,6 +2661,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     return matchesPattern(mpegPattern)(data.subarray(0, 4));
   };
   const removeBytesRead = () => {
+    if (!discardAllowed) {
+      return;
+    }
     const bytesToRemove = counter.getDiscardedOffset();
     if (bytesToRemove < 1e5) {
       return;
@@ -2616,12 +2674,22 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     buf.resize(newData.byteLength);
     view = new DataView(data.buffer);
   };
-  const skipTo = (offset) => {
+  const skipTo = (offset, reset) => {
     const becomesSmaller = offset < counter.getOffset();
     if (becomesSmaller) {
-      buf.resize(0);
-      counter.decrement(counter.getOffset() - offset);
-      counter.setDiscardedOffset(offset);
+      if (reset) {
+        buf.resize(0);
+        counter.decrement(counter.getOffset() - offset);
+        counter.setDiscardedOffset(offset);
+      } else {
+        const toDecrement = counter.getOffset() - offset;
+        const newOffset = counter.getOffset() - toDecrement;
+        counter.decrement(toDecrement);
+        const c = counter.getDiscardedBytes();
+        if (c > newOffset) {
+          throw new Error("already discarded too many bytes");
+        }
+      }
     } else {
       const currentOffset = counter.getOffset();
       counter.increment(offset - currentOffset);
@@ -2842,7 +2910,9 @@ var getArrayBufferIterator = (initialData, maxBytes) => {
     getInt32Le,
     getInt32,
     destroy,
-    isMp3
+    isMp3,
+    disallowDiscard,
+    allowDiscard
   };
 };
 
@@ -4201,15 +4271,26 @@ var parseMdat = async ({
   fileOffset,
   existingBoxes,
   options,
-  signal
+  signal,
+  maySkipSampleProcessing
 }) => {
   const alreadyHas = hasTracks(existingBoxes);
   if (!alreadyHas) {
+    if (maySkipSampleProcessing) {
+      data.discard(size - (data.counter.getOffset() - fileOffset));
+      return Promise.resolve({
+        type: "mdat-box",
+        boxSize: size,
+        status: "samples-skipped",
+        fileOffset
+      });
+    }
     data.discard(size - (data.counter.getOffset() - fileOffset));
+    data.disallowDiscard();
     return Promise.resolve({
       type: "mdat-box",
       boxSize: size,
-      samplesProcessed: false,
+      status: "samples-buffered",
       fileOffset
     });
   }
@@ -4284,7 +4365,7 @@ var parseMdat = async ({
   return Promise.resolve({
     type: "mdat-box",
     boxSize: size,
-    samplesProcessed: true,
+    status: "samples-processed",
     fileOffset
   });
 };
@@ -5361,9 +5442,10 @@ var parseMdatPartially = async ({
     fileOffset,
     existingBoxes: parsedBoxes,
     options,
-    signal
+    signal,
+    maySkipSampleProcessing: options.supportsContentRange
   });
-  if (box.samplesProcessed && box.fileOffset + boxSize === iterator.counter.getOffset()) {
+  if ((box.status === "samples-processed" || box.status === "samples-buffered") && box.fileOffset + boxSize === iterator.counter.getOffset()) {
     return {
       type: "complete",
       box,
@@ -5412,7 +5494,7 @@ var processBox = async ({
   const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber(littleEndian) : boxSizeRaw;
   if (bytesRemaining < boxSize) {
     if (boxType === "mdat") {
-      const shouldSkip = options.canSkipVideoData || !hasTracks(parsedBoxes);
+      const shouldSkip = (options.canSkipVideoData || !hasTracks(parsedBoxes)) && options.supportsContentRange;
       if (shouldSkip) {
         const skipTo = fileOffset + boxSize;
         const bytesToSkip = skipTo - iterator.counter.getOffset();
@@ -5423,7 +5505,7 @@ var processBox = async ({
               type: "mdat-box",
               boxSize,
               fileOffset,
-              samplesProcessed: false
+              status: "samples-skipped"
             },
             size: boxSize,
             skipTo: fileOffset + boxSize
@@ -5751,8 +5833,12 @@ var processBox = async ({
       fileOffset,
       existingBoxes: parsedBoxes,
       options,
-      signal
+      signal,
+      maySkipSampleProcessing: options.supportsContentRange
     });
+    if (box === null) {
+      throw new Error("Unexpected null");
+    }
     return {
       type: "complete",
       box,
@@ -5855,11 +5941,18 @@ var parseBoxes = async ({
     if (result.box.type === "mdat-box" && alreadyHasMdat) {
       boxes = boxes.filter((b) => b.type !== "mdat-box");
       boxes.push(result.box);
+      iterator.allowDiscard();
+      if (result.box.status !== "samples-processed") {
+        throw new Error("unexpected");
+      }
       break;
     } else {
       boxes.push(result.box);
     }
     if (result.skipTo !== null) {
+      if (!options.supportsContentRange) {
+        throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
+      }
       return {
         status: "incomplete",
         segments: boxes,
@@ -5878,18 +5971,42 @@ var parseBoxes = async ({
         skipTo: result.skipTo
       };
     }
+    if (iterator.bytesRemaining() < 0) {
+      return {
+        status: "incomplete",
+        segments: boxes,
+        continueParsing: () => {
+          return parseBoxes({
+            iterator,
+            maxBytes,
+            allowIncompleteBoxes,
+            initialBoxes: boxes,
+            options,
+            continueMdat: false,
+            littleEndian,
+            signal
+          });
+        },
+        skipTo: null
+      };
+    }
     iterator.removeBytesRead();
   }
-  const mdatState = hasSkippedMdatProcessing(boxes);
-  if (mdatState.skipped && !options.canSkipVideoData) {
+  const mdatState = getMdatBox(boxes);
+  const skipped = mdatState?.status === "samples-skipped" && !options.canSkipVideoData && options.supportsContentRange;
+  const buffered = mdatState?.status === "samples-buffered" && !options.canSkipVideoData;
+  if (skipped || buffered) {
     return {
       status: "incomplete",
       segments: boxes,
       continueParsing: () => {
+        if (buffered) {
+          iterator.skipTo(mdatState.fileOffset, false);
+        }
         return parseBoxes({
           iterator,
           maxBytes,
-          allowIncompleteBoxes,
+          allowIncompleteBoxes: false,
           initialBoxes: boxes,
           options,
           continueMdat: false,
@@ -5897,7 +6014,7 @@ var parseBoxes = async ({
           signal
         });
       },
-      skipTo: mdatState.fileOffset
+      skipTo: skipped ? mdatState.fileOffset : null
     };
   }
   return {
@@ -6338,6 +6455,9 @@ var continueParsingfunction = ({
   const offset = iterator.counter.getOffset();
   const continued = await result.continueParsing();
   if (continued.status === "incomplete") {
+    if (!parserContext.supportsContentRange) {
+      throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
+    }
     return {
       status: "incomplete",
       continueParsing: continueParsingfunction({
@@ -6380,6 +6500,9 @@ var expectChildren = async ({
       wrap
     });
     if (child.status === "incomplete") {
+      if (!parserContext.supportsContentRange) {
+        throw new Error("Content-Range header is not supported by the reader, but was asked to seek");
+      }
       return {
         status: "incomplete",
         continueParsing: continueParsingfunction({
@@ -6595,8 +6718,14 @@ var parseMedia = async ({
     hasVideoCallbacks: onVideoTrack !== null,
     signal
   });
-  const { reader, contentLength, name } = await readerInterface.read(src, null, signal);
+  const {
+    reader,
+    contentLength,
+    name,
+    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;
   let iterator = null;
@@ -6606,22 +6735,34 @@ var parseMedia = async ({
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
     parserState: state,
-    nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true")
+    nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
+    supportsContentRange
   };
   while (parseResult === null || parseResult.status === "incomplete") {
     if (signal?.aborted) {
       throw new Error("Aborted");
     }
-    const result = await currentReader.reader.read();
-    if (iterator) {
-      if (!result.done) {
-        iterator.addData(result.value);
+    while (true) {
+      const result = await currentReader.reader.read();
+      if (iterator) {
+        if (!result.done) {
+          iterator.addData(result.value);
+        }
+      } else {
+        if (result.done) {
+          throw new Error("Unexpectedly reached EOF");
+        }
+        iterator = getArrayBufferIterator(result.value, contentLength ?? 1e9);
+      }
+      if (iterator.bytesRemaining() >= 0) {
+        break;
       }
-    } else {
       if (result.done) {
-        throw new Error("Unexpectedly reached EOF");
+        break;
       }
-      iterator = getArrayBufferIterator(result.value, contentLength ?? 1e9);
+    }
+    if (!iterator) {
+      throw new Error("Unexpected null");
     }
     if (parseResult && parseResult.status === "incomplete") {
       parseResult = await parseResult.continueParsing();
@@ -6647,27 +6788,19 @@ var parseMedia = async ({
       break;
     }
     if (parseResult && 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");
+      }
       const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
       currentReader = newReader;
-      iterator.skipTo(parseResult.skipTo);
+      iterator.skipTo(parseResult.skipTo, true);
     }
   }
   emitAvailableInfo({
-    hasInfo: {
-      boxes: true,
-      durationInSeconds: true,
-      dimensions: true,
-      fps: true,
-      videoCodec: true,
-      audioCodec: true,
-      tracks: true,
-      rotation: true,
-      unrotatedDimensions: true,
-      internalStats: true,
-      size: true,
-      name: true,
-      container: true
-    },
+    hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
+      acc[key] = true;
+      return acc;
+    }, {}),
     moreFields,
     parseResult,
     state,