@remotion/media-parser 4.0.208 → 4.0.210

package/dist/has-all-info.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasAllInfo = void 0;
+exports.getAvailableInfo = void 0;
 const get_audio_codec_1 = require("./get-audio-codec");
+const get_container_1 = require("./get-container");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const hasAllInfo = (options, parseResult, state) => {
-    const keys = Object.entries(options)
-        .filter(([, value]) => value)
-        .map(([key]) => key);
-    return keys.every((key) => {
+const getAvailableInfo = (options, parseResult, state) => {
+    const keys = Object.entries(options).filter(([, value]) => value);
+    const infos = keys.map(([key]) => {
         if (key === 'boxes') {
             return parseResult.status === 'done';
         }
@@ -24,13 +23,13 @@ const hasAllInfo = (options, parseResult, state) => {
             return (0, get_dimensions_1.hasDimensions)(parseResult.segments, state);
         }
         if (key === 'fps') {
-            return (0, get_fps_1.hasFps)(parseResult.segments) !== null;
+            return (0, get_fps_1.hasFps)(parseResult.segments);
         }
         if (key === 'videoCodec') {
             return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments);
         }
         if (key === 'audioCodec') {
-            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments);
+            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments, state);
         }
         if (key === 'tracks') {
             return (0, get_tracks_1.hasTracks)(parseResult.segments);
@@ -38,7 +37,22 @@ const hasAllInfo = (options, parseResult, state) => {
         if (key === 'internalStats') {
             return false;
         }
+        if (key === 'size') {
+            return true;
+        }
+        if (key === 'name') {
+            return true;
+        }
+        if (key === 'container') {
+            return (0, get_container_1.hasContainer)(parseResult.segments);
+        }
         throw new Error(`Unknown key: ${key}`);
     });
+    const entries = [];
+    let i = 0;
+    for (const [key] of keys) {
+        entries.push([key, infos[i++]]);
+    }
+    return Object.fromEntries(entries);
 };
-exports.hasAllInfo = hasAllInfo;
+exports.getAvailableInfo = getAvailableInfo;

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export { AudioTrack, OtherTrack, Track, VideoTrack } from './get-tracks';
+export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
+export type { Options, ParseMediaContainer, ParseMediaFields, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
 export { AudioSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, VideoSample, } from './webcodec-sample-types';
 export type { MediaFn } from './create/create-media';
+export { Dimensions } from './get-dimensions';
 export declare const MediaParserInternals: {
     createMedia: (writer: import("./writers/writer").WriterInterface) => Promise<import("./create/create-media").MediaFn>;
 };

package/dist/options.d.ts

@@ -1,50 +1,117 @@
 import type { Dimensions } from './get-dimensions';
-import type { AudioTrack, VideoTrack } from './get-tracks';
+import type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, VideoTrack } from './get-tracks';
 import type { AnySegment } from './parse-result';
 import type { InternalStats } from './parser-state';
 import type { ReaderInterface } from './readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
-export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
-export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean> = {
-    dimensions?: EnableDimensions;
-    durationInSeconds?: EnableDuration;
-    boxes?: EnableBoxes;
-    fps?: EnableFps;
-    videoCodec?: EnableVideoCodec;
-    audioCodec?: EnableAudioCodec;
-    tracks?: EnableTracks;
-    rotation?: EnableRotation;
-    unrotatedDimensions?: EnableUnrotatedDimensions;
-    internalStats?: EnableInternalStats;
+export type ParseMediaFields = {
+    dimensions: boolean;
+    durationInSeconds: boolean;
+    boxes: boolean;
+    fps: boolean;
+    videoCodec: boolean;
+    audioCodec: boolean;
+    tracks: boolean;
+    rotation: boolean;
+    unrotatedDimensions: boolean;
+    internalStats: boolean;
+    size: boolean;
+    name: boolean;
+    container: boolean;
 };
-export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean> = (EnableDimensions extends true ? {
+export type AllParseMediaFields = {
+    dimensions: true;
+    durationInSeconds: true;
+    boxes: true;
+    fps: true;
+    videoCodec: true;
+    audioCodec: true;
+    tracks: true;
+    rotation: true;
+    unrotatedDimensions: true;
+    internalStats: true;
+    size: true;
+    name: true;
+    container: true;
+};
+export type Options<Fields extends ParseMediaFields> = {
+    dimensions?: Fields['dimensions'];
+    durationInSeconds?: Fields['durationInSeconds'];
+    boxes?: Fields['boxes'];
+    fps?: Fields['fps'];
+    videoCodec?: Fields['videoCodec'];
+    audioCodec?: Fields['audioCodec'];
+    tracks?: Fields['tracks'];
+    rotation?: Fields['rotation'];
+    unrotatedDimensions?: Fields['unrotatedDimensions'];
+    internalStats?: Fields['internalStats'];
+    size?: Fields['size'];
+    name?: Fields['name'];
+    container?: Fields['container'];
+};
+export type TracksField = {
+    videoTracks: VideoTrack[];
+    audioTracks: AudioTrack[];
+};
+export type ParseMediaContainer = 'mp4' | 'webm';
+export type ParseMediaCallbacks<Fields extends Options<ParseMediaFields>> = (Fields['dimensions'] extends true ? {
+    onDimensions?: (dimensions: Dimensions) => void;
+} : {}) & (Fields['durationInSeconds'] extends true ? {
+    onDurationInSeconds?: (durationInSeconds: number | null) => void;
+} : {}) & (Fields['boxes'] extends true ? {
+    onBoxes?: (boxes: AnySegment[]) => void;
+} : {}) & (Fields['fps'] extends true ? {
+    onFps?: (fps: number | null) => void;
+} : {}) & (Fields['videoCodec'] extends true ? {
+    onVideoCodec?: (codec: MediaParserVideoCodec | null) => void;
+} : {}) & (Fields['audioCodec'] extends true ? {
+    onAudioCodec?: (codec: MediaParserAudioCodec | null) => void;
+} : {}) & (Fields['tracks'] extends true ? {
+    onTracks?: (tracks: TracksField) => void;
+} : {}) & (Fields['rotation'] extends true ? {
+    onRotation?: (rotation: number | null) => void;
+} : {}) & (Fields['unrotatedDimensions'] extends true ? {
+    onUnrotatedDimensions?: (dimensions: Dimensions) => void;
+} : {}) & (Fields['internalStats'] extends true ? {
+    onInternalStats?: (stats: InternalStats) => void;
+} : {}) & (Fields['size'] extends true ? {
+    onSize?: (size: number | null) => void;
+} : {}) & (Fields['name'] extends true ? {
+    onName?: (name: string) => void;
+} : {}) & (Fields['container'] extends true ? {
+    onContainer?: (container: ParseMediaContainer | null) => void;
+} : {});
+export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields['dimensions'] extends true ? {
     dimensions: Dimensions;
-} : {}) & (EnableDuration extends true ? {
+} : {}) & (Fields['durationInSeconds'] extends true ? {
     durationInSeconds: number | null;
-} : {}) & (EnableBoxes extends true ? {
+} : {}) & (Fields['boxes'] extends true ? {
     boxes: AnySegment[];
-} : {}) & (EnableFps extends true ? {
+} : {}) & (Fields['fps'] extends true ? {
     fps: number | null;
-} : {}) & (EnableVideoCodec extends true ? {
-    videoCodec: KnownVideoCodecs | null;
-} : {}) & (EnableAudioCodec extends true ? {
-    audioCodec: KnownAudioCodecs | null;
-} : {}) & (EnableTracks extends true ? {
-    videoTracks: VideoTrack[];
-    audioTracks: AudioTrack[];
-} : {}) & (EnableRotation extends true ? {
+} : {}) & (Fields['videoCodec'] extends true ? {
+    videoCodec: MediaParserVideoCodec | null;
+} : {}) & (Fields['audioCodec'] extends true ? {
+    audioCodec: MediaParserAudioCodec | null;
+} : {}) & (Fields['tracks'] extends true ? TracksField : {}) & (Fields['rotation'] extends true ? {
     rotation: number | null;
-} : {}) & (EnableUnrotatedDimensions extends true ? {
+} : {}) & (Fields['unrotatedDimensions'] extends true ? {
     unrotatedDimensions: Dimensions;
-} : {}) & (EnableInternalStats extends true ? {
+} : {}) & (Fields['internalStats'] extends true ? {
     internalStats: InternalStats;
+} : {}) & (Fields['size'] extends true ? {
+    size: number | null;
+} : {}) & (Fields['name'] extends true ? {
+    name: string;
+} : {}) & (Fields['container'] extends true ? {
+    container: ParseMediaContainer | null;
 } : {});
-export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean, EnableTracks extends boolean, EnableRotation extends boolean, EnableUnrotatedDimensions extends boolean, EnableInternalStats extends boolean>(options: {
+export type ParseMedia = <F extends Options<ParseMediaFields>>(options: {
     src: string | File;
-    fields?: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec, EnableTracks, EnableRotation, EnableUnrotatedDimensions, EnableInternalStats>;
+    fields?: F;
     reader?: ReaderInterface;
     onAudioTrack?: OnAudioTrack;
     onVideoTrack?: OnVideoTrack;
     signal?: AbortSignal;
-}) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec, EnableTracks, EnableRotation, EnableUnrotatedDimensions, EnableInternalStats>>;
+} & ParseMediaCallbacks<F>) => Promise<ParseMediaResult<F>>;

package/dist/parse-media.js

@@ -2,25 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
-const get_audio_codec_1 = require("./get-audio-codec");
-const get_dimensions_1 = require("./get-dimensions");
-const get_duration_1 = require("./get-duration");
-const get_fps_1 = require("./get-fps");
-const get_tracks_1 = require("./get-tracks");
-const get_video_codec_1 = require("./get-video-codec");
+const emit_available_info_1 = require("./emit-available-info");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parser_state_1 = require("./parser-state");
 const from_fetch_1 = require("./readers/from-fetch");
-const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, }) => {
+const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, ...more }) => {
     const state = (0, parser_state_1.makeParserState)({
         hasAudioCallbacks: onAudioTrack !== null,
         hasVideoCallbacks: onVideoTrack !== null,
         signal,
     });
-    const { reader, contentLength } = await readerInterface.read(src, null, signal);
+    const { reader, contentLength, name } = await readerInterface.read(src, null, signal);
     let currentReader = reader;
     const returnValue = {};
+    const moreFields = more;
     let iterator = null;
     let parseResult = null;
     const options = {
@@ -36,7 +32,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw new Error('Aborted');
         }
-        const result = await currentReader.read();
+        const result = await currentReader.reader.read();
         if (iterator) {
             if (!result.done) {
                 iterator.addData(result.value);
@@ -55,73 +51,58 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             parseResult = await (0, parse_video_1.parseVideo)({
                 iterator,
                 options,
+                signal: signal !== null && signal !== void 0 ? signal : null,
             });
         }
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
+        const hasAllInfo = Object.values(availableInfo).every(Boolean);
+        (0, emit_available_info_1.emitAvailableInfo)({
+            hasInfo: availableInfo,
+            moreFields,
+            parseResult,
+            state,
+            returnValue,
+            contentLength,
+            name,
+        });
         // TODO Better: Check if no active listeners are registered
         // Also maybe check for canSkipVideoData
-        if ((0, has_all_info_1.hasAllInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state) &&
-            !onVideoTrack &&
-            !onAudioTrack) {
-            if (!currentReader.closed) {
-                currentReader.cancel(new Error('has all information'));
-            }
+        if (hasAllInfo && !onVideoTrack && !onAudioTrack) {
             break;
         }
         if (parseResult &&
             parseResult.status === 'incomplete' &&
             parseResult.skipTo !== null) {
-            if (!currentReader.closed) {
-                currentReader.cancel(new Error('skipped ahead'));
-            }
             const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
             currentReader = newReader;
             iterator.skipTo(parseResult.skipTo);
         }
     }
-    if (!parseResult) {
-        throw new Error('Could not parse video');
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.dimensions) {
-        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
-        returnValue.dimensions = {
-            width: dimensions.width,
-            height: dimensions.height,
-        };
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.unrotatedDimensions) {
-        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
-        returnValue.unrotatedDimensions = {
-            width: dimensions.unrotatedWidth,
-            height: dimensions.unrotatedHeight,
-        };
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.rotation) {
-        const dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
-        returnValue.rotation = dimensions.rotation;
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.durationInSeconds) {
-        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments, state);
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.fps) {
-        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.videoCodec) {
-        returnValue.videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.audioCodec) {
-        returnValue.audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments);
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.tracks) {
-        const { audioTracks, videoTracks } = (0, get_tracks_1.getTracks)(parseResult.segments, state);
-        returnValue.audioTracks = audioTracks;
-        returnValue.videoTracks = videoTracks;
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.boxes) {
-        returnValue.boxes = parseResult.segments;
-    }
-    if (fields === null || fields === void 0 ? void 0 : fields.internalStats) {
-        returnValue.internalStats = state.getInternalStats();
-    }
+    // Force assign
+    (0, emit_available_info_1.emitAvailableInfo)({
+        hasInfo: {
+            boxes: true,
+            durationInSeconds: true,
+            dimensions: true,
+            fps: true,
+            videoCodec: true,
+            audioCodec: true,
+            tracks: true,
+            rotation: true,
+            unrotatedDimensions: true,
+            internalStats: true,
+            size: true,
+            name: true,
+            container: true,
+        },
+        moreFields,
+        parseResult,
+        state,
+        returnValue,
+        contentLength,
+        name,
+    });
+    currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
     return returnValue;
 };

