@remotion/media-parser 4.0.239 → 4.0.241

package/dist/has-all-info.js

@@ -9,8 +9,8 @@ const get_fps_1 = require("./get-fps");
 const get_is_hdr_1 = require("./get-is-hdr");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const getAvailableInfo = (options, structure, state) => {
-    const keys = Object.entries(options).filter(([, value]) => value);
+const getAvailableInfo = ({ fieldsToFetch, structure, state, }) => {
+    const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
     const infos = keys.map(([_key]) => {
         const key = _key;
         if (key === 'structure') {
@@ -45,13 +45,16 @@ const getAvailableInfo = (options, structure, state) => {
         if (key === 'size') {
             return true;
         }
+        if (key === 'mimeType') {
+            return true;
+        }
         if (key === 'name') {
             return true;
         }
         if (key === 'container') {
             return Boolean(structure && (0, get_container_1.hasContainer)(structure));
         }
-        if (key === 'metadata') {
+        if (key === 'metadata' || key === 'location') {
             return false;
         }
         throw new Error(`Unknown key: ${key}`);
@@ -65,7 +68,11 @@ const getAvailableInfo = (options, structure, state) => {
 };
 exports.getAvailableInfo = getAvailableInfo;
 const hasAllInfo = ({ fields, state, structure, }) => {
-    const availableInfo = (0, exports.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, structure, state);
+    const availableInfo = (0, exports.getAvailableInfo)({
+        fieldsToFetch: fields !== null && fields !== void 0 ? fields : {},
+        structure,
+        state,
+    });
     return (Object.values(availableInfo).every(Boolean) &&
         (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks()));
 };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { IoEventEmitter } from './create/event-emitter';
 import type { ProgressTracker } from './create/progress-tracker';
 import type { LogLevel } from './log';
+export { IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsupportedFileTypeError, IsAPdfError, } from './errors';
 export { MetadataEntry } from './metadata/get-metadata';
 export { WriterInterface } from './writers/writer';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
@@ -9,6 +10,7 @@ export { parseMedia } from './parse-media';
 export { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
 export type { MediaFn } from './create/media-fn';
 export { Dimensions } from './get-dimensions';
+export { MediaParserLocation } from './get-location';
 export type { ReaderInterface } from './readers/reader';
 export declare const MediaParserInternals: {
     createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
@@ -44,7 +46,7 @@ export declare const MediaParserInternals: {
         audioObjectType: number;
         sampleRate: number;
         channelConfiguration: number;
-    }) => Uint8Array;
+    }) => Uint8Array<ArrayBuffer>;
 };
 export type { IoEventEmitter, LogLevel, ProgressTracker };
 export { VERSION } from './version';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.MediaParserInternals = exports.parseMedia = void 0;
+exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = void 0;
 const aac_codecprivate_1 = require("./aac-codecprivate");
 const event_emitter_1 = require("./create/event-emitter");
 const create_iso_base_media_1 = require("./create/iso-base-media/create-iso-base-media");
@@ -9,6 +9,12 @@ const progress_tracker_1 = require("./create/progress-tracker");
 const create_wav_1 = require("./create/wav/create-wav");
 const with_resolvers_1 = require("./create/with-resolvers");
 const log_1 = require("./log");
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "IsAGifError", { enumerable: true, get: function () { return errors_1.IsAGifError; } });
+Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: function () { return errors_1.IsAnImageError; } });
+Object.defineProperty(exports, "IsAnUnsupportedAudioTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedAudioTypeError; } });
+Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
+Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 exports.MediaParserInternals = {

package/dist/options.d.ts

@@ -1,4 +1,5 @@
 import type { Dimensions } from './get-dimensions';
+import type { MediaParserLocation } from './get-location';
 import type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, VideoTrack } from './get-tracks';
 import type { LogLevel } from './log';
 import type { MetadataEntry } from './metadata/get-metadata';
@@ -23,6 +24,8 @@ export type ParseMediaFields = {
     container: boolean;
     isHdr: boolean;
     metadata: boolean;
+    location: boolean;
+    mimeType: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
@@ -40,90 +43,78 @@ export type AllParseMediaFields = {
     container: true;
     isHdr: true;
     metadata: true;
+    location: true;
+    mimeType: true;
 };
-export type Options<Fields extends ParseMediaFields> = {
-    dimensions?: Fields['dimensions'];
-    durationInSeconds?: Fields['durationInSeconds'];
-    structure?: Fields['structure'];
-    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'];
-    isHdr?: Fields['isHdr'];
-    metadata?: Fields['metadata'];
+export type AllOptions<Fields extends ParseMediaFields> = {
+    dimensions: Fields['dimensions'];
+    durationInSeconds: Fields['durationInSeconds'];
+    structure: Fields['structure'];
+    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'];
+    isHdr: Fields['isHdr'];
+    metadata: Fields['metadata'];
+    location: Fields['location'];
+    mimeType: Fields['mimeType'];
 };
+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 ParseMediaCallbacks<Fields extends Options<ParseMediaFields>> = (Fields['dimensions'] extends true ? {
+export interface ParseMediaCallbacks {
     onDimensions?: (dimensions: Dimensions) => void;
-} : {}) & (Fields['durationInSeconds'] extends true ? {
     onDurationInSeconds?: (durationInSeconds: number | null) => void;
-} : {}) & (Fields['structure'] extends true ? {
     onStructure?: (structure: Structure) => 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['metadata'] extends true ? {
-    onMetadata?: (metadata: MetadataEntry[]) => void;
-} : {}) & (Fields['unrotatedDimensions'] extends true ? {
     onUnrotatedDimensions?: (dimensions: Dimensions) => void;
-} : {}) & (Fields['isHdr'] extends true ? {
-    onIsHdr?: (isHdr: boolean) => void;
-} : {}) & (Fields['size'] extends true ? {
+    onInternalStats?: (internalStats: InternalStats) => void;
     onSize?: (size: number | null) => void;
-} : {}) & (Fields['name'] extends true ? {
     onName?: (name: string) => void;
-} : {}) & (Fields['container'] extends true ? {
     onContainer?: (container: ParseMediaContainer) => void;
-} : {});
-export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields['dimensions'] extends true ? {
+    onIsHdr?: (isHdr: boolean) => void;
+    onMetadata?: (metadata: MetadataEntry[]) => void;
+    onLocation?: (location: MediaParserLocation | null) => void;
+    onMimeType?: (mimeType: string | null) => void;
+}
+export interface ParseMediaData {
     dimensions: Dimensions;
-} : {}) & (Fields['durationInSeconds'] extends true ? {
     durationInSeconds: number | null;
-} : {}) & (Fields['structure'] extends true ? {
     structure: Structure;
-} : {}) & (Fields['fps'] extends true ? {
     fps: number | null;
-} : {}) & (Fields['videoCodec'] extends true ? {
     videoCodec: MediaParserVideoCodec | null;
-} : {}) & (Fields['audioCodec'] extends true ? {
     audioCodec: MediaParserAudioCodec | null;
-} : {}) & (Fields['tracks'] extends true ? TracksField : {}) & (Fields['rotation'] extends true ? {
+    tracks: TracksField;
     rotation: number | null;
-} : {}) & (Fields['unrotatedDimensions'] extends true ? {
     unrotatedDimensions: Dimensions;
-} : {}) & (Fields['isHdr'] extends true ? {
     isHdr: boolean;
-} : {}) & (Fields['internalStats'] extends true ? {
     internalStats: InternalStats;
-} : {}) & (Fields['size'] extends true ? {
     size: number | null;
-} : {}) & (Fields['name'] extends true ? {
     name: string;
-} : {}) & (Fields['metadata'] extends true ? {
     metadata: MetadataEntry[];
-} : {}) & (Fields['container'] extends true ? {
+    location: MediaParserLocation | null;
     container: ParseMediaContainer;
-} : {});
+    mimeType: string | null;
+}
+export type ParseMediaResult<T extends Partial<ParseMediaFields>> = {
+    [K in keyof T]: T[K] extends true ? K extends keyof ParseMediaData ? ParseMediaData[K] : never : never;
+};
 export type ParseMediaDynamicOptions<F extends Options<ParseMediaFields>> = {
     fields?: F;
-} & ParseMediaCallbacks<F>;
+} & ParseMediaCallbacks;
 export type ParseMediaProgress = {
     bytes: number;
     percentage: number | null;

package/dist/parse-media.js

@@ -3,23 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
 const emit_available_info_1 = require("./emit-available-info");
+const get_fields_from_callbacks_1 = require("./get-fields-from-callbacks");
 const has_all_info_1 = require("./has-all-info");
 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 ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) => {
+const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) {
     let iterator = null;
     let parseResult = null;
+    const fieldsInReturnValue = _fieldsInReturnValue !== null && _fieldsInReturnValue !== void 0 ? _fieldsInReturnValue : {};
+    const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
+        fields: fieldsInReturnValue,
+        callbacks: more,
+    });
     const state = (0, parser_state_1.makeParserState)({
         hasAudioTrackHandlers: Boolean(onAudioTrack),
         hasVideoTrackHandlers: Boolean(onVideoTrack),
         signal,
         getIterator: () => iterator,
-        fields: fields !== null && fields !== void 0 ? fields : {},
+        fields,
     });
-    const { reader, contentLength, name, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
+    const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
     let currentReader = reader;
+    const emittedFields = {
+        audioCodec: false,
+        container: false,
+        dimensions: false,
+        durationInSeconds: false,
+        fps: false,
+        internalStats: false,
+        isHdr: false,
+        location: false,
+        metadata: false,
+        mimeType: false,
+        name: false,
+        rotation: false,
+        size: false,
+        structure: false,
+        tracks: false,
+        videoCodec: false,
+        unrotatedDimensions: false,
+    };
     const supportsContentRange = readerSupportsContentRange &&
         !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
@@ -38,15 +63,22 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
     };
     const triggerInfoEmit = () => {
         var _a;
-        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, (_a = parseResult === null || parseResult === void 0 ? void 0 : parseResult.segments) !== null && _a !== void 0 ? _a : null, state);
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)({
+            fieldsToFetch: fields,
+            structure: (_a = parseResult === null || parseResult === void 0 ? void 0 : parseResult.segments) !== null && _a !== void 0 ? _a : null,
+            state,
+        });
         (0, emit_available_info_1.emitAvailableInfo)({
             hasInfo: availableInfo,
-            moreFields,
+            callbacks: moreFields,
+            fieldsInReturnValue,
             parseResult,
             state,
             returnValue,
             contentLength,
             name,
+            mimeType: contentType,
+            emittedFields,
         });
     };
     triggerInfoEmit();
@@ -95,14 +127,17 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
                 options,
                 signal: signal !== null && signal !== void 0 ? signal : null,
                 logLevel,
-                fields: fields !== null && fields !== void 0 ? fields : {},
+                fields,
+                mimeType: contentType,
+                contentLength,
+                name,
             });
         }
         if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
             state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
         }
         if ((0, has_all_info_1.hasAllInfo)({
-            fields: fields !== null && fields !== void 0 ? fields : {},
+            fields,
             structure: parseResult.segments,
             state,
         })) {
@@ -128,20 +163,24 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         }
     }
     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: Object.keys(fields !== null && fields !== void 0 ? fields : {}).reduce((acc, key) => {
-            if (fields === null || fields === void 0 ? void 0 : fields[key]) {
-                acc[key] = true;
-            }
-            return acc;
-        }, {}),
-        moreFields,
+        hasInfo,
+        callbacks: moreFields,
+        fieldsInReturnValue,
         parseResult,
         state,
         returnValue,
         contentLength,
