@remotion/media-parser 4.0.248 → 4.0.250

package/dist/options.d.ts

@@ -5,6 +5,7 @@ import type { LogLevel } from './log';
 import type { MetadataEntry } from './metadata/get-metadata';
 import type { Structure } from './parse-result';
 import type { ReaderInterface } from './readers/reader';
+import type { MediaParserEmbeddedImage } from './state/images';
 import type { InternalStats } from './state/parser-state';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
@@ -31,6 +32,7 @@ export type ParseMediaFields = {
     keyframes: boolean;
     slowKeyframes: boolean;
     slowNumberOfFrames: boolean;
+    images: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
@@ -55,6 +57,7 @@ export type AllParseMediaFields = {
     mimeType: true;
     keyframes: true;
     slowKeyframes: true;
+    images: true;
 };
 export type AllOptions<Fields extends ParseMediaFields> = {
     dimensions: Fields['dimensions'];
@@ -79,13 +82,14 @@ export type AllOptions<Fields extends ParseMediaFields> = {
     keyframes: Fields['keyframes'];
     slowKeyframes: Fields['slowKeyframes'];
     slowNumberOfFrames: Fields['slowNumberOfFrames'];
+    images: Fields['images'];
 };
 export type Options<Fields extends ParseMediaFields> = Partial<AllOptions<Fields>>;
 export type TracksField = {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
 };
-export type ParseMediaContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream';
+export type ParseMediaContainer = 'mp4' | 'webm' | 'avi' | 'transport-stream' | 'mp3';
 export type MediaParserKeyframe = {
     positionInBytes: number;
     sizeInBytes: number;
@@ -94,7 +98,7 @@ export type MediaParserKeyframe = {
     trackId: number;
 };
 export interface ParseMediaCallbacks {
-    onDimensions?: (dimensions: Dimensions) => void;
+    onDimensions?: (dimensions: Dimensions | null) => void;
     onDurationInSeconds?: (durationInSeconds: number | null) => void;
     onSlowDurationInSeconds?: (durationInSeconds: number) => void;
     onSlowFps?: (fps: number) => void;
@@ -104,7 +108,7 @@ export interface ParseMediaCallbacks {
     onAudioCodec?: (codec: MediaParserAudioCodec | null) => void;
     onTracks?: (tracks: TracksField) => void;
     onRotation?: (rotation: number | null) => void;
-    onUnrotatedDimensions?: (dimensions: Dimensions) => void;
+    onUnrotatedDimensions?: (dimensions: Dimensions | null) => void;
     onInternalStats?: (internalStats: InternalStats) => void;
     onSize?: (size: number | null) => void;
     onName?: (name: string) => void;
@@ -116,9 +120,10 @@ export interface ParseMediaCallbacks {
     onKeyframes?: (keyframes: MediaParserKeyframe[] | null) => void;
     onSlowKeyframes?: (keyframes: MediaParserKeyframe[]) => void;
     onSlowNumberOfFrames?: (samples: number) => void;
+    onImages?: (images: MediaParserEmbeddedImage[]) => void;
 }
 export interface ParseMediaData {
-    dimensions: Dimensions;
+    dimensions: Dimensions | null;
     durationInSeconds: number | null;
     slowDurationInSeconds: number;
     slowFps: number;
@@ -128,7 +133,7 @@ export interface ParseMediaData {
     audioCodec: MediaParserAudioCodec | null;
     tracks: TracksField;
     rotation: number | null;
-    unrotatedDimensions: Dimensions;
+    unrotatedDimensions: Dimensions | null;
     isHdr: boolean;
     internalStats: InternalStats;
     size: number | null;
@@ -140,6 +145,7 @@ export interface ParseMediaData {
     keyframes: MediaParserKeyframe[] | null;
     slowKeyframes: MediaParserKeyframe[];
     slowNumberOfFrames: number;
+    images: MediaParserEmbeddedImage[];
 }
 export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {
     [K in keyof T]: T[K] extends true ? K extends keyof ParseMediaData ? ParseMediaData[K] : never : never;
@@ -161,5 +167,6 @@ export type ParseMediaOptions<F extends Options<ParseMediaFields>> = {
     signal?: AbortSignal;
     logLevel?: LogLevel;
     onParseProgress?: ParseMediaOnProgress;
+    progressIntervalInMs?: number;
 } & ParseMediaDynamicOptions<F>;
 export type ParseMedia = <F extends Options<ParseMediaFields>>(options: ParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;

package/dist/parse-media.js

@@ -9,8 +9,9 @@ const log_1 = require("./log");
 const parse_video_1 = require("./parse-video");
 const from_fetch_1 = require("./readers/from-fetch");
 const parser_state_1 = require("./state/parser-state");
-const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) {
-    let iterator = null;
+const throttled_progress_1 = require("./throttled-progress");
+const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, ...more }) {
+    var _a;
     let parseResult = null;
     const fieldsInReturnValue = _fieldsInReturnValue !== null && _fieldsInReturnValue !== void 0 ? _fieldsInReturnValue : {};
     const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
@@ -18,6 +19,10 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         callbacks: more,
     });
     const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
+    if (contentLength === null) {
+        throw new Error('Media was passed with no content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.');
+    }
     const supportsContentRange = readerSupportsContentRange &&
         !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
@@ -31,10 +36,18 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         supportsContentRange,
+        contentLength,
+        logLevel,
     });
     let currentReader = reader;
     const returnValue = {};
     const moreFields = more;
+    const throttledState = (0, throttled_progress_1.throttledStateUpdate)({
+        updateFn: onParseProgressDoNotCallDirectly !== null && onParseProgressDoNotCallDirectly !== void 0 ? onParseProgressDoNotCallDirectly : null,
+        everyMilliseconds: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : 100,
+        signal,
+        totalBytes: contentLength,
+    });
     const triggerInfoEmit = () => {
         const availableInfo = (0, has_all_info_1.getAvailableInfo)({
             fieldsToFetch: fields,
@@ -52,35 +65,44 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             mimeType: contentType,
         });
     };
-    triggerInfoEmit();
-    while (parseResult === null || parseResult.status === 'incomplete') {
-        while (true) {
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                throw new Error('Aborted');
+    const checkIfDone = () => {
+        if ((0, has_all_info_1.hasAllInfo)({
+            fields,
+            state,
+        })) {
+            log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
+            if (contentLength !== null) {
+                state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
             }
+            return true;
+        }
+        if (iterator.counter.getOffset() === contentLength) {
+            log_1.Log.verbose(logLevel, 'Reached end of file');
+            return true;
+        }
+        return false;
+    };
+    triggerInfoEmit();
+    let iterationWithThisOffset = 0;
+    while (!checkIfDone()) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('Aborted');
+        }
+        const offsetBefore = iterator.counter.getOffset();
+        const fetchMoreData = async () => {
             const result = await currentReader.reader.read();
-            if (iterator) {
-                if (!result.done) {
-                    iterator.addData(result.value);
-                }
-            }
-            else {
-                if (result.done) {
-                    throw new Error('Unexpectedly reached EOF');
-                }
-                iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
-            }
-            if (iterator.bytesRemaining() >= 0) {
-                break;
-            }
-            if (result.done) {
-                break;
+            if (result.value) {
+                iterator.addData(result.value);
             }
+        };
+        while (iterator.bytesRemaining() < 0) {
+            await fetchMoreData();
         }
-        if (!iterator) {
-            throw new Error('Unexpected null');
+        const hasBigBuffer = iterator.bytesRemaining() > 100000;
+        if (iterationWithThisOffset > 0 || !hasBigBuffer) {
+            await fetchMoreData();
         }
-        await (onParseProgress === null || onParseProgress === void 0 ? void 0 : onParseProgress({
+        (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, () => ({
             bytes: iterator.counter.getOffset(),
             percentage: contentLength
                 ? iterator.counter.getOffset() / contentLength
@@ -88,60 +110,58 @@ const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader:
             totalBytes: contentLength,
         }));
         triggerInfoEmit();
-        if (parseResult && parseResult.status === 'incomplete') {
-            log_1.Log.trace(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
-            parseResult = await parseResult.continueParsing();
-        }
-        else {
-            parseResult = await (0, parse_video_1.parseVideo)({
-                iterator,
-                state,
-                signal: signal !== null && signal !== void 0 ? signal : null,
-                logLevel,
-                fields,
-                mimeType: contentType,
-                contentLength,
-                name,
-            });
+        if (iterationWithThisOffset > 300) {
+            throw new Error('Infinite loop detected. The parser is not progressing. This is likely a bug in the parser.');
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
-            state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
-        }
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
+        log_1.Log.trace(logLevel, `Continuing parsing of file, currently at position ${iterator.counter.getOffset()}/${contentLength}`);
+        parseResult = await (0, parse_video_1.parseVideo)({
+            iterator,
             state,
-        })) {
-            log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
-            if (contentLength !== null) {
-                state.increaseSkippedBytes(contentLength - iterator.counter.getOffset());
-            }
-            break;
+            mimeType: contentType,
+            contentLength,
+            name,
+        });
+        if (parseResult.skipTo !== null) {
+            state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
         }
-        if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
-            if (!supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
+        if (parseResult.skipTo !== null) {
             if (parseResult.skipTo === contentLength) {
                 log_1.Log.verbose(logLevel, 'Skipped to end of file, not fetching.');
                 break;
             }
-            log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}`);
-            currentReader.abort();
-            const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
-            currentReader = newReader;
-            iterator.skipTo(parseResult.skipTo, true);
+            const skippingAhead = parseResult.skipTo > iterator.counter.getOffset();
+            if (!skippingAhead && !supportsContentRange) {
+                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
+            }
+            if (skippingAhead &&
+                iterator.counter.getOffset() + iterator.bytesRemaining() >=
+                    parseResult.skipTo) {
+                log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}. Data already fetched`);
+                iterator.discard(parseResult.skipTo - iterator.counter.getOffset());
+            }
+            else {
+                log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${parseResult.skipTo}. Re-reading because this portion is not available`);
+                currentReader.abort();
+                const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
+                currentReader = newReader;
+                iterator.skipTo(parseResult.skipTo, true);
+            }
         }
+        const didProgress = iterator.counter.getOffset() > offsetBefore;
+        if (!didProgress) {
+            iterationWithThisOffset++;
+        }
+        iterator.removeBytesRead();
     }
     log_1.Log.verbose(logLevel, 'Finished parsing file');
-    const hasInfo = Object.keys(fields).reduce((acc, key) => {
-        if (fields === null || fields === void 0 ? void 0 : fields[key]) {
-            acc[key] = true;
-        }
-        return acc;
-    }, {});
     // Force assign
     (0, emit_available_info_1.emitAvailableInfo)({
-        hasInfo,
+        hasInfo: Object.keys(fields).reduce((acc, key) => {
+            if (fields === null || fields === void 0 ? void 0 : fields[key]) {
+                acc[key] = true;
+            }
+            return acc;
+        }, {}),
         callbacks: moreFields,
         fieldsInReturnValue,
         parseResult,

package/dist/parse-result.d.ts

@@ -1,7 +1,6 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
 import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
-import type { MdatBox } from './boxes/iso-base-media/mdat/mdat';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { HdlrBox } from './boxes/iso-base-media/meta/hdlr';
 import type { IlstBox } from './boxes/iso-base-media/meta/ilst';
@@ -30,6 +29,7 @@ import type { VoidBox } from './boxes/iso-base-media/void-box';
 import type { RiffBox } from './boxes/riff/riff-box';
 import type { TransportStreamBox } from './boxes/transport-stream/boxes';
 import type { MatroskaSegment } from './boxes/webm/segments';
+import type { MetadataEntry } from './metadata/get-metadata';
 export interface RegularBox extends BaseBox {
     boxType: string;
     boxSize: number;
@@ -37,7 +37,16 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | IlstBox | EsdsBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | HdlrBox | ColorParameterBox | TfdtBox | TfhdBox;
+type Mp3Id3Header = {
+    type: 'id3-header';
+    versionMajor: number;
+    versionMinor: number;
+    flags: number;
+    size: number;
+    metatags: MetadataEntry[];
+};
+export type Mp3Box = Mp3Id3Header;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox | RiffBox | TransportStreamBox;
 export type IsoBaseMediaStructure = {
     type: 'iso-base-media';
@@ -55,26 +64,15 @@ export type TransportStreamStructure = {
     type: 'transport-stream';
     boxes: TransportStreamBox[];
 };
-export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure;
+export type Mp3Structure = {
+    type: 'mp3';
+    boxes: Mp3Box[];
+};
+export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure | Mp3Structure;
 export type ParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
 };
 export type MatroskaParseResult = {
-    status: 'done';
-} | {
-    status: 'incomplete';
     skipTo: number | null;
-    continueParsing: () => Promise<MatroskaParseResult>;
-};
-export type ExpectSegmentParseResult = {
-    status: 'done';
-    segment: MatroskaSegment;
-} | {
-    status: 'incomplete';
-    segment: MatroskaSegment | null;
-    continueParsing: () => Promise<ExpectSegmentParseResult>;
 };
+export {};

package/dist/parse-video.d.ts

@@ -1,27 +1,13 @@
 import type { BufferIterator } from './buffer-iterator';
-import { type LogLevel } from './log';
-import type { Options, ParseMediaFields } from './options';
 import type { IsoBaseMediaBox, ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export type PartialMdatBox = {
-    type: 'partial-mdat-box';
-    boxSize: number;
-    fileOffset: number;
-};
 export type BoxAndNext = {
-    type: 'complete';
-    box: IsoBaseMediaBox;
-    size: number;
+    box: IsoBaseMediaBox | null;
     skipTo: number | null;
-} | {
-    type: 'incomplete';
-} | PartialMdatBox;
-export declare const parseVideo: ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }: {
+};
+export declare const parseVideo: ({ iterator, state, mimeType, contentLength, name, }: {
     iterator: BufferIterator;
     state: ParserState;
-    signal: AbortSignal | null;
-    logLevel: LogLevel;
-    fields: Options<ParseMediaFields>;
     mimeType: string | null;
     contentLength: number | null;
     name: string | null;

package/dist/parse-video.js

@@ -1,75 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
-const process_box_1 = require("./boxes/iso-base-media/process-box");
-const parse_box_1 = require("./boxes/riff/parse-box");
-const next_pes_header_store_1 = require("./boxes/transport-stream/next-pes-header-store");
+const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
+const parse_mp3_1 = require("./boxes/mp3/parse-mp3");
+const parse_riff_1 = require("./boxes/riff/parse-riff");
 const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transport-stream");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
 const errors_1 = require("./errors");
 const log_1 = require("./log");
-const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }) => {
-    if (iterator.bytesRemaining() === 0) {
-        return Promise.reject(new Error('no bytes'));
-    }
+const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     const fileType = iterator.detectFileType();
     if (fileType.type === 'riff') {
-        log_1.Log.verbose(logLevel, 'Detected RIFF container');
+        log_1.Log.verbose(state.logLevel, 'Detected RIFF container');
         state.structure.setStructure({
             type: 'riff',
             boxes: [],
         });
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, state, fields }));
+        return;
     }
     if (fileType.type === 'iso-base-media') {
-        log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
-        const initialBoxes = [];
+        log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
         state.structure.setStructure({
             type: 'iso-base-media',
-            boxes: initialBoxes,
-        });
-        return (0, process_box_1.parseIsoBaseMediaBoxes)({
-            iterator,
-            maxBytes: Infinity,
-            allowIncompleteBoxes: true,
-            initialBoxes,
-            state,
-            continueMdat: false,
-            signal,
-            logLevel,
-            fields,
+            boxes: [],
         });
+        return;
     }
     if (fileType.type === 'webm') {
-        log_1.Log.verbose(logLevel, 'Detected Matroska container');
+        log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
         state.structure.setStructure({
             boxes: [],
             type: 'matroska',
         });
-        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, state, fields });
+        return;
     }
     if (fileType.type === 'transport-stream') {
-        log_1.Log.verbose(logLevel, 'Detected MPEG-2 Transport Stream');
+        log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
         state.structure.setStructure({
             boxes: [],
             type: 'transport-stream',
         });
-        return (0, parse_transport_stream_1.parseTransportStream)({
-            iterator,
-            state,
-            streamBuffers: new Map(),
-            fields,
-            nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
-        });
+        return;
     }
     if (fileType.type === 'mp3') {
-        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
-            message: 'MP3 files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-            audioType: 'mp3',
-        }));
+        log_1.Log.verbose(state.logLevel, 'Detected MP3');
+        const structure = {
+            boxes: [],
+            type: 'mp3',
+        };
+        state.structure.setStructure(structure);
+        return;
     }
     if (fileType.type === 'wav') {
         return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
@@ -128,4 +108,36 @@ const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, conte
     }
     return Promise.reject(new Error('Unknown video format ' + fileType));
 };
+const parseVideo = async ({ iterator, state, mimeType, contentLength, name, }) => {
+    if (iterator.bytesRemaining() === 0) {
+        return Promise.reject(new Error('no bytes'));
+    }
+    const structure = state.structure.getStructureOrNull();
+    if (structure === null) {
+        await initVideo({ iterator, state, mimeType, name, contentLength });
+        return { skipTo: null };
+    }
+    if (structure.type === 'riff') {
+        return (0, parse_riff_1.parseRiff)({ iterator, state });
+    }
+    if (structure.type === 'mp3') {
+        return (0, parse_mp3_1.parseMp3)({ iterator, state });
+    }
+    if (structure.type === 'iso-base-media') {
+        return (0, parse_boxes_1.parseIsoBaseMedia)({
+            iterator,
+            state,
+        });
+    }
+    if (structure.type === 'matroska') {
+        return (0, parse_webm_header_1.parseWebm)({ iterator, state });
+    }
+    if (structure.type === 'transport-stream') {
+        return (0, parse_transport_stream_1.parseTransportStream)({
+            iterator,
+            state,
+        });
+    }
+    return Promise.reject(new Error('Unknown video format ' + structure));
+};
 exports.parseVideo = parseVideo;

package/dist/readers/from-node.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = void 0;
 const fs_1 = require("fs");
-const promises_1 = require("node:fs/promises");
 const path_1 = require("path");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: async (src, range, signal) => {
+    read: (src, range, signal) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
@@ -23,14 +22,14 @@ exports.nodeReader = {
         signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
             controller.abort();
         }, { once: true });
-        const stats = await (0, promises_1.stat)(src);
+        const stats = (0, fs_1.statSync)(src);
         const reader = stream_1.Readable.toWeb(stream).getReader();
         if (signal) {
             signal.addEventListener('abort', () => {
                 reader.cancel().catch(() => { });
             }, { once: true });
         }
-        return {
+        return Promise.resolve({
             reader: {
                 reader,
                 abort: () => {
@@ -41,13 +40,13 @@ exports.nodeReader = {
             contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
-        };
+        });
     },
-    getLength: async (src) => {
+    getLength: (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;
+        const stats = (0, fs_1.statSync)(src);
+        return Promise.resolve(stats.size);
     },
 };

package/dist/state/can-skip-tracks.d.ts

@@ -1,8 +1,15 @@
 import type { Options, ParseMediaFields } from '../options';
-export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }: {
+import type { Structure } from '../parse-result';
+import type { StructureState } from './structure';
+export declare const needsTracksForField: ({ field, structure, }: {
+    field: keyof Options<ParseMediaFields>;
+    structure: Structure;
+}) => boolean;
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     fields: Options<ParseMediaFields>;
+    structure: StructureState;
 }) => {
     canSkipTracks: () => boolean;
 };