@remotion/media-parser 4.0.240 → 4.0.242

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) => {