@remotion/media-parser 4.0.240 → 4.0.241

package/dist/emit-available-info.js

@@ -11,105 +11,118 @@ const get_location_1 = require("./get-location");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const get_metadata_1 = require("./metadata/get-metadata");
-const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue, contentLength, name, mimeType, fieldsInReturnValue, emittedFields, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
     const keys = Object.keys(hasInfo);
     for (const key of keys) {
         if (key === 'structure') {
-            if (parseResult &&
-                hasInfo.structure &&
-                returnValue.structure === undefined) {
-                (_a = moreFields.onStructure) === null || _a === void 0 ? void 0 : _a.call(moreFields, parseResult.segments);
-                returnValue.structure = parseResult.segments;
+            if (parseResult && hasInfo.structure && !emittedFields.structure) {
+                (_a = callbacks.onStructure) === null || _a === void 0 ? void 0 : _a.call(callbacks, parseResult.segments);
+                if (fieldsInReturnValue.structure) {
+                    returnValue.structure = parseResult.segments;
+                }
+                emittedFields.structure = true;
             }
             continue;
         }
         if (key === 'durationInSeconds') {
             if (hasInfo.durationInSeconds &&
-                returnValue.durationInSeconds === undefined &&
+                !emittedFields.durationInSeconds &&
                 parseResult) {
                 const durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments, state);
-                (_b = moreFields.onDurationInSeconds) === null || _b === void 0 ? void 0 : _b.call(moreFields, durationInSeconds);
-                returnValue.durationInSeconds = durationInSeconds;
+                (_b = callbacks.onDurationInSeconds) === null || _b === void 0 ? void 0 : _b.call(callbacks, durationInSeconds);
+                if (fieldsInReturnValue.durationInSeconds) {
+                    returnValue.durationInSeconds = durationInSeconds;
+                }
+                emittedFields.durationInSeconds = true;
             }
             continue;
         }
         if (key === 'dimensions') {
-            if (hasInfo.dimensions &&
-                returnValue.dimensions === undefined &&
-                parseResult) {
+            if (hasInfo.dimensions && !emittedFields.dimensions && parseResult) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
                 const dimensions = {
                     height: dimensionsQueried.height,
                     width: dimensionsQueried.width,
                 };
-                (_c = moreFields.onDimensions) === null || _c === void 0 ? void 0 : _c.call(moreFields, dimensions);
-                returnValue.dimensions = dimensions;
+                (_c = callbacks.onDimensions) === null || _c === void 0 ? void 0 : _c.call(callbacks, dimensions);
+                if (fieldsInReturnValue.dimensions) {
+                    returnValue.dimensions = dimensions;
+                }
+                emittedFields.dimensions = true;
             }
             continue;
         }
         if (key === 'unrotatedDimensions') {
-            if (returnValue.unrotatedDimensions === undefined &&
-                hasInfo.unrotatedDimensions &&
+            if (hasInfo.unrotatedDimensions &&
+                !emittedFields.unrotatedDimensions &&
                 parseResult) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
                 const unrotatedDimensions = {
                     height: dimensionsQueried.unrotatedHeight,
                     width: dimensionsQueried.unrotatedWidth,
                 };
-                (_d = moreFields.onUnrotatedDimensions) === null || _d === void 0 ? void 0 : _d.call(moreFields, unrotatedDimensions);
-                returnValue.unrotatedDimensions = unrotatedDimensions;
+                (_d = callbacks.onUnrotatedDimensions) === null || _d === void 0 ? void 0 : _d.call(callbacks, unrotatedDimensions);
+                if (fieldsInReturnValue.unrotatedDimensions) {
+                    returnValue.unrotatedDimensions = unrotatedDimensions;
+                }
+                emittedFields.unrotatedDimensions = true;
             }
             continue;
         }
         if (key === 'rotation') {
-            if (returnValue.rotation === undefined &&
-                hasInfo.rotation &&
-                parseResult) {
+            if (hasInfo.rotation && !emittedFields.rotation && parseResult) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
                 const { rotation } = dimensionsQueried;
-                (_e = moreFields.onRotation) === null || _e === void 0 ? void 0 : _e.call(moreFields, rotation);
-                returnValue.rotation = rotation;
+                (_e = callbacks.onRotation) === null || _e === void 0 ? void 0 : _e.call(callbacks, rotation);
+                if (fieldsInReturnValue.rotation) {
+                    returnValue.rotation = rotation;
+                }
+                emittedFields.rotation = true;
             }
             continue;
         }
         if (key === 'fps') {
-            if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
+            if (!emittedFields.fps && hasInfo.fps && parseResult) {
                 const fps = (0, get_fps_1.getFps)(parseResult.segments);
-                (_f = moreFields.onFps) === null || _f === void 0 ? void 0 : _f.call(moreFields, fps);
-                returnValue.fps = fps;
+                (_f = callbacks.onFps) === null || _f === void 0 ? void 0 : _f.call(callbacks, fps);
+                if (fieldsInReturnValue.fps) {
+                    returnValue.fps = fps;
+                }
+                emittedFields.fps = true;
             }
             continue;
         }
         if (key === 'videoCodec') {
-            if (returnValue.videoCodec === undefined &&
-                hasInfo.videoCodec &&
-                parseResult) {
+            if (!emittedFields.videoCodec && hasInfo.videoCodec && parseResult) {
                 const videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments, state);
-                (_g = moreFields.onVideoCodec) === null || _g === void 0 ? void 0 : _g.call(moreFields, videoCodec);
-                returnValue.videoCodec = videoCodec;
+                (_g = callbacks.onVideoCodec) === null || _g === void 0 ? void 0 : _g.call(callbacks, videoCodec);
+                if (fieldsInReturnValue.videoCodec) {
+                    returnValue.videoCodec = videoCodec;
+                }
+                emittedFields.videoCodec = true;
             }
             continue;
         }
         if (key === 'audioCodec') {
-            if (returnValue.audioCodec === undefined &&
-                hasInfo.audioCodec &&
-                parseResult) {
+            if (!emittedFields.audioCodec && hasInfo.audioCodec && parseResult) {
                 const audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments, state);
-                (_h = moreFields.onAudioCodec) === null || _h === void 0 ? void 0 : _h.call(moreFields, audioCodec);
-                returnValue.audioCodec = audioCodec;
+                (_h = callbacks.onAudioCodec) === null || _h === void 0 ? void 0 : _h.call(callbacks, audioCodec);
+                if (fieldsInReturnValue.audioCodec) {
+                    returnValue.audioCodec = audioCodec;
+                }
+                emittedFields.audioCodec = true;
             }
             continue;
         }
         if (key === 'tracks') {
-            if (hasInfo.tracks &&
-                returnValue.videoTracks === undefined &&
-                returnValue.audioTracks === undefined &&
-                parseResult) {
+            if (!emittedFields.tracks && hasInfo.tracks && parseResult) {
                 const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(parseResult.segments, state);
-                (_j = moreFields.onTracks) === null || _j === void 0 ? void 0 : _j.call(moreFields, { videoTracks, audioTracks });
-                returnValue.videoTracks = videoTracks;
-                returnValue.audioTracks = audioTracks;
+                (_j = callbacks.onTracks) === null || _j === void 0 ? void 0 : _j.call(callbacks, { videoTracks, audioTracks });
+                if (fieldsInReturnValue.tracks) {
+                    returnValue.tracks = { videoTracks, audioTracks };
+                }
+                emittedFields.tracks = true;
             }
             continue;
         }
@@ -117,59 +130,84 @@ const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValu
             // Special case: Always emitting internal stats at the end
             if (hasInfo.internalStats) {
                 const internalStats = state.getInternalStats();
-                returnValue.internalStats = internalStats;
+                if (fieldsInReturnValue.internalStats) {
+                    returnValue.internalStats = internalStats;
+                }
+                emittedFields.internalStats = true;
             }
             continue;
         }
         if (key === 'size') {
-            if (returnValue.size === undefined && hasInfo.size) {
-                (_k = moreFields.onSize) === null || _k === void 0 ? void 0 : _k.call(moreFields, contentLength);
-                returnValue.size = contentLength;
+            if (!emittedFields.size && hasInfo.size) {
+                (_k = callbacks.onSize) === null || _k === void 0 ? void 0 : _k.call(callbacks, contentLength);
+                if (fieldsInReturnValue.size) {
+                    returnValue.size = contentLength;
+                }
+                emittedFields.size = true;
+            }
+            continue;
+        }
+        if (key === 'mimeType') {
+            if (!emittedFields.mimeType && hasInfo.mimeType) {
+                (_l = callbacks.onMimeType) === null || _l === void 0 ? void 0 : _l.call(callbacks, mimeType);
+                if (fieldsInReturnValue.mimeType) {
+                    returnValue.mimeType = mimeType;
+                }
+                emittedFields.mimeType = true;
             }
             continue;
         }
         if (key === 'name') {
-            if (returnValue.name === undefined && hasInfo.name) {
-                (_l = moreFields.onName) === null || _l === void 0 ? void 0 : _l.call(moreFields, name);
-                returnValue.name = name;
+            if (!emittedFields.name && hasInfo.name) {
+                (_m = callbacks.onName) === null || _m === void 0 ? void 0 : _m.call(callbacks, name);
+                if (fieldsInReturnValue.name) {
+                    returnValue.name = name;
+                }
+                emittedFields.name = true;
             }
             continue;
         }
         if (key === 'isHdr') {
-            if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
+            if (!returnValue.isHdr && hasInfo.isHdr && parseResult) {
                 const isHdr = (0, get_is_hdr_1.getIsHdr)(parseResult.segments, state);
-                (_m = moreFields.onIsHdr) === null || _m === void 0 ? void 0 : _m.call(moreFields, isHdr);
-                returnValue.isHdr = isHdr;
+                (_o = callbacks.onIsHdr) === null || _o === void 0 ? void 0 : _o.call(callbacks, isHdr);
+                if (fieldsInReturnValue.isHdr) {
+                    returnValue.isHdr = isHdr;
+                }
+                emittedFields.isHdr = true;
             }
             continue;
         }
         if (key === 'container') {
-            if (returnValue.container === undefined &&
-                hasInfo.container &&
-                parseResult) {
+            if (!returnValue.container && hasInfo.container && parseResult) {
                 const container = (0, get_container_1.getContainer)(parseResult.segments);
-                (_o = moreFields.onContainer) === null || _o === void 0 ? void 0 : _o.call(moreFields, container);
-                returnValue.container = container;
+                (_p = callbacks.onContainer) === null || _p === void 0 ? void 0 : _p.call(callbacks, container);
+                if (fieldsInReturnValue.container) {
+                    returnValue.container = container;
+                }
+                emittedFields.container = true;
             }
             continue;
         }
         if (key === 'metadata') {
-            if (returnValue.metadata === undefined &&
-                hasInfo.metadata &&
-                parseResult) {
+            if (!emittedFields.metadata && hasInfo.metadata && parseResult) {
                 const metadata = (0, get_metadata_1.getMetadata)(parseResult.segments);
-                (_p = moreFields.onMetadata) === null || _p === void 0 ? void 0 : _p.call(moreFields, metadata);
-                returnValue.metadata = metadata;
+                (_q = callbacks.onMetadata) === null || _q === void 0 ? void 0 : _q.call(callbacks, metadata);
+                if (fieldsInReturnValue.metadata) {
+                    returnValue.metadata = metadata;
+                }
+                emittedFields.metadata = true;
             }
             continue;
         }
         if (key === 'location') {
-            if (returnValue.location === undefined &&
-                hasInfo.location &&
-                parseResult) {
+            if (!emittedFields.location && hasInfo.location && parseResult) {
                 const location = (0, get_location_1.getLocation)(parseResult.segments);
-                (_q = moreFields.onLocation) === null || _q === void 0 ? void 0 : _q.call(moreFields, location);
-                returnValue.location = location;
+                (_r = callbacks.onLocation) === null || _r === void 0 ? void 0 : _r.call(callbacks, location);
+                if (fieldsInReturnValue.location) {
+                    returnValue.location = location;
+                }
+                emittedFields.location = true;
             }
             continue;
         }

package/dist/errors/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/errors/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 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 width = data[6] * 256 + data[7];
+    const height = data[8] * 256 + data[9];
+    console.log(width, height);
+    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/errors/file-types.d.ts

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

package/dist/errors/file-types.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 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 width = data[6] * 256 + data[7];
+    const height = data[8] * 256 + data[9];
+    console.log(width, height);
+    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/errors.d.ts

@@ -0,0 +1,68 @@
+export declare class IsAGifError extends Error {
+    mimeType: string | null;
+    sizeInBytes: number | null;
+    fileName: string | null;
+    constructor({ message, mimeType, sizeInBytes, fileName, }: {
+        message: string;
+        mimeType: string | null;
+        sizeInBytes: number | null;
+        fileName: string | null;
+    });
+}
+type ImageType = 'png' | 'jpeg' | 'bmp' | 'webp';
+type Dimensions = {
+    width: number;
+    height: number;
+};
+export declare class IsAnImageError extends Error {
+    imageType: ImageType;
+    dimensions: Dimensions | null;
+    mimeType: string | null;
+    sizeInBytes: number | null;
+    fileName: string | null;
+    constructor({ dimensions, imageType, message, mimeType, sizeInBytes, fileName, }: {
+        message: string;
+        imageType: ImageType;
+        dimensions: Dimensions | null;
+        mimeType: string | null;
+        sizeInBytes: number | null;
+        fileName: string | null;
+    });
+}
+export declare class IsAPdfError extends Error {
+    mimeType: string | null;
+    sizeInBytes: number | null;
+    fileName: string | null;
+    constructor({ message, mimeType, sizeInBytes, fileName, }: {
+        message: string;
+        mimeType: string | null;
+        sizeInBytes: number | null;
+        fileName: string | null;
+    });
+}
+export declare class IsAnUnsupportedFileTypeError extends Error {
+    mimeType: string | null;
+    sizeInBytes: number | null;
+    fileName: string | null;
+    constructor({ message, mimeType, sizeInBytes, fileName, }: {
+        message: string;
+        mimeType: string | null;
+        sizeInBytes: number | null;
+        fileName: string | null;
+    });
+}
+type UnsupportedAudioType = 'mp3' | 'wav' | 'aac';
+export declare class IsAnUnsupportedAudioTypeError extends Error {
+    mimeType: string | null;
+    sizeInBytes: number | null;
+    fileName: string | null;
+    audioType: UnsupportedAudioType | null;
+    constructor({ message, mimeType, sizeInBytes, fileName, audioType, }: {
+        message: string;
+        mimeType: string | null;
+        sizeInBytes: number | null;
+        fileName: string | null;
+        audioType: UnsupportedAudioType | null;
+    });
+}
+export {};

package/dist/errors.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAnUnsupportedAudioTypeError = exports.IsAnUnsupportedFileTypeError = exports.IsAPdfError = exports.IsAnImageError = exports.IsAGifError = void 0;
+class IsAGifError extends Error {
+    constructor({ message, mimeType, sizeInBytes, fileName, }) {
+        super(message);
+        this.fileName = 'IsAGifError';
+        this.mimeType = mimeType;
+        this.sizeInBytes = sizeInBytes;
+        this.fileName = fileName;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IsAGifError);
+        }
+    }
+}
+exports.IsAGifError = IsAGifError;
+class IsAnImageError extends Error {
+    constructor({ dimensions, imageType, message, mimeType, sizeInBytes, fileName, }) {
+        super(message);
+        this.name = 'IsAnImageError';
+        this.imageType = imageType;
+        this.dimensions = dimensions;
+        this.mimeType = mimeType;
+        this.sizeInBytes = sizeInBytes;
+        this.fileName = fileName;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IsAnImageError);
+        }
+    }
+}
+exports.IsAnImageError = IsAnImageError;
+class IsAPdfError extends Error {
+    constructor({ message, mimeType, sizeInBytes, fileName, }) {
+        super(message);
+        this.name = 'IsAPdfError';
+        this.mimeType = mimeType;
+        this.sizeInBytes = sizeInBytes;
+        this.fileName = fileName;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IsAPdfError);
+        }
+    }
+}
+exports.IsAPdfError = IsAPdfError;
+class IsAnUnsupportedFileTypeError extends Error {
+    constructor({ message, mimeType, sizeInBytes, fileName, }) {
+        super(message);
+        this.name = 'IsAnUnsupportedFileTypeError';
+        this.mimeType = mimeType;
+        this.sizeInBytes = sizeInBytes;
+        this.fileName = fileName;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
+        }
+    }
+}
+exports.IsAnUnsupportedFileTypeError = IsAnUnsupportedFileTypeError;
+class IsAnUnsupportedAudioTypeError extends Error {
+    constructor({ message, mimeType, sizeInBytes, fileName, audioType, }) {
+        super(message);
+        this.name = 'IsAnUnsupportedAudioTypeError';
+        this.mimeType = mimeType;
+        this.sizeInBytes = sizeInBytes;
+        this.fileName = fileName;
+        this.audioType = audioType;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
+        }
+    }
+}
+exports.IsAnUnsupportedAudioTypeError = IsAnUnsupportedAudioTypeError;

package/dist/esm/from-fetch.mjs

@@ -83,6 +83,7 @@ var fetchReader = {
         }
       },
       contentLength,
+      contentType: res.headers.get("content-type"),
       name: name ?? fallbackName,
       supportsContentRange
     };

package/dist/esm/from-node.mjs

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

package/dist/esm/from-web-file.mjs

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