@remotion/media-parser 4.0.214 → 4.0.216

package/dist/boxes/webm/ebml.d.ts

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 5 | 3 | 6 | 4;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/get-track.d.ts

@@ -0,0 +1,6 @@
+import type { AudioTrack, VideoTrack } from '../../get-tracks';
+import type { TrackEntry } from './segments/all-segments';
+export declare const getTrack: ({ timescale, track, }: {
+    timescale: number;
+    track: TrackEntry;
+}) => VideoTrack | AudioTrack | null;

package/dist/boxes/webm/get-track.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrack = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
+const traversal_1 = require("../../traversal");
+const av1_codec_private_1 = require("./av1-codec-private");
+const description_1 = require("./description");
+const track_entry_1 = require("./segments/track-entry");
+const getDescription = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec) {
+        return undefined;
+    }
+    if (codec.value === 'V_MPEG4/ISO/AVC' || codec.value === 'V_MPEGH/ISO/HEVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            return priv;
+        }
+    }
+    return undefined;
+};
+const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
+    if (codec.value === 'V_VP8') {
+        return 'vp8';
+    }
+    if (codec.value === 'V_VP9') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            throw new Error('@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it?');
+        }
+        return 'vp09.00.10.08';
+    }
+    if (codec.value === 'V_MPEG4/ISO/AVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (priv) {
+            return `avc1.${priv[1].toString(16).padStart(2, '0')}${priv[2].toString(16).padStart(2, '0')}${priv[3].toString(16).padStart(2, '0')}`;
+        }
+        throw new Error('Could not find a CodecPrivate field in TrackEntry');
+    }
+    if (codec.value === 'V_AV1') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        if (!priv) {
+            throw new Error('Expected private data in AV1 track');
+        }
+        return (0, av1_codec_private_1.parseAv1PrivateData)(priv, null);
+    }
+    if (codec.value === 'V_MPEGH/ISO/HEVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
+        return 'hvc1.' + (0, make_hvc1_codec_strings_1.getHvc1CodecString)(iterator);
+    }
+    throw new Error(`Unknown codec: ${codec.value}`);
+};
+const getMatroskaAudioCodecString = (track) => {
+    const codec = (0, traversal_1.getCodecSegment)(track);
+    if (!codec) {
+        throw new Error('Expected codec segment');
+    }
+    if (codec.value === 'A_OPUS') {
+        return 'opus';
+    }
+    if (codec.value === 'A_VORBIS') {
+        return 'vorbis';
+    }
+    if (codec.value === 'A_PCM/INT/LIT') {
+        // https://github.com/ietf-wg-cellar/matroska-specification/issues/142#issuecomment-330004950
+        // Audio samples MUST be considered as signed values, except if the audio bit depth is 8 which MUST be interpreted as unsigned values.
+        const bitDepth = (0, traversal_1.getBitDepth)(track);
+        if (bitDepth === null) {
+            throw new Error('Expected bit depth');
+        }
+        if (bitDepth === 8) {
+            return 'pcm-u8';
+        }
+        return 'pcm-s' + bitDepth;
+    }
+    if (codec.value === 'A_AAC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
+        iterator.startReadingBits();
+        /**
+         * ChatGPT
+         * 	▪	The first 5 bits represent the AOT.
+                ▪	Common values:
+                ◦	1 for AAC Main
+                ◦	2 for AAC LC (Low Complexity)
+                ◦	3 for AAC SSR (Scalable Sample Rate)
+                ◦	4 for AAC LTP (Long Term Prediction)
+                ◦	5 for SBR (Spectral Band Replication)
+                ◦	29 for HE-AAC (which uses SBR with AAC LC)
+         */
+        /**
+         * Fully qualified codec:
+         * This codec has multiple possible codec strings:
+            "mp4a.40.2" — MPEG-4 AAC LC
+            "mp4a.40.02" — MPEG-4 AAC LC, leading 0 for Aud-OTI compatibility
+            "mp4a.40.5" — MPEG-4 HE-AAC v1 (AAC LC + SBR)
+            "mp4a.40.05" — MPEG-4 HE-AAC v1 (AAC LC + SBR), leading 0 for Aud-OTI compatibility
+            "mp4a.40.29" — MPEG-4 HE-AAC v2 (AAC LC + SBR + PS)
+            "mp4a.67" — MPEG-2 AAC LC
+        */
+        const profile = iterator.getBits(5);
+        iterator.stopReadingBits();
+        iterator.destroy();
+        return `mp4a.40.${profile.toString().padStart(2, '0')}`;
+    }
+    if (codec.value === 'A_MPEG/L3') {
+        return 'mp3';
+    }
+    throw new Error(`Unknown codec: ${codec.value}`);
+};
+const getTrack = ({ timescale, track, }) => {
+    const trackType = (0, traversal_1.getTrackTypeSegment)(track);
+    if (!trackType) {
+        throw new Error('Expected track type segment');
+    }
+    const trackId = (0, traversal_1.getTrackId)(track);
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'video') {
+        const width = (0, traversal_1.getWidthSegment)(track);
+        if (width === null) {
+            throw new Error('Expected width segment');
+        }
+        const height = (0, traversal_1.getHeightSegment)(track);
+        if (height === null) {
+            throw new Error('Expected height segment');
+        }
+        const displayHeight = (0, traversal_1.getDisplayHeightSegment)(track);
+        const displayWidth = (0, traversal_1.getDisplayWidthSegment)(track);
+        const codec = (0, traversal_1.getCodecSegment)(track);
+        if (!codec) {
+            return null;
+        }
+        const codecString = getMatroskaVideoCodecString({
+            track,
+            codecSegment: codec,
+        });
+        if (!codecString) {
+            return null;
+        }
+        return {
+            type: 'video',
+            trackId,
+            codec: codecString,
+            description: getDescription(track),
+            height: displayHeight ? displayHeight.value.value : height.value.value,
+            width: displayWidth ? displayWidth.value.value : width.value.value,
+            sampleAspectRatio: {
+                numerator: 1,
+                denominator: 1,
+            },
+            timescale,
+            codedHeight: height.value.value,
+            codedWidth: width.value.value,
+            displayAspectHeight: displayHeight
+                ? displayHeight.value.value
+                : height.value.value,
+            displayAspectWidth: displayWidth
+                ? displayWidth.value.value
+                : width.value.value,
+            rotation: 0,
+            trakBox: null,
+        };
+    }
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
+        const sampleRate = (0, traversal_1.getSampleRate)(track);
+        const numberOfChannels = (0, traversal_1.getNumberOfChannels)(track);
+        if (sampleRate === null) {
+            throw new Error('Could not find sample rate or number of channels');
+        }
+        return {
+            type: 'audio',
+            trackId,
+            codec: getMatroskaAudioCodecString(track),
+            timescale,
+            numberOfChannels,
+            sampleRate,
+            description: (0, description_1.getAudioDescription)(track),
+            trakBox: null,
+        };
+    }
+    return null;
+};
+exports.getTrack = getTrack;

