@remotion/media-parser 4.0.230 → 4.0.231

package/dist/esm/index.mjs

@@ -1965,14 +1965,15 @@ var createIsoBaseMedia = async ({
   writer,
   onBytesProgress,
   onMillisecondsProgress,
-  logLevel
+  logLevel,
+  filename
 }) => {
   const header = createIsoBaseMediaFtyp({
     compatibleBrands: ["isom", "iso2", "avc1", "mp42"],
     majorBrand: "isom",
     minorBrand: 512
   });
-  const w = await writer.createContent();
+  const w = await writer.createContent({ filename, mimeType: "video/mp4" });
   await w.write(header);
   let durationInUnits = 0;
   const currentTracks = [];
@@ -2072,9 +2073,8 @@ var createIsoBaseMedia = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: async () => {
-      const file = await w.save();
-      return file;
+    save: () => {
+      return w.save();
     },
     remove: async () => {
       await w.remove();
@@ -2182,11 +2182,17 @@ var canFitInCluster = ({
   }
   return timecodeRelativeToCluster <= maxClusterTimestamp;
 };
-var makeCluster = async (w, clusterStartTimestamp, timescale) => {
+var makeCluster = async ({
+  writer,
+  clusterStartTimestamp,
+  timescale,
+  logLevel
+}) => {
+  Log.verbose(logLevel, `Making new Matroska cluster with timestamp ${clusterStartTimestamp}`);
   const cluster = createClusterSegment(timestampToClusterTimestamp(clusterStartTimestamp, timescale));
-  const clusterVIntPosition = w.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
+  const clusterVIntPosition = writer.getWrittenByteCount() + cluster.offsets.offset + matroskaToHex(matroskaElements.Cluster).byteLength;
   let clusterSize = cluster.bytes.byteLength - matroskaToHex(matroskaElements.Cluster).byteLength - CLUSTER_MIN_VINT_WIDTH;
-  await w.write(cluster.bytes);
+  await writer.write(cluster.bytes);
   const addSample = async (chunk, trackNumber2) => {
     const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp, timescale) - timestampToClusterTimestamp(clusterStartTimestamp, timescale);
     if (!canFitInCluster({ clusterStartTimestamp, chunk, timescale })) {
@@ -2202,8 +2208,8 @@ var makeCluster = async (w, clusterStartTimestamp, timescale) => {
       timecodeRelativeToCluster
     });
     clusterSize += simpleBlock2.byteLength;
-    await w.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
-    await w.write(simpleBlock2);
+    await writer.updateDataAt(clusterVIntPosition, getVariableInt(clusterSize, CLUSTER_MIN_VINT_WIDTH));
+    await writer.write(simpleBlock2);
     return { timecodeRelativeToCluster };
   };
   const shouldMakeNewCluster = ({
@@ -2219,6 +2225,7 @@ var makeCluster = async (w, clusterStartTimestamp, timescale) => {
       timescale
     });
     if (!canFit) {
+      Log.verbose(logLevel, `Cannot fit ${chunk.timestamp} in cluster ${clusterStartTimestamp}. Creating new cluster`);
       return true;
     }
     const keyframe = chunk.type === "key";
@@ -2938,10 +2945,12 @@ var timescale = 1e6;
 var createMatroskaMedia = async ({
   writer,
   onBytesProgress,
-  onMillisecondsProgress
+  onMillisecondsProgress,
+  filename,
+  logLevel
 }) => {
   const header = makeMatroskaHeader();
-  const w = await writer.createContent();
+  const w = await writer.createContent({ filename, mimeType: "video/webm" });
   await w.write(header.bytes);
   const matroskaInfo = makeMatroskaInfo({
     timescale
@@ -2993,7 +3002,12 @@ var createMatroskaMedia = async ({
   };
   await w.write(matroskaSegment.bytes);
   const clusterOffset = w.getWrittenByteCount();
-  let currentCluster = await makeCluster(w, 0, timescale);
+  let currentCluster = await makeCluster({
+    writer: w,
+    clusterStartTimestamp: 0,
+    timescale,
+    logLevel
+  });
   seeks.push({
     hexString: matroskaElements.Cluster,
     byte: clusterOffset - seekHeadOffset
@@ -3001,9 +3015,14 @@ var createMatroskaMedia = async ({
   const trackNumberProgresses = {};
   const getClusterOrMakeNew = async ({
     chunk,
-    isVideo
+    isVideo,
+    trackNumber: trackNumber2
   }) => {
-    const smallestProgress = Math.min(...Object.values(trackNumberProgresses));
+    const trackProgressValues = Object.values(trackNumberProgresses);
+    const smallestProgress = trackProgressValues.length === 0 ? 0 : Math.min(...trackProgressValues);
+    if (chunk.type === "key") {
+      trackNumberProgresses[trackNumber2] = chunk.timestamp;
+    }
     if (!currentCluster.shouldMakeNewCluster({
       newT: smallestProgress,
       isVideo,
@@ -3011,7 +3030,12 @@ var createMatroskaMedia = async ({
     })) {
       return { cluster: currentCluster, isNew: false, smallestProgress };
     }
-    currentCluster = await makeCluster(w, smallestProgress, timescale);
+    currentCluster = await makeCluster({
+      writer: w,
+      clusterStartTimestamp: smallestProgress,
+      timescale,
+      logLevel
+    });
     return { cluster: currentCluster, isNew: true, smallestProgress };
   };
   const updateDuration = async (newDuration) => {
@@ -3024,10 +3048,10 @@ var createMatroskaMedia = async ({
     trackNumber: trackNumber2,
     isVideo
   }) => {
-    trackNumberProgresses[trackNumber2] = chunk.timestamp;
     const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
-      isVideo
+      isVideo,
+      trackNumber: trackNumber2
     });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
@@ -3061,9 +3085,8 @@ var createMatroskaMedia = async ({
         }
       });
     },
-    save: async () => {
-      const file = await w.save();
-      return file;
+    save: () => {
+      return w.save();
     },
     remove: async () => {
       await w.remove();
@@ -3266,6 +3289,244 @@ var getMdatBox = (anySegment) => {
   return mdat;
 };
 
+// src/get-sample-positions.ts
+var getSamplePositions = ({
+  stcoBox,
+  stszBox,
+  stscBox,
+  stssBox,
+  sttsBox,
+  cttsBox
+}) => {
+  const sttsDeltas = [];
+  for (const distribution of sttsBox.sampleDistribution) {
+    for (let i = 0;i < distribution.sampleCount; i++) {
+      sttsDeltas.push(distribution.sampleDelta);
+    }
+  }
+  const cttsEntries = [];
+  for (const entry of cttsBox?.entries ?? [
+    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
+  ]) {
+    for (let i = 0;i < entry.sampleCount; i++) {
+      cttsEntries.push(entry.sampleOffset);
+    }
+  }
+  let dts = 0;
+  const chunks = stcoBox.entries;
+  const samples = [];
+  let samplesPerChunk = 1;
+  for (let i = 0;i < chunks.length; i++) {
+    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+    if (hasEntry) {
+      samplesPerChunk = hasEntry.samplesPerChunk;
+    }
+    let offsetInThisChunk = 0;
+    for (let j = 0;j < samplesPerChunk; j++) {
+      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
+      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
+      const delta = sttsDeltas[samples.length];
+      const ctsOffset = cttsEntries[samples.length];
+      const cts = dts + ctsOffset;
+      samples.push({
+        offset: Number(chunks[i]) + offsetInThisChunk,
+        size,
+        isKeyframe,
+        dts,
+        cts,
+        duration: delta,
+        chunk: i
+      });
+      dts += delta;
+      offsetInThisChunk += size;
+    }
+  }
+  return samples;
+};
+
+// src/samples-from-moof.ts
+var getSamplesFromTraf = (trafSegment, moofOffset) => {
+  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
+    throw new Error("Expected traf-box");
+  }
+  const tfhdBox = getTfhdBox(trafSegment);
+  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
+  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
+  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
+  const tfdtBox = getTfdtBox(trafSegment);
+  const trunBoxes = getTrunBoxes(trafSegment);
+  let time = 0;
+  let offset = 0;
+  let dataOffset = 0;
+  const samples = [];
+  for (const trunBox of trunBoxes) {
+    let i = -1;
+    if (trunBox.dataOffset) {
+      dataOffset = trunBox.dataOffset;
+      offset = 0;
+    }
+    for (const sample of trunBox.samples) {
+      i++;
+      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
+      if (duration2 === null) {
+        throw new Error("Expected duration");
+      }
+      const size = sample.sampleSize ?? defaultSampleSize;
+      if (size === null) {
+        throw new Error("Expected size");
+      }
+      const isFirstSample = i === 0;
+      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
+      if (sampleFlags === null) {
+        throw new Error("Expected sample flags");
+      }
+      const keyframe = !(sampleFlags >> 16 & 1);
+      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
+      const samplePosition = {
+        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
+        dts,
+        cts: dts,
+        duration: duration2,
+        isKeyframe: keyframe,
+        size,
+        chunk: 0
+      };
+      samples.push(samplePosition);
+      offset += size;
+      time += duration2;
+    }
+  }
+  return samples;
+};
+var getSamplesFromMoof = ({
+  moofBox,
+  trackId
+}) => {
+  if (moofBox.type !== "regular-box") {
+    throw new Error("Expected moof-box");
+  }
+  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
+  const mapped = trafs.map((traf) => {
+    const tfhdBox = getTfhdBox(traf);
+    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
+  });
+  return mapped.flat(1);
+};
+
+// src/boxes/iso-base-media/get-sample-positions-from-track.ts
+var getSamplePositionsFromTrack = (trakBox, moofBox) => {
+  const stszBox = getStszBox(trakBox);
+  const stcoBox = getStcoBox(trakBox);
+  const stscBox = getStscBox(trakBox);
+  const stssBox = getStssBox(trakBox);
+  const sttsBox = getSttsBox(trakBox);
+  const tkhdBox = getTkhdBox(trakBox);
+  const cttsBox = getCttsBox(trakBox);
+  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
+  if (!tkhdBox) {
+    throw new Error("Expected tkhd box in trak box");
+  }
+  if (!stszBox) {
+    throw new Error("Expected stsz box in trak box");
+  }
+  if (!stcoBox) {
+    throw new Error("Expected stco box in trak box");
+  }
+  if (!stscBox) {
+    throw new Error("Expected stsc box in trak box");
+  }
+  if (!sttsBox) {
+    throw new Error("Expected stts box in trak box");
+  }
+  if (!timescaleAndDuration) {
+    throw new Error("Expected timescale and duration in trak box");
+  }
+  let samplePositions = getSamplePositions({
+    stcoBox,
+    stscBox,
+    stszBox,
+    stssBox,
+    sttsBox,
+    cttsBox
+  });
+  if (samplePositions.length === 0 && moofBox) {
+    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
+  }
+  return samplePositions;
+};
+
+// src/get-duration.ts
+var getDurationFromMatroska = (segments) => {
+  const mainSegment = segments.find((s) => s.type === "Segment");
+  if (!mainSegment || mainSegment.type !== "Segment") {
+    return null;
+  }
+  const { value: children } = mainSegment;
+  if (!children) {
+    return null;
+  }
+  const infoSegment = children.find((s) => s.type === "Info");
+  const relevantBoxes = [
+    ...mainSegment.value,
+    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
+  ];
+  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
+  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
+    return null;
+  }
+  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
+  if (!duration2 || duration2.type !== "Duration") {
+    return null;
+  }
+  return duration2.value.value / timestampScale2.value.value * 1000;
+};
+var isMatroska = (boxes) => {
+  const matroskaBox = boxes.find((b) => b.type === "Segment");
+  return matroskaBox;
+};
+var getDuration = (boxes, parserState) => {
+  if (isMatroska(boxes)) {
+    return getDurationFromMatroska(boxes);
+  }
+  const moovBox = getMoovBox(boxes);
+  if (!moovBox) {
+    return null;
+  }
+  const moofBox = getMoofBox(boxes);
+  const mvhdBox = getMvhdBox(moovBox);
+  if (!mvhdBox) {
+    return null;
+  }
+  if (mvhdBox.type !== "mvhd-box") {
+    throw new Error("Expected mvhd-box");
+  }
+  if (mvhdBox.durationInSeconds > 0) {
+    return mvhdBox.durationInSeconds;
+  }
+  const tracks2 = getTracks(boxes, parserState);
+  const allTracks = [
+    ...tracks2.videoTracks,
+    ...tracks2.audioTracks,
+    ...tracks2.otherTracks
+  ];
+  const allSamples = allTracks.map((t) => {
+    const { timescale: ts } = t;
+    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
+    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+    return highest ?? 0;
+  });
+  const highestTimestamp = Math.max(...allSamples);
+  return highestTimestamp;
+};
+var hasDuration = (boxes, parserState) => {
+  try {
+    const duration2 = getDuration(boxes, parserState);
+    return getDuration(boxes, parserState) !== null && duration2 !== 0;
+  } catch {
+    return false;
+  }
+};
+
 // src/get-fps.ts
 var calculateFps = ({
   sttsBox,
@@ -3338,6 +3599,9 @@ var getFps = (segments) => {
 };
 var hasFps = (boxes) => {
   try {
+    if (isMatroska(boxes)) {
+      return true;
+    }
     return getFps(boxes) !== null;
   } catch {
     return false;
@@ -3360,13 +3624,9 @@ var getAudioCodec = (boxes, parserState) => {
   }
   return null;
 };
-var hasAudioCodec = (boxes, state) => {
-  try {
-    return getAudioCodec(boxes, state) !== null;
-  } catch {
-    return false;
-  }
-};
+var hasAudioCodec = (boxes) => {
+  return hasTracks(boxes);
+};
 var getCodecSpecificatorFromEsdsBox = ({
   child
 }) => {
@@ -4226,11 +4486,7 @@ var getVideoCodec = (boxes) => {
   return null;
 };
 var hasVideoCodec = (boxes) => {
-  try {
-    return getVideoCodec(boxes) !== null;
-  } catch {
-    return false;
-  }
+  return hasTracks(boxes);
 };
 var getVideoPrivateData = (trakBox) => {
   const videoSample = getStsdVideoConfig(trakBox);
@@ -4800,303 +5056,68 @@ var getTracks = (segments, state) => {
     return {
       videoTracks,
       audioTracks,
-      otherTracks
-    };
-  }
-  const tracks2 = getTraks(moovBox);
-  for (const trakBox of tracks2) {
-    const track = makeBaseMediaTrack(trakBox);
-    if (!track) {
-      continue;
-    }
-    if (track.type === "video") {
-      videoTracks.push(track);
-    } else if (track.type === "audio") {
-      audioTracks.push(track);
-    } else if (track.type === "other") {
-      otherTracks.push(track);
-    }
-  }
-  return {
-    videoTracks,
-    audioTracks,
-    otherTracks
-  };
-};
-
-// src/get-container.ts
-var getContainer = (segments) => {
-  const moovBox = getMoovBox(segments);
-  if (moovBox) {
-    return "mp4";
-  }
-  const mainSegment = getMainSegment(segments);
-  if (mainSegment) {
-    return "webm";
-  }
-  return null;
-};
-var hasContainer = (boxes) => {
-  try {
-    return getContainer(boxes) !== null;
-  } catch {
-    return false;
-  }
-};
-
-// src/get-dimensions.ts
-var getDimensions = (boxes, state) => {
-  const { videoTracks } = getTracks(boxes, state);
-  if (!videoTracks.length) {
-    throw new Error("Expected video track");
-  }
-  const firstVideoTrack = videoTracks[0];
-  return {
-    width: firstVideoTrack.width,
-    height: firstVideoTrack.height,
-    rotation: firstVideoTrack.rotation,
-    unrotatedHeight: firstVideoTrack.displayAspectHeight,
-    unrotatedWidth: firstVideoTrack.displayAspectWidth
-  };
-};
-var hasDimensions = (boxes, state) => {
-  try {
-    return getDimensions(boxes, state) !== null;
-  } catch {
-    return false;
-  }
-};
-
-// src/get-sample-positions.ts
-var getSamplePositions = ({
-  stcoBox,
-  stszBox,
-  stscBox,
-  stssBox,
-  sttsBox,
-  cttsBox
-}) => {
-  const sttsDeltas = [];
-  for (const distribution of sttsBox.sampleDistribution) {
-    for (let i = 0;i < distribution.sampleCount; i++) {
-      sttsDeltas.push(distribution.sampleDelta);
-    }
-  }
-  const cttsEntries = [];
-  for (const entry of cttsBox?.entries ?? [
-    { sampleCount: sttsDeltas.length, sampleOffset: 0 }
-  ]) {
-    for (let i = 0;i < entry.sampleCount; i++) {
-      cttsEntries.push(entry.sampleOffset);
-    }
-  }
-  let dts = 0;
-  const chunks = stcoBox.entries;
-  const samples = [];
-  let samplesPerChunk = 1;
-  for (let i = 0;i < chunks.length; i++) {
-    const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
-    if (hasEntry) {
-      samplesPerChunk = hasEntry.samplesPerChunk;
-    }
-    let offsetInThisChunk = 0;
-    for (let j = 0;j < samplesPerChunk; j++) {
-      const size = stszBox.countType === "fixed" ? stszBox.sampleSize : stszBox.entries[samples.length];
-      const isKeyframe = stssBox ? stssBox.sampleNumber.includes(samples.length + 1) : true;
-      const delta = sttsDeltas[samples.length];
-      const ctsOffset = cttsEntries[samples.length];
-      const cts = dts + ctsOffset;
-      samples.push({
-        offset: Number(chunks[i]) + offsetInThisChunk,
-        size,
-        isKeyframe,
-        dts,
-        cts,
-        duration: delta,
-        chunk: i
-      });
-      dts += delta;
-      offsetInThisChunk += size;
-    }
-  }
-  return samples;
-};
-
-// src/samples-from-moof.ts
-var getSamplesFromTraf = (trafSegment, moofOffset) => {
-  if (trafSegment.type !== "regular-box" || trafSegment.boxType !== "traf") {
-    throw new Error("Expected traf-box");
-  }
-  const tfhdBox = getTfhdBox(trafSegment);
-  const defaultSampleDuration = tfhdBox?.defaultSampleDuration ?? null;
-  const defaultSampleSize = tfhdBox?.defaultSampleSize ?? null;
-  const defaultSampleFlags = tfhdBox?.defaultSampleFlags ?? null;
-  const tfdtBox = getTfdtBox(trafSegment);
-  const trunBoxes = getTrunBoxes(trafSegment);
-  let time = 0;
-  let offset = 0;
-  let dataOffset = 0;
-  const samples = [];
-  for (const trunBox of trunBoxes) {
-    let i = -1;
-    if (trunBox.dataOffset) {
-      dataOffset = trunBox.dataOffset;
-      offset = 0;
-    }
-    for (const sample of trunBox.samples) {
-      i++;
-      const duration2 = sample.sampleDuration ?? defaultSampleDuration;
-      if (duration2 === null) {
-        throw new Error("Expected duration");
-      }
-      const size = sample.sampleSize ?? defaultSampleSize;
-      if (size === null) {
-        throw new Error("Expected size");
-      }
-      const isFirstSample = i === 0;
-      const sampleFlags = sample.sampleFlags ? sample.sampleFlags : isFirstSample && trunBox.firstSampleFlags !== null ? trunBox.firstSampleFlags : defaultSampleFlags;
-      if (sampleFlags === null) {
-        throw new Error("Expected sample flags");
-      }
-      const keyframe = !(sampleFlags >> 16 & 1);
-      const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
-      const samplePosition = {
-        offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
-        dts,
-        cts: dts,
-        duration: duration2,
-        isKeyframe: keyframe,
-        size,
-        chunk: 0
-      };
-      samples.push(samplePosition);
-      offset += size;
-      time += duration2;
-    }
-  }
-  return samples;
-};
-var getSamplesFromMoof = ({
-  moofBox,
-  trackId
-}) => {
-  if (moofBox.type !== "regular-box") {
-    throw new Error("Expected moof-box");
-  }
-  const trafs = moofBox.children.filter((c) => c.type === "regular-box" && c.boxType === "traf");
-  const mapped = trafs.map((traf) => {
-    const tfhdBox = getTfhdBox(traf);
-    return tfhdBox?.trackId === trackId ? getSamplesFromTraf(traf, moofBox.offset) : [];
-  });
-  return mapped.flat(1);
-};
-
-// src/boxes/iso-base-media/get-sample-positions-from-track.ts
-var getSamplePositionsFromTrack = (trakBox, moofBox) => {
-  const stszBox = getStszBox(trakBox);
-  const stcoBox = getStcoBox(trakBox);
-  const stscBox = getStscBox(trakBox);
-  const stssBox = getStssBox(trakBox);
-  const sttsBox = getSttsBox(trakBox);
-  const tkhdBox = getTkhdBox(trakBox);
-  const cttsBox = getCttsBox(trakBox);
-  const timescaleAndDuration = getTimescaleAndDuration(trakBox);
-  if (!tkhdBox) {
-    throw new Error("Expected tkhd box in trak box");
-  }
-  if (!stszBox) {
-    throw new Error("Expected stsz box in trak box");
-  }
-  if (!stcoBox) {
-    throw new Error("Expected stco box in trak box");
-  }
-  if (!stscBox) {
-    throw new Error("Expected stsc box in trak box");
-  }
-  if (!sttsBox) {
-    throw new Error("Expected stts box in trak box");
-  }
-  if (!timescaleAndDuration) {
-    throw new Error("Expected timescale and duration in trak box");
-  }
-  let samplePositions = getSamplePositions({
-    stcoBox,
-    stscBox,
-    stszBox,
-    stssBox,
-    sttsBox,
-    cttsBox
-  });
-  if (samplePositions.length === 0 && moofBox) {
-    samplePositions = getSamplesFromMoof({ moofBox, trackId: tkhdBox.trackId });
-  }
-  return samplePositions;
-};
-
-// src/get-duration.ts
-var getDurationFromMatroska = (segments) => {
-  const mainSegment = segments.find((s) => s.type === "Segment");
-  if (!mainSegment || mainSegment.type !== "Segment") {
-    return null;
-  }
-  const { value: children } = mainSegment;
-  if (!children) {
-    return null;
-  }
-  const infoSegment = children.find((s) => s.type === "Info");
-  const relevantBoxes = [
-    ...mainSegment.value,
-    ...infoSegment && infoSegment.type === "Info" ? infoSegment.value : []
-  ];
-  const timestampScale2 = relevantBoxes.find((s) => s.type === "TimestampScale");
-  if (!timestampScale2 || timestampScale2.type !== "TimestampScale") {
-    return null;
+      otherTracks
+    };
   }
-  const duration2 = relevantBoxes.find((s) => s.type === "Duration");
-  if (!duration2 || duration2.type !== "Duration") {
-    return null;
+  const tracks2 = getTraks(moovBox);
+  for (const trakBox of tracks2) {
+    const track = makeBaseMediaTrack(trakBox);
+    if (!track) {
+      continue;
+    }
+    if (track.type === "video") {
+      videoTracks.push(track);
+    } else if (track.type === "audio") {
+      audioTracks.push(track);
+    } else if (track.type === "other") {
+      otherTracks.push(track);
+    }
   }
-  return duration2.value.value / timestampScale2.value.value * 1000;
+  return {
+    videoTracks,
+    audioTracks,
+    otherTracks
+  };
 };
-var getDuration = (boxes, parserState) => {
-  const matroskaBox = boxes.find((b) => b.type === "Segment");
-  if (matroskaBox) {
-    return getDurationFromMatroska(boxes);
-  }
-  const moovBox = getMoovBox(boxes);
-  if (!moovBox) {
-    return null;
+
+// src/get-container.ts
+var getContainer = (segments) => {
+  const moovBox = getMoovBox(segments);
+  if (moovBox) {
+    return "mp4";
   }
-  const moofBox = getMoofBox(boxes);
-  const mvhdBox = getMvhdBox(moovBox);
-  if (!mvhdBox) {
-    return null;
+  const mainSegment = getMainSegment(segments);
+  if (mainSegment) {
+    return "webm";
   }
-  if (mvhdBox.type !== "mvhd-box") {
-    throw new Error("Expected mvhd-box");
+  return null;
+};
+var hasContainer = (boxes) => {
+  try {
+    return getContainer(boxes) !== null;
+  } catch {
+    return false;
   }
-  if (mvhdBox.durationInSeconds > 0) {
-    return mvhdBox.durationInSeconds;
+};
+
+// src/get-dimensions.ts
+var getDimensions = (boxes, state) => {
+  const { videoTracks } = getTracks(boxes, state);
+  if (!videoTracks.length) {
+    throw new Error("Expected video track");
   }
-  const tracks2 = getTracks(boxes, parserState);
-  const allTracks = [
-    ...tracks2.videoTracks,
-    ...tracks2.audioTracks,
-    ...tracks2.otherTracks
-  ];
-  const allSamples = allTracks.map((t) => {
-    const { timescale: ts } = t;
-    const samplePositions = getSamplePositionsFromTrack(t.trakBox, moofBox);
-    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
-    return highest ?? 0;
-  });
-  const highestTimestamp = Math.max(...allSamples);
-  return highestTimestamp;
+  const firstVideoTrack = videoTracks[0];
+  return {
+    width: firstVideoTrack.width,
+    height: firstVideoTrack.height,
+    rotation: firstVideoTrack.rotation,
+    unrotatedHeight: firstVideoTrack.displayAspectHeight,
+    unrotatedWidth: firstVideoTrack.displayAspectWidth
+  };
 };
-var hasDuration = (boxes, parserState) => {
+var hasDimensions = (boxes, state) => {
   try {
-    const duration2 = getDuration(boxes, parserState);
-    return getDuration(boxes, parserState) !== null && duration2 !== 0;
+    return getDimensions(boxes, state) !== null;
   } catch {
     return false;
   }
@@ -5115,14 +5136,14 @@ var emitAvailableInfo = ({
   const keys = Object.keys(hasInfo);
   for (const key of keys) {
     if (key === "boxes") {
-      if (hasInfo.boxes && returnValue.boxes === undefined) {
+      if (parseResult && hasInfo.boxes && returnValue.boxes === undefined) {
         moreFields.onBoxes?.(parseResult.segments);
         returnValue.boxes = parseResult.segments;
       }
       continue;
     }
     if (key === "durationInSeconds") {
-      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined) {
+      if (hasInfo.durationInSeconds && returnValue.durationInSeconds === undefined && parseResult) {
         const durationInSeconds = getDuration(parseResult.segments, state);
         moreFields.onDurationInSeconds?.(durationInSeconds);
         returnValue.durationInSeconds = durationInSeconds;
@@ -5130,7 +5151,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "dimensions") {
-      if (hasInfo.dimensions && returnValue.dimensions === undefined) {
+      if (hasInfo.dimensions && returnValue.dimensions === undefined && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const dimensions = {
           height: dimensionsQueried.height,
@@ -5142,7 +5163,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "unrotatedDimensions") {
-      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions) {
+      if (returnValue.unrotatedDimensions === undefined && hasInfo.unrotatedDimensions && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const unrotatedDimensions = {
           height: dimensionsQueried.unrotatedHeight,
@@ -5154,7 +5175,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "rotation") {
-      if (returnValue.rotation === undefined && hasInfo.rotation) {
+      if (returnValue.rotation === undefined && hasInfo.rotation && parseResult) {
         const dimensionsQueried = getDimensions(parseResult.segments, state);
         const { rotation } = dimensionsQueried;
         moreFields.onRotation?.(rotation);
@@ -5163,7 +5184,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "fps") {
-      if (returnValue.fps === undefined && hasInfo.fps) {
+      if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
         const fps = getFps(parseResult.segments);
         moreFields.onFps?.(fps);
         returnValue.fps = fps;
@@ -5171,7 +5192,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "videoCodec") {
-      if (returnValue.videoCodec === undefined && hasInfo.videoCodec) {
+      if (returnValue.videoCodec === undefined && hasInfo.videoCodec && parseResult) {
         const videoCodec = getVideoCodec(parseResult.segments);
         moreFields.onVideoCodec?.(videoCodec);
         returnValue.videoCodec = videoCodec;
@@ -5179,7 +5200,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "audioCodec") {
-      if (returnValue.audioCodec === undefined && hasInfo.audioCodec) {
+      if (returnValue.audioCodec === undefined && hasInfo.audioCodec && parseResult) {
         const audioCodec = getAudioCodec(parseResult.segments, state);
         moreFields.onAudioCodec?.(audioCodec);
         returnValue.audioCodec = audioCodec;
@@ -5187,7 +5208,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "tracks") {
-      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined) {
+      if (hasInfo.tracks && returnValue.videoTracks === undefined && returnValue.audioTracks === undefined && parseResult) {
         const { videoTracks, audioTracks } = getTracks(parseResult.segments, state);
         moreFields.onTracks?.({ videoTracks, audioTracks });
         returnValue.videoTracks = videoTracks;
@@ -5218,7 +5239,7 @@ var emitAvailableInfo = ({
       continue;
     }
     if (key === "container") {
-      if (returnValue.container === undefined && hasInfo.container) {
+      if (returnValue.container === undefined && hasInfo.container && parseResult) {
         const container = getContainer(parseResult.segments);
         moreFields.onContainer?.(container);
         returnValue.container = container;
@@ -5234,25 +5255,25 @@ var getAvailableInfo = (options, parseResult, state) => {
   const keys = Object.entries(options).filter(([, value]) => value);
   const infos = keys.map(([key]) => {
     if (key === "boxes") {
-      return parseResult.status === "done";
+      return Boolean(parseResult && parseResult.status === "done");
     }
     if (key === "durationInSeconds") {
-      return hasDuration(parseResult.segments, state);
+      return Boolean(parseResult && hasDuration(parseResult.segments, state));
     }
     if (key === "dimensions" || key === "rotation" || key === "unrotatedDimensions") {
-      return hasDimensions(parseResult.segments, state);
+      return Boolean(parseResult && hasDimensions(parseResult.segments, state));
     }
     if (key === "fps") {
-      return hasFps(parseResult.segments);
+      return Boolean(parseResult && hasFps(parseResult.segments));
     }
     if (key === "videoCodec") {
-      return hasVideoCodec(parseResult.segments);
+      return Boolean(parseResult && hasVideoCodec(parseResult.segments));
     }
     if (key === "audioCodec") {
-      return hasAudioCodec(parseResult.segments, state);
+      return Boolean(parseResult && hasAudioCodec(parseResult.segments));
     }
     if (key === "tracks") {
-      return hasTracks(parseResult.segments);
+      return Boolean(parseResult && hasTracks(parseResult.segments));
     }
     if (key === "internalStats") {
       return false;
@@ -5264,7 +5285,7 @@ var getAvailableInfo = (options, parseResult, state) => {
       return true;
     }
     if (key === "container") {
-      return hasContainer(parseResult.segments);
+      return Boolean(parseResult && hasContainer(parseResult.segments));
     }
     throw new Error(`Unknown key: ${key}`);
   });
@@ -7605,32 +7626,54 @@ var postprocessEbml = async ({
 };
 
 // src/boxes/webm/segments.ts
-var parseSegment = async ({
-  segmentId,
+var continueAfterMatroskaParseResult = async ({
+  result,
   iterator,
-  length,
   parserContext,
-  headerReadSoFar
+  segment
 }) => {
-  if (length < 0) {
-    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  iterator.counter.decrement(headerReadSoFar);
-  const offset = iterator.counter.getOffset();
-  const ebml = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml, parserContext });
-  return remapped;
+  const proceeded = await result.continueParsing();
+  if (proceeded.status === "done") {
+    return {
+      status: "done",
+      segment
+    };
+  }
+  return {
+    continueParsing() {
+      return continueAfterMatroskaParseResult({
+        result: proceeded,
+        iterator,
+        parserContext,
+        segment
+      });
+    },
+    segment: null,
+    status: "incomplete"
+  };
 };
-var expectSegment = async (iterator, parserContext) => {
-  const offset = iterator.counter.getOffset();
+var expectSegment = async ({
+  iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  iterator.counter.decrement(iterator.counter.getOffset() - offset);
   if (iterator.bytesRemaining() === 0) {
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const segmentId = iterator.getMatroskaSegmentId();
@@ -7638,11 +7681,15 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectAndProcessSegment({
+          iterator,
+          parserContext,
+          offset,
+          children
+        });
       },
-      skipTo: null
+      segment: null
     };
   }
   const offsetBeforeVInt = iterator.counter.getOffset();
@@ -7652,41 +7699,43 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     return {
       status: "incomplete",
-      segments: [],
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
+        return expectSegment({ iterator, parserContext, offset, children });
       },
-      skipTo: null
+      segment: null
     };
   }
   const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
   if (segmentId === "0x18538067" || segmentId === "0x1f43b675") {
+    const newSegment = {
+      type: segmentId === "0x18538067" ? "Segment" : "Cluster",
+      minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+      value: []
+    };
     const main = await expectChildren({
       iterator,
       length,
-      initialChildren: [],
-      wrap: segmentId === "0x18538067" ? (s) => ({
-        type: "Segment",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }) : (s) => ({
-        type: "Cluster",
-        value: s,
-        minVintWidth: offsetAfterVInt - offsetBeforeVInt
-      }),
-      parserContext
+      children: newSegment.value,
+      parserContext,
+      startOffset: iterator.counter.getOffset()
     });
     if (main.status === "incomplete") {
       return {
         status: "incomplete",
-        segments: main.segments,
-        skipTo: null,
-        continueParsing: main.continueParsing
+        continueParsing: () => {
+          return continueAfterMatroskaParseResult({
+            iterator,
+            parserContext,
+            result: main,
+            segment: newSegment
+          });
+        },
+        segment: newSegment
       };
     }
     return {
       status: "done",
-      segments: main.segments
+      segment: newSegment
     };
   }
   if (bytesRemainingNow < length) {
@@ -7694,11 +7743,10 @@ var expectSegment = async (iterator, parserContext) => {
     iterator.counter.decrement(bytesRead);
     return {
       status: "incomplete",
-      segments: [],
+      segment: null,
       continueParsing: () => {
-        return Promise.resolve(expectSegment(iterator, parserContext));
-      },
-      skipTo: null
+        return expectSegment({ iterator, parserContext, offset, children });
+      }
     };
   }
   const segment = await parseSegment({
@@ -7710,131 +7758,179 @@ var expectSegment = async (iterator, parserContext) => {
   });
   return {
     status: "done",
-    segments: [segment]
+    segment
   };
 };
+var parseSegment = async ({
+  segmentId,
+  iterator,
+  length,
+  parserContext,
+  headerReadSoFar
+}) => {
+  if (length < 0) {
+    throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+  }
+  iterator.counter.decrement(headerReadSoFar);
+  const offset = iterator.counter.getOffset();
+  const ebml = await parseEbml(iterator, parserContext);
+  const remapped = await postprocessEbml({ offset, ebml, parserContext });
+  return remapped;
+};
 
 // src/boxes/webm/segments/parse-children.ts
 var processParseResult = ({
   parseResult,
-  children,
-  wrap
+  children
 }) => {
+  if (parseResult.segment && !children.includes(parseResult.segment)) {
+    children.push(parseResult.segment);
+  }
   if (parseResult.status === "incomplete") {
     return {
       status: "incomplete",
-      segments: [],
+      segment: parseResult.segment,
       continueParsing: async () => {
         const newParseResult = await parseResult.continueParsing();
         return processParseResult({
           children,
-          parseResult: newParseResult,
-          wrap
+          parseResult: newParseResult
         });
-      },
-      skipTo: null
+      }
     };
   }
-  for (const segment of parseResult.segments) {
-    children.push(segment);
-  }
   return {
     status: "done",
-    segments: wrap ? [wrap(children)] : children
+    segment: parseResult.segment
   };
 };
-var continueParsingfunction = ({
-  result,
+var expectAndProcessSegment = async ({
   iterator,
+  parserContext,
+  offset,
+  children
+}) => {
+  const segment = await expectSegment({
+    iterator,
+    parserContext,
+    offset,
+    children
+  });
+  return processParseResult({
+    children,
+    parseResult: segment
+  });
+};
+var continueAfterSegmentResult = async ({
+  result,
+  length,
   children,
-  wrap,
   parserContext,
-  length
-}) => async () => {
-  if (result.status !== "incomplete") {
-    throw new Error("expected incomplete");
+  iterator,
+  startOffset
+}) => {
+  if (result.status === "done") {
+    throw new Error("Should not continue after done");
   }
-  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");
-    }
+  const segmentResult = await result.continueParsing();
+  if (segmentResult.status === "done") {
     return {
       status: "incomplete",
-      continueParsing: continueParsingfunction({
-        result: continued,
-        iterator,
-        children,
-        wrap,
-        parserContext,
-        length: length - (iterator.counter.getOffset() - offset)
-      }),
-      skipTo: continued.skipTo,
-      segments: wrap ? [wrap(children)] : children
+      continueParsing: () => {
+        return expectChildren({
+          children,
+          iterator,
+          length,
+          parserContext,
+          startOffset
+        });
+      },
+      skipTo: null
     };
   }
-  return expectChildren({
-    iterator,
-    length: length - (iterator.counter.getOffset() - offset),
-    initialChildren: children,
-    wrap,
-    parserContext
-  });
+  return {
+    status: "incomplete",
+    continueParsing: () => {
+      return continueAfterSegmentResult({
+        result: segmentResult,
+        children,
+        iterator,
+        length,
+        parserContext,
+        startOffset
+      });
+    },
+    skipTo: null
+  };
 };
 var expectChildren = async ({
   iterator,
   length,
-  initialChildren,
-  wrap,
-  parserContext
+  children,
+  parserContext,
+  startOffset
 }) => {
-  const children = [...initialChildren];
-  const startOffset = iterator.counter.getOffset();
   while (iterator.counter.getOffset() < startOffset + length) {
     if (iterator.bytesRemaining() === 0) {
       break;
     }
-    const parseResult = await expectSegment(iterator, parserContext);
-    const child = processParseResult({
-      children,
-      parseResult,
-      wrap
+    const currentOffset = iterator.counter.getOffset();
+    const child = await expectAndProcessSegment({
+      iterator,
+      parserContext,
+      offset: currentOffset,
+      children
     });
     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({
-          result: child,
-          iterator,
-          children,
-          wrap,
-          parserContext,
-          length: length - (iterator.counter.getOffset() - startOffset)
-        }),
-        skipTo: child.skipTo,
-        segments: wrap ? [wrap(children)] : children
+        continueParsing: () => {
+          return continueAfterSegmentResult({
+            result: child,
+            children,
+            iterator,
+            length: length - (currentOffset - startOffset),
+            parserContext,
+            startOffset: currentOffset
+          });
+        },
+        skipTo: null
       };
     }
   }
   return {
-    status: "done",
-    segments: wrap ? [wrap(children)] : children
+    status: "done"
   };
 };
 
 // src/boxes/webm/parse-webm-header.ts
-var parseWebm = (counter, parserContext) => {
-  return expectChildren({
+var continueAfterMatroskaResult = (result, children) => {
+  if (result.status === "done") {
+    return {
+      status: "done",
+      segments: children
+    };
+  }
+  return {
+    status: "incomplete",
+    segments: children,
+    continueParsing: async () => {
+      const newResult = await result.continueParsing();
+      return continueAfterMatroskaResult(newResult, children);
+    },
+    skipTo: null
+  };
+};
+var parseWebm = async (counter, parserContext) => {
+  const children = [];
+  const results = await expectChildren({
     iterator: counter,
     length: Infinity,
-    initialChildren: [],
-    wrap: null,
-    parserContext
+    children,
+    parserContext,
+    startOffset: counter.counter.getOffset()
   });
+  return continueAfterMatroskaResult(results, children);
 };
 
 // src/parse-video.ts
@@ -7863,6 +7959,7 @@ var parseVideo = ({
     throw new Error("AVI files are not yet supported");
   }
   if (iterator.isIsoBaseMedia()) {
+    Log.verbose(logLevel, "Detected ISO Base Media container");
     return parseBoxes({
       iterator,
       maxBytes: Infinity,
@@ -7875,6 +7972,7 @@ var parseVideo = ({
     });
   }
   if (iterator.isWebm()) {
+    Log.verbose(logLevel, "Detected Matroska container");
     return Promise.resolve(parseWebm(iterator, options));
   }
   if (iterator.isMp3()) {
@@ -8016,6 +8114,7 @@ var parseMedia = async ({
   onVideoTrack,
   signal,
   logLevel = "info",
+  onParseProgress,
   ...more
 }) => {
   const state = makeParserState({
@@ -8035,14 +8134,40 @@ var parseMedia = async ({
   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 || onVideoTrack),
+    canSkipVideoData,
     onAudioTrack: onAudioTrack ?? null,
     onVideoTrack: onVideoTrack ?? null,
     parserState: state,
     nullifySamples: !(typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.KEEP_SAMPLES === "true"),
     supportsContentRange
   };
+  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);
+    emitAvailableInfo({
+      hasInfo: availableInfo,
+      moreFields,
+      parseResult,
+      state,
+      returnValue,
+      contentLength,
+      name
+    });
+  };
+  triggerInfoEmit();
   while (parseResult === null || parseResult.status === "incomplete") {
     if (signal?.aborted) {
       throw new Error("Aborted");
@@ -8069,7 +8194,14 @@ var parseMedia = async ({
     if (!iterator) {
       throw new Error("Unexpected null");
     }
+    await onParseProgress?.({
+      bytes: iterator.counter.getOffset(),
+      percentage: contentLength ? iterator.counter.getOffset() / contentLength : null,
+      totalBytes: contentLength
+    });
+    triggerInfoEmit();
     if (parseResult && parseResult.status === "incomplete") {
+      Log.verbose(logLevel, "Continuing parsing of file, currently at position", iterator.counter.getOffset(), getAvailableInfo(fields ?? {}, parseResult, state));
       parseResult = await parseResult.continueParsing();
     } else {
       parseResult = await parseVideo({
@@ -8079,18 +8211,7 @@ var parseMedia = async ({
         logLevel
       });
     }
-    const availableInfo = getAvailableInfo(fields ?? {}, parseResult, state);
-    const hasAllInfo = Object.values(availableInfo).every(Boolean);
-    emitAvailableInfo({
-      hasInfo: availableInfo,
-      moreFields,
-      parseResult,
-      state,
-      returnValue,
-      contentLength,
-      name
-    });
-    if (hasAllInfo && !onVideoTrack && !onAudioTrack) {
+    if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
       break;
     }
     if (parseResult && parseResult.status === "incomplete" && parseResult.skipTo !== null) {
@@ -8103,6 +8224,7 @@ var parseMedia = async ({
       iterator.skipTo(parseResult.skipTo, true);
     }
   }
+  Log.verbose(logLevel, "Finished parsing file");
   emitAvailableInfo({
     hasInfo: Object.keys(fields ?? {}).reduce((acc, key) => {
       acc[key] = true;
@@ -8119,6 +8241,9 @@ var parseMedia = async ({
   iterator?.destroy();
   return returnValue;
 };
+// src/version.ts
+var VERSION = "4.0.231";
+
 // src/index.ts
 var MediaParserInternals = {
   createMatroskaMedia,
@@ -8127,5 +8252,6 @@ var MediaParserInternals = {
 };
 export {
   parseMedia,
+  VERSION,
   MediaParserInternals
 };