+        mimeType: contentType,
         name,
+        emittedFields,
     });
     currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();

package/dist/parse-video.d.ts

@@ -16,10 +16,13 @@ export type BoxAndNext = {
 } | {
     type: 'incomplete';
 } | PartialMdatBox;
-export declare const parseVideo: ({ iterator, options, signal, logLevel, fields, }: {
+export declare const parseVideo: ({ iterator, options, signal, logLevel, fields, mimeType, contentLength, name, }: {
     iterator: BufferIterator;
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
+    mimeType: string | null;
+    contentLength: number | null;
+    name: string | null;
 }) => Promise<ParseResult<Structure>>;

package/dist/parse-video.js

@@ -6,16 +6,18 @@ 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_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, options, signal, logLevel, fields, }) => {
+const parseVideo = ({ iterator, options, signal, logLevel, fields, mimeType, contentLength, name, }) => {
     if (iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
-    if (iterator.isRiff()) {
+    const fileType = iterator.detectFileType();
+    if (fileType.type === 'riff') {
         log_1.Log.verbose(logLevel, 'Detected RIFF container');
         return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options, fields }));
     }
-    if (iterator.isIsoBaseMedia()) {
+    if (fileType.type === 'iso-base-media') {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
         return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
@@ -29,11 +31,11 @@ const parseVideo = ({ iterator, options, signal, logLevel, fields, }) => {
             fields,
         });
     }
-    if (iterator.isWebm()) {
+    if (fileType.type === 'webm') {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
         return (0, parse_webm_header_1.parseWebm)({ counter: iterator, parserContext: options, fields });
     }
-    if (iterator.isTransportStream()) {
+    if (fileType.type === 'transport-stream') {
         return (0, parse_transport_stream_1.parseTransportStream)({
             iterator,
             parserContext: options,
@@ -46,9 +48,70 @@ const parseVideo = ({ iterator, options, signal, logLevel, fields, }) => {
             nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
         });
     }
-    if (iterator.isMp3()) {
-        return Promise.reject(new Error('MP3 files are not yet supported'));
+    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',
+        }));
     }
-    return Promise.reject(new Error('Unknown video format'));
+    if (fileType.type === 'wav') {
+        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
+            message: 'WAV files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+            audioType: 'wav',
+        }));
+    }
+    if (fileType.type === 'aac') {
+        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
+            message: 'AAC files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+            audioType: 'aac',
+        }));
+    }
+    if (fileType.type === 'gif') {
+        return Promise.reject(new errors_1.IsAGifError({
+            message: 'GIF files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'pdf') {
+        return Promise.reject(new errors_1.IsAPdfError({
+            message: 'GIF files are not supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'bmp' ||
+        fileType.type === 'jpeg' ||
+        fileType.type === 'png' ||
+        fileType.type === 'webp') {
+        return Promise.reject(new errors_1.IsAnImageError({
+            message: 'Image files are not supported',
+            imageType: fileType.type,
+            dimensions: fileType.dimensions,
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'unknown') {
+        return Promise.reject(new errors_1.IsAnUnsupportedFileTypeError({
+            message: 'Unknown file format',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    return Promise.reject(new Error('Unknown video format ' + fileType));
 };
 exports.parseVideo = parseVideo;

package/dist/probing/detect-file-type.d.ts

@@ -0,0 +1 @@
+export declare const detectFileType: (data: Uint8Array) => "webp" | "riff" | "webm" | "iso-base-media" | "transport-stream" | "mp3" | "gif" | "png" | "bmp" | "jpeg" | "unknown";

package/dist/probing/detect-file-type.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const get_jpeg_dimensions_1 = require("./get-jpeg-dimensions");
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+const isRiff = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(riffPattern)(data.subarray(0, 4));
+};
+const isWebm = (data) => {
+    return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
+};
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+    return matchesPattern(mpegPattern)(data.subarray(0, 4));
+};
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    return matchesPattern(gifPattern)(data.subarray(0, 4));
+};
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    return matchesPattern(pngPattern)(data.subarray(0, 4));
+};
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    return matchesPattern(bmpPattern)(data.subarray(0, 2));
+};
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return false;
+    }
+    const dim = (0, get_jpeg_dimensions_1.getJpegDimensions)(data);
+    console.log(dim);
+    return true;
+};
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(webpPattern)(data.subarray(0, 4));
+};
+const detectFileType = (data) => {
+    if (isWebp(data)) {
+        return 'webp';
+    }
+    if (isRiff(data)) {
+        return 'riff';
+    }
+    if (isWebm(data)) {
+        return 'webm';
+    }
+    if (isIsoBaseMedia(data)) {
+        return 'iso-base-media';
+    }
+    if (isTransportStream(data)) {
+        return 'transport-stream';
+    }
+    if (isMp3(data)) {
+        return 'mp3';
+    }
+    if (isGif(data)) {
+        return 'gif';
+    }
+    if (isPng(data)) {
+        return 'png';
+    }
+    if (isBmp(data)) {
+        return 'bmp';
+    }
+    if (isJpeg(data)) {
+        return 'jpeg';
+    }
+    return 'unknown';
+};
+exports.detectFileType = detectFileType;

package/dist/probing/get-jpeg-dimensions.d.ts

@@ -0,0 +1,4 @@
+export declare function getJpegDimensions(data: Uint8Array): {
+    width: number;
+    height: number;
+} | null;

package/dist/probing/get-jpeg-dimensions.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJpegDimensions = getJpegDimensions;
+function getJpegDimensions(data) {
+    let offset = 0;
+    // Helper function to read a 16-bit big-endian integer
+    function readUint16BE(o) {
+        return (data[o] << 8) | data[o + 1];
+    }
+    // Skip the Start of Image (SOI) marker
+    if (readUint16BE(offset) !== 0xffd8) {
+        return null; // Not a valid JPEG file
+    }
+    offset += 2;
+    while (offset < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                // SOF0 or SOF2
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            offset += length + 2; // Move to the next marker
+        }
+        else {
+            offset++;
+        }
+    }
+    return null; // Return null if dimensions are not found
+}

package/dist/readers/from-fetch.js

@@ -110,6 +110,7 @@ exports.fetchReader = {
                 },
             },
             contentLength,
+            contentType: res.headers.get('content-type'),
             name: name !== null && name !== void 0 ? name : fallbackName,
             supportsContentRange,
         };

package/dist/readers/from-node.js

@@ -38,6 +38,7 @@ exports.nodeReader = {
                 },
             },
             contentLength: stats.size,
+            contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
         };

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

@@ -39,6 +39,7 @@ exports.webFileReader = {
                     contentLength: file.size,
                     name: file.name,
                     supportsContentRange: true,
+                    contentType: file.type,
                 });
             };
             reader.onerror = (error) => {

package/dist/readers/reader.d.ts

@@ -5,6 +5,7 @@ type Reader = {
 type ReadResult = {
     reader: Reader;
     contentLength: number | null;
+    contentType: string | null;
     name: string;
     supportsContentRange: boolean;
 };

package/dist/state/can-skip-tracks.js

@@ -17,6 +17,8 @@ const needsTracksField = {
     unrotatedDimensions: true,
     videoCodec: true,
     metadata: true,
+    location: true,
+    mimeType: false,
 };
 const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }) => {
     return {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.239";
+export declare const VERSION = "4.0.241";