package/dist/esm/from-node.mjs

@@ -1,7 +1,7 @@
 // src/readers/from-node.ts
-import {createReadStream} from "fs";
-import {stat} from "node:fs/promises";
-import {Readable} from "stream";
+import { createReadStream } from "fs";
+import { stat } from "node:fs/promises";
+import { Readable } from "stream";
 var nodeReader = {
   read: async (src, range, signal) => {
     if (typeof src !== "string") {

package/dist/esm/index.mjs

@@ -1233,14 +1233,14 @@ var makeMatroskaHeader = () => {
 };
 
 // src/create/matroska-info.ts
-var makeMatroskaInfo = ({ timescale: timescale2 }) => {
+var makeMatroskaInfo = ({ timescale }) => {
   return makeMatroskaBytes({
     type: "Info",
     value: [
       {
         type: "TimestampScale",
         value: {
-          value: timescale2,
+          value: timescale,
           byteLength: null
         },
         minVintWidth: null
@@ -1569,7 +1569,7 @@ var makeMatroskaColorBytes = ({
 
 // src/create/matroska-trackentry.ts
 var makeMatroskaVideoBytes = ({
-  color: color3,
+  color: color2,
   width,
   height
 }) => {
@@ -1600,7 +1600,7 @@ var makeMatroskaVideoBytes = ({
         },
         minVintWidth: null
       },
-      makeMatroskaColorBytes(color3)
+      makeMatroskaColorBytes(color2)
     ],
     minVintWidth: null
   });
@@ -1735,7 +1735,7 @@ var makeMatroskaAudioTrackEntryBytes = ({
   });
 };
 var makeMatroskaVideoTrackEntryBytes = ({
-  color: color3,
+  color: color2,
   width,
   height,
   trackNumber: trackNumber2,
@@ -1794,7 +1794,7 @@ var makeMatroskaVideoTrackEntryBytes = ({
         minVintWidth: null
       },
       makeMatroskaVideoBytes({
-        color: color3,
+        color: color2,
         width,
         height
       }),
@@ -1890,13 +1890,13 @@ var createMedia = async (writer) => {
   };
   const addSample = async (chunk, trackNumber2, isVideo) => {
     trackNumberProgresses[trackNumber2] = chunk.timestamp;
-    const { cluster: cluster2, isNew, smallestProgress } = await getClusterOrMakeNew({
+    const { cluster, isNew, smallestProgress } = await getClusterOrMakeNew({
       chunk,
       isVideo
     });
     const newDuration = Math.round((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     await updateDuration(newDuration);
-    const { timecodeRelativeToCluster } = await cluster2.addSample(chunk, trackNumber2);
+    const { timecodeRelativeToCluster } = await cluster.addSample(chunk, trackNumber2);
     if (isNew) {
       const newCluster = w.getWrittenByteCount();
       cues.push({
@@ -3474,7 +3474,7 @@ var getMatroskaAudioCodecString = (track) => {
   throw new Error(`Unknown codec: ${codec.value}`);
 };
 var getTrack = ({
-  timescale: timescale3,
+  timescale,
   track
 }) => {
   const trackType2 = getTrackTypeSegment(track);
@@ -3517,7 +3517,7 @@ var getTrack = ({
         numerator: 1,
         denominator: 1
       },
-      timescale: timescale3,
+      timescale,
       codedHeight: height.value.value,
       codedWidth: width.value.value,
       displayAspectHeight: displayHeight2 ? displayHeight2.value.value : height.value.value,
@@ -3547,7 +3547,7 @@ var getTrack = ({
       type: "audio",
       trackId,
       codec: getMatroskaAudioCodecString(track),
-      timescale: timescale3,
+      timescale,
       numberOfChannels,
       sampleRate,
       description: getAudioDescription(track),
@@ -3562,7 +3562,7 @@ var getTrack = ({
 };
 
 // src/boxes/webm/get-ready-tracks.ts
-var getTracksFromMatroska = (segment, timescale3) => {
+var getTracksFromMatroska = (segment, timescale) => {
   const tracksSegment = getTracksSegment(segment);
   if (!tracksSegment) {
     throw new Error("No tracks segment");
@@ -3577,7 +3577,7 @@ var getTracksFromMatroska = (segment, timescale3) => {
     }
     const track = getTrack({
       track: trackEntrySegment,
-      timescale: timescale3
+      timescale
     });
     if (track) {
       tracks2.push(track);
@@ -4383,7 +4383,7 @@ var parseMdhd = ({
   data.discard(3);
   const creationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
   const modificationTime = version === 1 ? Number(data.getUint64()) : data.getUint32();
-  const timescale3 = data.getUint32();
+  const timescale = data.getUint32();
   const duration2 = version === 1 ? data.getUint64() : data.getUint32();
   const language2 = data.getUint16();
   const quality = data.getUint16();
@@ -4394,7 +4394,7 @@ var parseMdhd = ({
   return {
     type: "mdhd-box",
     duration: Number(duration2),
-    timescale: timescale3,
+    timescale,
     version,
     language: language2,
     quality,
@@ -5133,13 +5133,13 @@ var parseStsz = ({
       sampleSize
     };
   }
-  const samples2 = [];
+  const samples = [];
   for (let i = 0;i < sampleCount; i++) {
     const bytesRemaining = size - (iterator.counter.getOffset() - offset);
     if (bytesRemaining < 4) {
       break;
     }
-    samples2.push(iterator.getUint32());
+    samples.push(iterator.getUint32());
   }
   iterator.discard(size - (iterator.counter.getOffset() - offset));
   return {
@@ -5150,7 +5150,7 @@ var parseStsz = ({
     flags: [...flags],
     sampleCount,
     countType: "variable",
-    entries: samples2
+    entries: samples
   };
 };
 
@@ -5371,13 +5371,13 @@ var parseTrun = ({
   const sampleCount = iterator.getUint32();
   const dataOffset = flags & 1 ? iterator.getInt32() : null;
   const firstSampleFlags = flags & 4 ? iterator.getUint32() : null;
-  const samples2 = [];
+  const samples = [];
   for (let i = 0;i < sampleCount; i++) {
     const sampleDuration = flags & 256 ? iterator.getUint32() : null;
     const sampleSize = flags & 512 ? iterator.getUint32() : null;
     const sampleFlags = flags & 1024 ? iterator.getUint32() : null;
     const sampleCompositionTimeOffset = flags & 2048 ? version === 0 ? iterator.getUint32() : iterator.getInt32Le() : null;
-    samples2.push({
+    samples.push({
       sampleDuration,
       sampleSize,
       sampleFlags,
@@ -5395,7 +5395,7 @@ var parseTrun = ({
     sampleCount,
     dataOffset,
     firstSampleFlags,
-    samples: samples2
+    samples
   };
 };
 
@@ -6075,26 +6075,26 @@ var parseBlockFlags = (iterator, type) => {
 };
 
 // src/boxes/webm/get-sample-from-block.ts
-var getSampleFromBlock = (ebml5, parserContext, offset) => {
-  const iterator = getArrayBufferIterator(ebml5.value, ebml5.value.length);
+var getSampleFromBlock = (ebml, parserContext, offset) => {
+  const iterator = getArrayBufferIterator(ebml.value, ebml.value.length);
   const trackNumber2 = iterator.getVint();
   if (trackNumber2 === null) {
     throw new Error("Not enough data to get track number, should not happen");
   }
   const timecodeRelativeToCluster = iterator.getInt16();
-  const { keyframe } = parseBlockFlags(iterator, ebml5.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
+  const { keyframe } = parseBlockFlags(iterator, ebml.type === "SimpleBlock" ? matroskaElements.SimpleBlock : matroskaElements.Block);
   const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber2);
   const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-  const timescale3 = parserContext.parserState.getTimescale();
+  const timescale = parserContext.parserState.getTimescale();
   if (clusterOffset === undefined) {
     throw new Error("Could not find offset for byte offset " + offset);
   }
-  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale3 * (trackTimescale ?? 1);
+  const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) * timescale * (trackTimescale ?? 1);
   const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
   if (!codec) {
     throw new Error(`Could not find codec for track ${trackNumber2}`);
   }
-  const remainingNow = ebml5.value.length - (iterator.counter.getOffset() - 0);
+  const remainingNow = ebml.value.length - (iterator.counter.getOffset() - 0);
   if (codec.startsWith("V_")) {
     const partialVideoSample = {
       data: iterator.getSlice(remainingNow),
@@ -6231,16 +6231,16 @@ var parseEbml = async (iterator, parserContext) => {
 };
 var postprocessEbml = async ({
   offset,
-  ebml: ebml5,
+  ebml,
   parserContext
 }) => {
-  if (ebml5.type === "TimestampScale") {
-    parserContext.parserState.setTimescale(ebml5.value.value);
+  if (ebml.type === "TimestampScale") {
+    parserContext.parserState.setTimescale(ebml.value.value);
   }
-  if (ebml5.type === "TrackEntry") {
-    parserContext.parserState.onTrackEntrySegment(ebml5);
+  if (ebml.type === "TrackEntry") {
+    parserContext.parserState.onTrackEntrySegment(ebml);
     const track = getTrack({
-      track: ebml5,
+      track: ebml,
       timescale: parserContext.parserState.getTimescale()
     });
     if (track) {
@@ -6251,17 +6251,17 @@ var postprocessEbml = async ({
       });
     }
   }
-  if (ebml5.type === "Timestamp") {
-    parserContext.parserState.setTimestampOffset(offset, ebml5.value.value);
+  if (ebml.type === "Timestamp") {
+    parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
   }
-  if (ebml5.type === "Block" || ebml5.type === "SimpleBlock") {
-    const sample = getSampleFromBlock(ebml5, parserContext, offset);
+  if (ebml.type === "Block" || ebml.type === "SimpleBlock") {
+    const sample = getSampleFromBlock(ebml, parserContext, offset);
     if (sample.type === "video-sample" && parserContext.nullifySamples) {
       await parserContext.parserState.onVideoSample(sample.videoSample.trackId, sample.videoSample);
       return {
         type: "Block",
         value: new Uint8Array([]),
-        minVintWidth: ebml5.minVintWidth
+        minVintWidth: ebml.minVintWidth
       };
     }
     if (sample.type === "audio-sample" && parserContext.nullifySamples) {
@@ -6269,23 +6269,23 @@ var postprocessEbml = async ({
       return {
         type: "Block",
         value: new Uint8Array([]),
-        minVintWidth: ebml5.minVintWidth
+        minVintWidth: ebml.minVintWidth
       };
     }
     if (sample.type === "no-sample" && parserContext.nullifySamples) {
       return {
         type: "Block",
         value: new Uint8Array([]),
-        minVintWidth: ebml5.minVintWidth
+        minVintWidth: ebml.minVintWidth
       };
     }
   }
-  if (ebml5.type === "BlockGroup") {
-    const block2 = ebml5.value.find((c) => c.type === "SimpleBlock" || c.type === "Block");
+  if (ebml.type === "BlockGroup") {
+    const block2 = ebml.value.find((c) => c.type === "SimpleBlock" || c.type === "Block");
     if (!block2 || block2.type !== "SimpleBlock" && block2.type !== "Block") {
       throw new Error("Expected block segment");
     }
-    const hasReferenceBlock = ebml5.value.find((c) => c.type === "ReferenceBlock");
+    const hasReferenceBlock = ebml.value.find((c) => c.type === "ReferenceBlock");
     const sample = block2.value.length === 0 ? null : getSampleFromBlock(block2, parserContext, offset);
     if (sample && sample.type === "partial-video-sample") {
       const completeFrame = {
@@ -6298,11 +6298,11 @@ var postprocessEbml = async ({
       return {
         type: "BlockGroup",
         value: [],
-        minVintWidth: ebml5.minVintWidth
+        minVintWidth: ebml.minVintWidth
       };
     }
   }
-  return ebml5;
+  return ebml;
 };
 
 // src/boxes/webm/segments.ts
@@ -6318,8 +6318,8 @@ var parseSegment = async ({
   }
   iterator.counter.decrement(headerReadSoFar);
   const offset = iterator.counter.getOffset();
-  const ebml5 = await parseEbml(iterator, parserContext);
-  const remapped = await postprocessEbml({ offset, ebml: ebml5, parserContext });
+  const ebml = await parseEbml(iterator, parserContext);
+  const remapped = await postprocessEbml({ offset, ebml, parserContext });
   return remapped;
 };
 var expectSegment = async (iterator, parserContext) => {
@@ -6612,15 +6612,15 @@ var makeParserState = ({
   const queuedAudioSamples = {};
   const queuedVideoSamples = {};
   const declinedTrackNumbers = [];
-  let timescale3 = null;
+  let timescale = null;
   const getTimescale = () => {
-    if (timescale3 === null) {
+    if (timescale === null) {
       return 1e6;
     }
-    return timescale3;
+    return timescale;
   };
   const setTimescale = (newTimescale) => {
-    timescale3 = newTimescale;
+    timescale = newTimescale;
   };
   const timestampMap = new Map;
   const setTimestampOffset = (byteOffset, timestamp) => {

package/dist/from-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const fetchReader: ReaderInterface;

package/dist/from-fetch.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = void 0;
+exports.fetchReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin).toString()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('http://')) {
+            return Promise.reject(new Error(resolvedUrl +
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                    },
+            signal,
+            // Disable Next.js caching
+            cache: 'no-store',
+        });
+        if (res.status.toString().startsWith('4') ||
+            res.status.toString().startsWith('5')) {
+            throw new Error(`Server returned status code ${res.status} for ${src}`);
+        }
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        const contentLength = length === null ? null : parseInt(length, 10);
+        const reader = res.body.getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return { reader, contentLength };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/from-node.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const nodeReader: ReaderInterface;

package/dist/from-node.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const stream_1 = require("stream");
+exports.nodeReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
+            signal,
+        });
+        const stats = await (0, promises_1.stat)(src);
+        const reader = stream_1.Readable.toWeb(stream).getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return {
+            reader,
+            contentLength: stats.size,
+        };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stats = await (0, promises_1.stat)(src);
+        return stats.size;
+    },
+};

package/dist/from-web-file.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const webFileReader: ReaderInterface;

package/dist/from-web-file.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = void 0;
+exports.webFileReader = {
+    read: (file, range, signal) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.abort();
+            }, { once: true });
+        }
+        return new Promise((resolve, reject) => {
+            reader.onload = () => {
+                resolve({
+                    reader: part.stream().getReader(),
+                    contentLength: file.size,
+                });
+            };
+            reader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    },
+    getLength: (src) => {
+        if (typeof src === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        return Promise.resolve(src.size);
+    },
+};

package/dist/reader.d.ts

@@ -0,0 +1,11 @@
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
+type GetLength = (src: string | File) => Promise<number>;
+export type ReaderInterface = {
+    read: ReadContent;
+    getLength: GetLength;
+};
+export {};

package/dist/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/traversal.d.ts

@@ -0,0 +1,65 @@
+import type { FtypBox } from './boxes/iso-base-media/ftyp';
+import type { MdhdBox } from './boxes/iso-base-media/mdhd';
+import type { MoovBox } from './boxes/iso-base-media/moov/moov';
+import type { MvhdBox } from './boxes/iso-base-media/mvhd';
+import type { CttsBox } from './boxes/iso-base-media/stsd/ctts';
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
+import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
+import type { StssBox } from './boxes/iso-base-media/stsd/stss';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+import type { TfdtBox } from './boxes/iso-base-media/tfdt';
+import type { TfhdBox } from './boxes/iso-base-media/tfhd';
+import type { TkhdBox } from './boxes/iso-base-media/tkhd';
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { TrunBox } from './boxes/iso-base-media/trun';
+import type { AudioSegment, ClusterSegment, CodecIdSegment, DisplayHeightSegment, DisplayWidthSegment, HeightSegment, MainSegment, TimestampScaleSegment, TrackEntry, TrackTypeSegment, VideoSegment, WidthSegment } from './boxes/webm/segments/all-segments';
+import type { AnySegment, IsoBaseMediaBox, RegularBox } from './parse-result';
+export declare const getFtypBox: (segments: AnySegment[]) => FtypBox | null;
+export declare const getMoovBox: (segments: AnySegment[]) => MoovBox | null;
+export declare const getMoofBox: (main: AnySegment[]) => IsoBaseMediaBox | null;
+export declare const getMvhdBox: (moovBox: MoovBox) => MvhdBox | null;
+export declare const getTraks: (moovBox: MoovBox) => TrakBox[];
+export declare const getTkhdBox: (trakBox: TrakBox) => TkhdBox | null;
+export declare const getMdiaBox: (trakBox: TrakBox) => RegularBox | null;
+export declare const getMdhdBox: (trakBox: TrakBox) => MdhdBox | null;
+export declare const getStblBox: (trakBox: TrakBox) => RegularBox | null;
+export declare const getStsdBox: (trakBox: TrakBox) => StsdBox | null;
+export declare const getVideoDescriptors: (trakBox: TrakBox) => Uint8Array | null;
+export declare const getStcoBox: (trakBox: TrakBox) => StcoBox | null;
+export declare const getSttsBox: (trakBox: TrakBox) => SttsBox | null;
+export declare const getCttsBox: (trakBox: TrakBox) => CttsBox | null;
+export declare const getStszBox: (trakBox: TrakBox) => StszBox | null;
+export declare const getStscBox: (trakBox: TrakBox) => StscBox | null;
+export declare const getStssBox: (trakBox: TrakBox) => StssBox | null;
+export declare const getTfdtBox: (segment: IsoBaseMediaBox) => TfdtBox | null;
+export declare const getTfhdBox: (segment: IsoBaseMediaBox) => TfhdBox | null;
+export declare const getTrunBoxes: (segment: IsoBaseMediaBox) => TrunBox[];
+export declare const getClusterSegment: (segment: MainSegment) => ClusterSegment | null;
+export declare const getTracksSegment: (segment: MainSegment) => {
+    type: "Tracks";
+    value: import("./boxes/webm/segments/all-segments").PossibleEbml[];
+    minVintWidth: number | null;
+} | null;
+export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
+export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;
+export declare const getAudioSegment: (track: TrackEntry) => AudioSegment | null;
+export declare const getSampleRate: (track: TrackEntry) => number | null;
+export declare const getNumberOfChannels: (track: TrackEntry) => number;
+export declare const getBitDepth: (track: TrackEntry) => number | null;
+export declare const getPrivateData: (track: TrackEntry) => Uint8Array | null;
+export declare const getWidthSegment: (track: TrackEntry) => WidthSegment | null;
+export declare const getHeightSegment: (track: TrackEntry) => HeightSegment | null;
+export declare const getDisplayWidthSegment: (track: TrackEntry) => DisplayWidthSegment | null;
+export declare const getDisplayHeightSegment: (track: TrackEntry) => DisplayHeightSegment | null;
+export declare const getTrackTypeSegment: (track: TrackEntry) => TrackTypeSegment | null;
+export declare const getTrackId: (track: TrackEntry) => number;
+export declare const getCodecSegment: (track: TrackEntry) => CodecIdSegment | null;
+export declare const hasSkippedMdatProcessing: (anySegment: AnySegment[]) => {
+    skipped: false;
+    fileOffset?: undefined;
+} | {
+    skipped: boolean;
+    fileOffset: number;
+};

package/dist/traversal.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSkippedMdatProcessing = exports.getCodecSegment = exports.getTrackId = exports.getTrackTypeSegment = exports.getDisplayHeightSegment = exports.getDisplayWidthSegment = exports.getHeightSegment = exports.getWidthSegment = exports.getPrivateData = exports.getBitDepth = exports.getNumberOfChannels = exports.getSampleRate = exports.getAudioSegment = exports.getVideoSegment = exports.getTimescaleSegment = exports.getTracksSegment = exports.getClusterSegment = exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBox = exports.getMoovBox = exports.getFtypBox = void 0;
+const getFtypBox = (segments) => {
+    const ftypBox = segments.find((s) => s.type === 'ftyp-box');
+    if (!ftypBox || ftypBox.type !== 'ftyp-box') {
+        return null;
+    }
+    return ftypBox;
+};
+exports.getFtypBox = getFtypBox;
+const getMoovBox = (segments) => {
+    const moovBox = segments.find((s) => s.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        return null;
+    }
+    return moovBox;
+};
+exports.getMoovBox = getMoovBox;
+const getMoofBox = (main) => {
+    const moofBox = main.find((s) => s.type === 'regular-box' && s.boxType === 'moof');
+    if (!moofBox || moofBox.type !== 'regular-box') {
+        return null;
+    }
+    return moofBox;
+};
+exports.getMoofBox = getMoofBox;
+const getMvhdBox = (moovBox) => {
+    const mvHdBox = moovBox.children.find((s) => s.type === 'mvhd-box');
+    if (!mvHdBox || mvHdBox.type !== 'mvhd-box') {
+        return null;
+    }
+    return mvHdBox;
+};
+exports.getMvhdBox = getMvhdBox;
+const getTraks = (moovBox) => {
+    return moovBox.children.filter((s) => s.type === 'trak-box');
+};
+exports.getTraks = getTraks;
+const getTkhdBox = (trakBox) => {
+    const tkhdBox = trakBox.children.find((s) => s.type === 'tkhd-box');
+    return tkhdBox;
+};
+exports.getTkhdBox = getTkhdBox;
+const getMdiaBox = (trakBox) => {
+    const mdiaBox = trakBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'mdia');
+    if (!mdiaBox || mdiaBox.type !== 'regular-box') {
+        return null;
+    }
+    return mdiaBox;
+};
+exports.getMdiaBox = getMdiaBox;
+const getMdhdBox = (trakBox) => {
+    const mdiaBox = (0, exports.getMdiaBox)(trakBox);
+    if (!mdiaBox) {
+        return null;
+    }
+    const mdhdBox = mdiaBox.children.find((c) => c.type === 'mdhd-box');
+    return mdhdBox;
+};
+exports.getMdhdBox = getMdhdBox;
+const getStblBox = (trakBox) => {
+    const mdiaBox = (0, exports.getMdiaBox)(trakBox);
+    if (!mdiaBox) {
+        return null;
+    }
+    const minfBox = mdiaBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'minf');
+    if (!minfBox || minfBox.type !== 'regular-box') {
+        return null;
+    }
+    const stblBox = minfBox.children.find((s) => s.type === 'regular-box' && s.boxType === 'stbl');
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    return stblBox;
+};
+exports.getStblBox = getStblBox;
+const getStsdBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stsdBox = stblBox.children.find((s) => s.type === 'stsd-box');
+    return stsdBox;
+};
+exports.getStsdBox = getStsdBox;
+const getVideoDescriptors = (trakBox) => {
+    var _a;
+    const stsdBox = (0, exports.getStsdBox)(trakBox);
+    if (!stsdBox) {
+        return null;
+    }
+    const descriptors = stsdBox.samples.map((s) => {
+        return s.type === 'video'
+            ? s.descriptors.map((d) => {
+                return d.type === 'avcc-box'
+                    ? d.description
+                    : d.type === 'hvcc-box'
+                        ? d.data
+                        : null;
+            })
+            : [];
+    });
+    return (_a = descriptors.flat(1).filter(Boolean)[0]) !== null && _a !== void 0 ? _a : null;
+};
+exports.getVideoDescriptors = getVideoDescriptors;
+const getStcoBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stcoBox = stblBox.children.find((s) => s.type === 'stco-box');
+    return stcoBox;
+};
+exports.getStcoBox = getStcoBox;
+const getSttsBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const sttsBox = stblBox.children.find((s) => s.type === 'stts-box');
+    return sttsBox;
+};
+exports.getSttsBox = getSttsBox;
+const getCttsBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const cttsBox = stblBox.children.find((s) => s.type === 'ctts-box');
+    return cttsBox;
+};
+exports.getCttsBox = getCttsBox;
+const getStszBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stszBox = stblBox.children.find((s) => s.type === 'stsz-box');
+    return stszBox;
+};
+exports.getStszBox = getStszBox;
+const getStscBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stcoBox = stblBox.children.find((b) => b.type === 'stsc-box');
+    return stcoBox;
+};
+exports.getStscBox = getStscBox;
+const getStssBox = (trakBox) => {
+    const stblBox = (0, exports.getStblBox)(trakBox);
+    if (!stblBox || stblBox.type !== 'regular-box') {
+        return null;
+    }
+    const stssBox = stblBox.children.find((b) => b.type === 'stss-box');
+    return stssBox;
+};
+exports.getStssBox = getStssBox;
+const getTfdtBox = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const tfhdBox = segment.children.find((c) => c.type === 'tfdt-box');
+    if (!tfhdBox || tfhdBox.type !== 'tfdt-box') {
+        throw new Error('Expected tfhd-box');
+    }
+    return tfhdBox;
+};
+exports.getTfdtBox = getTfdtBox;
+const getTfhdBox = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const tfhdBox = segment.children.find((c) => c.type === 'tfhd-box');
+    if (!tfhdBox || tfhdBox.type !== 'tfhd-box') {
+        throw new Error('Expected tfhd-box');
+    }
+    return tfhdBox;
+};
+exports.getTfhdBox = getTfhdBox;
+const getTrunBoxes = (segment) => {
+    if (segment.type !== 'regular-box' || segment.boxType !== 'traf') {
+        throw new Error('Expected traf-box');
+    }
+    const trunBoxes = segment.children.filter((c) => c.type === 'trun-box');
+    return trunBoxes;
+};
+exports.getTrunBoxes = getTrunBoxes;
+const getClusterSegment = (segment) => {
+    const clusterSegment = segment.value.find((b) => b.type === 'Cluster');
+    return clusterSegment !== null && clusterSegment !== void 0 ? clusterSegment : null;
+};
+exports.getClusterSegment = getClusterSegment;
+const getTracksSegment = (segment) => {
+    const tracksSegment = segment.value.find((b) => b.type === 'Tracks');
+    if (!tracksSegment || tracksSegment.type !== 'Tracks') {
+        return null;
+    }
+    return tracksSegment;
+};
+exports.getTracksSegment = getTracksSegment;
+const getTimescaleSegment = (segment) => {
+    const infoSegment = segment.value.find((b) => b.type === 'Info');
+    if (!infoSegment || infoSegment.type !== 'Info') {
+        return null;
+    }
+    const timescale = infoSegment.value.find((b) => b.type === 'TimestampScale');
+    if (!timescale || timescale.type !== 'TimestampScale') {
+        return null;
+    }
+    return timescale;
+};
+exports.getTimescaleSegment = getTimescaleSegment;
+const getVideoSegment = (track) => {
+    const videoSegment = track.value.find((b) => b.type === 'Video');
+    if (!videoSegment || videoSegment.type !== 'Video') {
+        return null;
+    }
+    return videoSegment !== null && videoSegment !== void 0 ? videoSegment : null;
+};
+exports.getVideoSegment = getVideoSegment;
+const getAudioSegment = (track) => {
+    const audioSegment = track.value.find((b) => b.type === 'Audio');
+    if (!audioSegment || audioSegment.type !== 'Audio') {
+        return null;
+    }
+    return audioSegment !== null && audioSegment !== void 0 ? audioSegment : null;
+};
+exports.getAudioSegment = getAudioSegment;
+const getSampleRate = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const samplingFrequency = audioSegment.value.find((b) => b.type === 'SamplingFrequency');
+    if (!samplingFrequency || samplingFrequency.type !== 'SamplingFrequency') {
+        return null;
+    }
+    return samplingFrequency.value.value;
+};
+exports.getSampleRate = getSampleRate;
+const getNumberOfChannels = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        throw new Error('Could not find audio segment');
+    }
+    const channels = audioSegment.value.find((b) => b.type === 'Channels');
+    if (!channels || channels.type !== 'Channels') {
+        return 1;
+    }
+    return channels.value.value;
+};
+exports.getNumberOfChannels = getNumberOfChannels;
+const getBitDepth = (track) => {
+    const audioSegment = (0, exports.getAudioSegment)(track);
+    if (!audioSegment) {
+        return null;
+    }
+    const bitDepth = audioSegment.value.find((b) => b.type === 'BitDepth');
+    if (!bitDepth || bitDepth.type !== 'BitDepth') {
+        return null;
+    }
+    return bitDepth.value.value;
+};
+exports.getBitDepth = getBitDepth;
+const getPrivateData = (track) => {
+    const privateData = track.value.find((b) => b.type === 'CodecPrivate');
+    if (!privateData || privateData.type !== 'CodecPrivate') {
+        return null;
+    }
+    return privateData.value;
+};
+exports.getPrivateData = getPrivateData;
+const getWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const width = videoSegment.value.find((b) => b.type === 'PixelWidth');
+    if (!width || width.type !== 'PixelWidth') {
+        return null;
+    }
+    return width;
+};
+exports.getWidthSegment = getWidthSegment;
+const getHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const height = videoSegment.value.find((b) => b.type === 'PixelHeight');
+    if (!height || height.type !== 'PixelHeight') {
+        return null;
+    }
+    return height;
+};
+exports.getHeightSegment = getHeightSegment;
+const getDisplayWidthSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayWidth = videoSegment.value.find((b) => b.type === 'DisplayWidth');
+    if (!displayWidth || displayWidth.type !== 'DisplayWidth') {
+        return null;
+    }
+    return displayWidth;
+};
+exports.getDisplayWidthSegment = getDisplayWidthSegment;
+const getDisplayHeightSegment = (track) => {
+    const videoSegment = (0, exports.getVideoSegment)(track);
+    if (!videoSegment) {
+        return null;
+    }
+    const displayHeight = videoSegment.value.find((b) => b.type === 'DisplayHeight');
+    if (!displayHeight || displayHeight.type !== 'DisplayHeight') {
+        return null;
+    }
+    return displayHeight;
+};
+exports.getDisplayHeightSegment = getDisplayHeightSegment;
+const getTrackTypeSegment = (track) => {
+    const trackType = track.value.find((b) => b.type === 'TrackType');
+    if (!trackType || trackType.type !== 'TrackType') {
+        return null;
+    }
+    return trackType;
+};
+exports.getTrackTypeSegment = getTrackTypeSegment;
+const getTrackId = (track) => {
+    const trackId = track.value.find((b) => b.type === 'TrackNumber');
+    if (!trackId || trackId.type !== 'TrackNumber') {
+        throw new Error('Expected track number segment');
+    }
+    return trackId.value.value;
+};
+exports.getTrackId = getTrackId;
+const getCodecSegment = (track) => {
+    const codec = track.value.find((b) => b.type === 'CodecID');
+    if (!codec || codec.type !== 'CodecID') {
+        return null;
+    }
+    return codec;
+};
+exports.getCodecSegment = getCodecSegment;
+const hasSkippedMdatProcessing = (anySegment) => {
+    const mdat = anySegment.find((b) => b.type === 'mdat-box');
+    if (!mdat) {
+        return {
+            skipped: false,
+        };
+    }
+    if (mdat.type !== 'mdat-box') {
+        throw new Error('Expected mdat-box');
+    }
+    if (mdat.samplesProcessed) {
+        return {
+            skipped: false,
+        };
+    }
+    return {
+        skipped: true,
+        fileOffset: mdat.fileOffset,
+    };
+};
+exports.hasSkippedMdatProcessing = hasSkippedMdatProcessing;

package/package.json

@@ -3,12 +3,12 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.214",
+  "version": "4.0.216",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
-    "@remotion/renderer": "4.0.214"
+    "@remotion/renderer": "4.0.216"
   },
   "publishConfig": {
     "access": "public"