package/dist/parse-video.d.ts

@@ -14,7 +14,8 @@ export type BoxAndNext = {
 } | {
     type: 'incomplete';
 } | PartialMdatBox;
-export declare const parseVideo: ({ iterator, options, }: {
+export declare const parseVideo: ({ iterator, options, signal, }: {
     iterator: BufferIterator;
     options: ParserContext;
+    signal: AbortSignal | null;
 }) => Promise<ParseResult>;

package/dist/parse-video.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
 const process_box_1 = require("./boxes/iso-base-media/process-box");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
-const parseVideo = ({ iterator, options, }) => {
+const parseVideo = ({ iterator, options, signal, }) => {
     if (iterator.bytesRemaining() === 0) {
         return Promise.resolve({
             status: 'incomplete',
@@ -12,6 +12,7 @@ const parseVideo = ({ iterator, options, }) => {
                 return (0, exports.parseVideo)({
                     iterator,
                     options,
+                    signal,
                 });
             },
             skipTo: null,
@@ -41,6 +42,7 @@ const parseVideo = ({ iterator, options, }) => {
             options,
             continueMdat: false,
             littleEndian: false,
+            signal,
         });
     }
     if (iterator.isWebm()) {

package/dist/parser-state.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
 const traversal_1 = require("./boxes/webm/traversal");
-const traversal_2 = require("./traversal");
 const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
     const trackEntries = {};
     const onTrackEntrySegment = (trackEntry) => {
         var _a;
-        const trackId = (0, traversal_2.getTrackId)(trackEntry);
+        const trackId = (0, traversal_1.getTrackId)(trackEntry);
         if (!trackId) {
             throw new Error('Expected track id');
         }

package/dist/readers/from-fetch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchReader = void 0;
 exports.fetchReader = {
     read: async (src, range, signal) => {
+        var _a;
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `fetchReader`');
         }
@@ -10,10 +11,12 @@ exports.fetchReader = {
             ? new URL(src, window.location.origin).toString()
             : src;
         if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('blob:') &&
             !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().'));
+                ' is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass `reader: nodeReader` to parseMedia().'));
         }
+        const controller = new AbortController();
         const res = await fetch(resolvedUrl, {
             headers: range === null
                 ? {}
@@ -24,10 +27,13 @@ exports.fetchReader = {
                     : {
                         Range: `bytes=${`${range[0]}-${range[1]}`}`,
                     },
-            signal,
+            signal: controller.signal,
             // Disable Next.js caching
             cache: 'no-store',
         });
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
+            controller.abort();
+        }, { once: true });
         if (res.status.toString().startsWith('4') ||
             res.status.toString().startsWith('5')) {
             throw new Error(`Server returned status code ${res.status} for ${src}`);
@@ -37,13 +43,27 @@ exports.fetchReader = {
         }
         const length = res.headers.get('content-length');
         const contentLength = length === null ? null : parseInt(length, 10);
+        const contentDisposition = res.headers.get('content-disposition');
+        const name = (_a = contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.match(/filename="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1];
+        const fallbackName = src.split('/').pop();
         const reader = res.body.getReader();
         if (signal) {
             signal.addEventListener('abort', () => {
-                reader.cancel();
+                reader.cancel().catch(() => {
+                    // Prevent unhandled rejection in Firefox
+                });
             }, { once: true });
         }
-        return { reader, contentLength };
+        return {
+            reader: {
+                reader,
+                abort: () => {
+                    controller.abort();
+                },
+            },
+            contentLength,
+            name: name !== null && name !== void 0 ? name : fallbackName,
+        };
     },
     getLength: async (src) => {
         if (typeof src !== 'string') {

package/dist/readers/from-node.js

@@ -9,6 +9,7 @@ exports.nodeReader = {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
+        const controller = new AbortController();
         const stream = (0, fs_1.createReadStream)(src, {
             start: range === null ? 0 : typeof range === 'number' ? range : range[0],
             end: range === null
@@ -16,18 +17,27 @@ exports.nodeReader = {
                 : typeof range === 'number'
                     ? Infinity
                     : range[1],
-            signal,
+            signal: controller.signal,
         });
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
+            controller.abort();
+        }, { once: true });
         const stats = await (0, promises_1.stat)(src);
         const reader = stream_1.Readable.toWeb(stream).getReader();
         if (signal) {
             signal.addEventListener('abort', () => {
-                reader.cancel();
+                reader.cancel().catch(() => { });
             }, { once: true });
         }
         return {
-            reader,
+            reader: {
+                reader,
+                abort: () => {
+                    controller.abort();
+                },
+            },
             contentLength: stats.size,
+            name: src.split('/').pop(),
         };
     },
     getLength: async (src) => {

package/dist/readers/from-web-file.js

@@ -13,16 +13,28 @@ exports.webFileReader = {
                 : file.slice(range[0], range[1]);
         const reader = new FileReader();
         reader.readAsArrayBuffer(file);
+        const controller = new AbortController();
+        if (controller) {
+            controller.signal.addEventListener('abort', () => {
+                reader.abort();
+            }, { once: true });
+        }
         if (signal) {
             signal.addEventListener('abort', () => {
-                reader.abort();
+                controller.abort();
             }, { once: true });
         }
         return new Promise((resolve, reject) => {
             reader.onload = () => {
                 resolve({
-                    reader: part.stream().getReader(),
+                    reader: {
+                        reader: part.stream().getReader(),
+                        abort() {
+                            controller.abort();
+                        },
+                    },
                     contentLength: file.size,
+                    name: file.name,
                 });
             };
             reader.onerror = (error) => {

package/dist/readers/reader.d.ts

@@ -1,6 +1,11 @@
-type ReadResult = {
+type Reader = {
     reader: ReadableStreamDefaultReader<Uint8Array>;
+    abort: () => void;
+};
+type ReadResult = {
+    reader: Reader;
     contentLength: number | null;
+    name: string;
 };
 type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
 type GetLength = (src: string | File) => Promise<number>;

package/dist/samples-from-moof.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSamplesFromMoof = void 0;
-const traversal_1 = require("./traversal");
+const traversal_1 = require("./boxes/iso-base-media/traversal");
 const getSamplesFromTraf = (trafSegment, moofOffset) => {
     var _a, _b, _c, _d, _e, _f;
     if (trafSegment.type !== 'regular-box' || trafSegment.boxType !== 'traf') {

package/dist/traversal.d.ts

@@ -14,7 +14,6 @@ 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;
@@ -36,26 +35,6 @@ 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;