@remotion/media-parser 4.0.209 → 4.0.211

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,10 @@
-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 type { ReaderInterface } from './readers/reader';
 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,25 @@
 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, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
     let currentReader = reader;
+    const supportsContentRange = readerSupportsContentRange &&
+        !(typeof process !== 'undefined' &&
+            typeof process.env !== 'undefined' &&
+            process.env.DISABLE_CONTENT_RANGE === 'true');
     const returnValue = {};
+    const moreFields = more;
     let iterator = null;
     let parseResult = null;
     const options = {
@@ -31,22 +31,35 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         nullifySamples: !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
             process.env.KEEP_SAMPLES === 'true'),
+        supportsContentRange,
     };
     while (parseResult === null || parseResult.status === 'incomplete') {
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw new Error('Aborted');
         }
-        const result = await currentReader.read();
-        if (iterator) {
-            if (!result.done) {
-                iterator.addData(result.value);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const result = await currentReader.reader.read();
+            if (iterator) {
+                if (!result.done) {
+                    iterator.addData(result.value);
+                }
+            }
+            else {
+                if (result.done) {
+                    throw new Error('Unexpectedly reached EOF');
+                }
+                iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
+            }
+            if (iterator.bytesRemaining() >= 0) {
+                break;
             }
-        }
-        else {
             if (result.done) {
-                throw new Error('Unexpectedly reached EOF');
+                break;
             }
-            iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : 1000000000);
+        }
+        if (!iterator) {
+            throw new Error('Unexpected null');
         }
         if (parseResult && parseResult.status === 'incomplete') {
             parseResult = await parseResult.continueParsing();
@@ -55,73 +68,50 @@ 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'));
+            if (!supportsContentRange) {
+                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
             }
             const { reader: newReader } = await readerInterface.read(src, parseResult.skipTo, signal);
             currentReader = newReader;
-            iterator.skipTo(parseResult.skipTo);
+            iterator.skipTo(parseResult.skipTo, true);
         }
     }
-    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: Object.keys(fields !== null && fields !== void 0 ? fields : {}).reduce((acc, key) => {
+            acc[key] = true;
+            return acc;
+        }, {}),
+        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-context.d.ts

@@ -6,4 +6,5 @@ export type ParserContext = {
     canSkipVideoData: boolean;
     parserState: ParserState;
     nullifySamples: boolean;
+    supportsContentRange: boolean;
 };

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.d.ts

@@ -1,2 +1,14 @@
 import type { ReaderInterface } from './reader';
+interface ParsedContentRange {
+    unit: string;
+    start?: number | null;
+    end?: number | null;
+    size?: number | null;
+}
+/**
+ * Parse Content-Range header.
+ * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
+ */
+export declare function parseContentRange(input: string): ParsedContentRange | null;
 export declare const fetchReader: ReaderInterface;
+export {};

package/dist/readers/from-fetch.js

@@ -1,8 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchReader = void 0;
+exports.fetchReader = exports.parseContentRange = void 0;
+/**
+ * Parse Content-Range header.
+ * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
+ */
+function parseContentRange(input) {
+    const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
+    if (!matches)
+        return null;
+    const [, unit, , start, end, size] = matches;
+    const range = {
+        unit,
+        start: start != null ? Number(start) : null,
+        end: end != null ? Number(end) : null,
+        size: size === '*' ? null : Number(size),
+    };
+    if (range.start === null && range.end === null && range.size === null) {
+        return null;
+    }
+    return range;
+}
+exports.parseContentRange = parseContentRange;
+const validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange) => {
+    if (typeof actualRange === 'number' &&
+        (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== actualRange) {
+        if (actualRange === 0) {
+            return { supportsContentRange: false };
+        }
+        throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+    }
+    if (actualRange !== null &&
+        typeof actualRange !== 'number' &&
+        ((parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== actualRange[0] ||
+            (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.end) !== actualRange[1])) {
+        throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+    }
+    return { supportsContentRange: true };
+};
 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,40 +48,68 @@ 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 `reader: 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 cache = typeof navigator !== 'undefined' &&
+            navigator.userAgent.includes('Cloudflare-Workers')
+            ? undefined
+            : // Disable Next.js caching
+                'no-store';
+        const actualRange = range === null ? 0 : range;
         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',
+            headers: typeof actualRange === 'number'
+                ? {
+                    Range: `bytes=${actualRange}-`,
+                }
+                : {
+                    Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`,
+                },
+            signal: controller.signal,
+            cache,
         });
+        const contentRange = res.headers.get('content-range');
+        const parsedContentRange = contentRange
+            ? parseContentRange(contentRange)
+            : null;
+        const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange);
+        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}`);
+            throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
         }
         if (!res.body) {
             throw new Error('No body');
         }
         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,
+            supportsContentRange,
+        };
     },
     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,28 @@ 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(),
+            supportsContentRange: true,
         };
     },
     getLength: async (src) => {