@remotion/media-parser 4.0.240 → 4.0.241

package/dist/file-types/bmp.d.ts

@@ -0,0 +1,6 @@
+import type { Dimensions } from '../get-dimensions';
+export declare const isBmp: (data: Uint8Array) => BmpType | null;
+export type BmpType = {
+    type: 'bmp';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/bmp.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBmp = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+function getBmpDimensions(bmpData) {
+    if (bmpData.length < 26) {
+        return null;
+    }
+    const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+    return {
+        width: view.getUint32(18, true),
+        height: Math.abs(view.getInt32(22, true)),
+    };
+}
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    if ((0, detect_file_type_1.matchesPattern)(bmpPattern)(data.subarray(0, 2))) {
+        const bmp = getBmpDimensions(data);
+        return { dimensions: bmp, type: 'bmp' };
+    }
+    return null;
+};
+exports.isBmp = isBmp;

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

@@ -0,0 +1,42 @@
+import type { BmpType } from './bmp';
+import type { JpegType } from './jpeg';
+import type { PdfType } from './pdf';
+import type { PngType } from './png';
+import type { WebpType } from './webp';
+export declare const matchesPattern: (pattern: Uint8Array) => (data: Uint8Array) => boolean;
+export declare const isRiffAvi: (data: Uint8Array) => boolean;
+export declare const isRiffWave: (data: Uint8Array) => boolean;
+export declare const isWebm: (data: Uint8Array) => boolean;
+export declare const isIsoBaseMedia: (data: Uint8Array) => boolean;
+export declare const isTransportStream: (data: Uint8Array) => boolean;
+export declare const isMp3: (data: Uint8Array) => boolean;
+export declare const isGif: (data: Uint8Array) => boolean;
+export declare const isAac: (data: Uint8Array) => boolean;
+export type RiffType = {
+    type: 'riff';
+};
+export type WebmType = {
+    type: 'webm';
+};
+export type IsoBaseMediaType = {
+    type: 'iso-base-media';
+};
+export type TransportStreamType = {
+    type: 'transport-stream';
+};
+export type Mp3Type = {
+    type: 'mp3';
+};
+export type AacType = {
+    type: 'aac';
+};
+export type WavType = {
+    type: 'wav';
+};
+export type GifType = {
+    type: 'gif';
+};
+export type UnknownType = {
+    type: 'unknown';
+};
+export type FileType = JpegType | WebpType | RiffType | WebmType | WavType | PdfType | AacType | IsoBaseMediaType | TransportStreamType | Mp3Type | GifType | PngType | BmpType | AacType | UnknownType;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAac = exports.isGif = exports.isMp3 = exports.isTransportStream = exports.isIsoBaseMedia = exports.isWebm = exports.isRiffWave = exports.isRiffAvi = exports.matchesPattern = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+exports.matchesPattern = matchesPattern;
+const isRiffAvi = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    return new TextDecoder().decode(fileType) === 'AVI ';
+};
+exports.isRiffAvi = isRiffAvi;
+const isRiffWave = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if (!(0, exports.matchesPattern)(riffPattern)(data.subarray(0, 4))) {
+        return false;
+    }
+    const fileType = data.subarray(8, 12);
+    return new TextDecoder().decode(fileType) === 'WAVE';
+};
+exports.isRiffWave = isRiffWave;
+const isWebm = (data) => {
+    return (0, exports.matchesPattern)(make_header_1.webmPattern)(data.subarray(0, 4));
+};
+exports.isWebm = isWebm;
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return (0, exports.matchesPattern)(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+exports.isIsoBaseMedia = isIsoBaseMedia;
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+exports.isTransportStream = isTransportStream;
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+    const id3Pattern = new Uint8Array([73, 68, 51, 3]);
+    const subarray = data.subarray(0, 4);
+    return ((0, exports.matchesPattern)(mpegPattern)(subarray) ||
+        (0, exports.matchesPattern)(id3Pattern)(subarray));
+};
+exports.isMp3 = isMp3;
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    return (0, exports.matchesPattern)(gifPattern)(data.subarray(0, 4));
+};
+exports.isGif = isGif;
+const isAac = (data) => {
+    const aacPattern = new Uint8Array([0xff, 0xf1]);
+    return (0, exports.matchesPattern)(aacPattern)(data.subarray(0, 2));
+};
+exports.isAac = isAac;

package/dist/file-types/get-jpeg-dimensions.d.ts

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

package/dist/file-types/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/file-types/index.d.ts

@@ -0,0 +1,2 @@
+import type { FileType } from './detect-file-type';
+export declare const detectFileType: (data: Uint8Array) => FileType;

package/dist/file-types/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = void 0;
+const bmp_1 = require("./bmp");
+const detect_file_type_1 = require("./detect-file-type");
+const jpeg_1 = require("./jpeg");
+const pdf_1 = require("./pdf");
+const png_1 = require("./png");
+const webp_1 = require("./webp");
+const detectFileType = (data) => {
+    if ((0, detect_file_type_1.isRiffWave)(data)) {
+        return { type: 'wav' };
+    }
+    if ((0, detect_file_type_1.isRiffAvi)(data)) {
+        return { type: 'riff' };
+    }
+    if ((0, detect_file_type_1.isAac)(data)) {
+        return { type: 'aac' };
+    }
+    const webp = (0, webp_1.isWebp)(data);
+    if (webp) {
+        return webp;
+    }
+    if ((0, detect_file_type_1.isWebm)(data)) {
+        return { type: 'webm' };
+    }
+    if ((0, detect_file_type_1.isIsoBaseMedia)(data)) {
+        return { type: 'iso-base-media' };
+    }
+    if ((0, detect_file_type_1.isTransportStream)(data)) {
+        return { type: 'transport-stream' };
+    }
+    if ((0, detect_file_type_1.isMp3)(data)) {
+        return { type: 'mp3' };
+    }
+    if ((0, detect_file_type_1.isGif)(data)) {
+        return { type: 'gif' };
+    }
+    const png = (0, png_1.isPng)(data);
+    if (png) {
+        return png;
+    }
+    const pdf = (0, pdf_1.isPdf)(data);
+    if (pdf) {
+        return pdf;
+    }
+    const bmp = (0, bmp_1.isBmp)(data);
+    if (bmp) {
+        return bmp;
+    }
+    const jpeg = (0, jpeg_1.isJpeg)(data);
+    if (jpeg) {
+        return jpeg;
+    }
+    return { type: 'unknown' };
+};
+exports.detectFileType = detectFileType;

package/dist/file-types/jpeg.d.ts

@@ -0,0 +1,12 @@
+export declare function getJpegDimensions(data: Uint8Array): {
+    width: number;
+    height: number;
+} | null;
+export declare const isJpeg: (data: Uint8Array) => JpegType | null;
+export type JpegType = {
+    type: 'jpeg';
+    dimensions: {
+        width: number;
+        height: number;
+    } | null;
+};

package/dist/file-types/jpeg.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJpeg = void 0;
+exports.getJpegDimensions = getJpegDimensions;
+const detect_file_type_1 = require("./detect-file-type");
+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
+}
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = (0, detect_file_type_1.matchesPattern)(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return null;
+    }
+    const dim = getJpegDimensions(data);
+    return { dimensions: dim, type: 'jpeg' };
+};
+exports.isJpeg = isJpeg;

package/dist/file-types/pdf.d.ts

@@ -0,0 +1,4 @@
+export type PdfType = {
+    type: 'pdf';
+};
+export declare const isPdf: (data: Uint8Array) => PdfType | null;

package/dist/file-types/pdf.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPdf = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+const isPdf = (data) => {
+    if (data.length < 4) {
+        return null;
+    }
+    const pdfPattern = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
+    return (0, detect_file_type_1.matchesPattern)(pdfPattern)(data.subarray(0, 4)) ? { type: 'pdf' } : null;
+};
+exports.isPdf = isPdf;

package/dist/file-types/png.d.ts

@@ -0,0 +1,10 @@
+import type { Dimensions } from '../get-dimensions';
+export declare function getPngDimensions(pngData: Uint8Array): {
+    width: number;
+    height: number;
+} | null;
+export declare const isPng: (data: Uint8Array) => PngType | null;
+export type PngType = {
+    type: 'png';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/png.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPng = void 0;
+exports.getPngDimensions = getPngDimensions;
+const detect_file_type_1 = require("./detect-file-type");
+function getPngDimensions(pngData) {
+    if (pngData.length < 24) {
+        // PNG header (8) + IHDR chunk (16) minimum
+        return null;
+    }
+    const view = new DataView(pngData.buffer, pngData.byteOffset);
+    // Check PNG signature
+    const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (pngData[i] !== pngSignature[i]) {
+            return null;
+        }
+    }
+    return {
+        width: view.getUint32(16, false), // false = big-endian
+        height: view.getUint32(20, false), // false = big-endian
+    };
+}
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    if ((0, detect_file_type_1.matchesPattern)(pngPattern)(data.subarray(0, 4))) {
+        const png = getPngDimensions(data);
+        return { dimensions: png, type: 'png' };
+    }
+    return null;
+};
+exports.isPng = isPng;

package/dist/file-types/webp.d.ts

@@ -0,0 +1,6 @@
+import type { Dimensions } from '../get-dimensions';
+export declare const isWebp: (data: Uint8Array) => WebpType | null;
+export type WebpType = {
+    type: 'webp';
+    dimensions: Dimensions | null;
+};

package/dist/file-types/webp.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWebp = void 0;
+const detect_file_type_1 = require("./detect-file-type");
+function getWebPDimensions(bytes) {
+    // Check if we have enough bytes for a basic WebP header
+    if (bytes.length < 30) {
+        return null;
+    }
+    // Check WebP file signature
+    // "RIFF" signature (52 49 46 46) and "WEBP" signature (57 45 42 50)
+    if (bytes[0] !== 0x52 || // R
+        bytes[1] !== 0x49 || // I
+        bytes[2] !== 0x46 || // F
+        bytes[3] !== 0x46 || // F
+        bytes[8] !== 0x57 || // W
+        bytes[9] !== 0x45 || // E
+        bytes[10] !== 0x42 || // B
+        bytes[11] !== 0x50 // P
+    ) {
+        return null;
+    }
+    // Check for VP8 bitstream
+    if (bytes[12] === 0x56 && bytes[13] === 0x50 && bytes[14] === 0x38) {
+        // VP8 format
+        if (bytes[15] === 0x20) {
+            // Simple VP8 format
+            return {
+                width: bytes[26] | ((bytes[27] << 8) & 0x3fff),
+                height: bytes[28] | ((bytes[29] << 8) & 0x3fff),
+            };
+        }
+    }
+    // Check for VP8L (lossless) bitstream
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x4c) {
+        return {
+            width: 1 + (bytes[21] | ((bytes[22] & 0x3f) << 8)),
+            height: 1 +
+                (((bytes[22] & 0xc0) >> 6) |
+                    (bytes[23] << 2) |
+                    ((bytes[24] & 0x0f) << 10)),
+        };
+    }
+    // Check for VP8X (extended) bitstream
+    if (bytes[12] === 0x56 &&
+        bytes[13] === 0x50 &&
+        bytes[14] === 0x38 &&
+        bytes[15] === 0x58) {
+        return {
+            width: 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)),
+            height: 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)),
+        };
+    }
+    return null;
+}
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    if ((0, detect_file_type_1.matchesPattern)(webpPattern)(data.subarray(0, 4))) {
+        return {
+            type: 'webp',
+            dimensions: getWebPDimensions(data),
+        };
+    }
+    return null;
+};
+exports.isWebp = isWebp;

package/dist/file-types.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/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/get-audio-codec.d.ts

@@ -11,7 +11,7 @@ type AudioCodecInfo = {
     secondarySpecificator: number | null;
     description: Uint8Array | undefined;
 };
-export declare const getCodecPrivateFromTrak: (trakBox: TrakBox) => Uint8Array | null;
+export declare const getCodecPrivateFromTrak: (trakBox: TrakBox) => Uint8Array<ArrayBufferLike> | null;
 export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | null;
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;

package/dist/get-fields-from-callbacks.d.ts

@@ -0,0 +1,5 @@
+import type { Options, ParseMediaCallbacks, ParseMediaFields } from './options';
+export declare const getFieldsFromCallback: <F extends Options<ParseMediaFields>>({ fields, callbacks, }: {
+    fields: F;
+    callbacks: ParseMediaCallbacks;
+}) => Options<ParseMediaFields>;

package/dist/get-fields-from-callbacks.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldsFromCallback = void 0;
+const getFieldsFromCallback = ({ fields, callbacks, }) => {
+    const newFields = {
+        audioCodec: Boolean(callbacks.onAudioCodec),
+        container: Boolean(callbacks.onContainer),
+        dimensions: Boolean(callbacks.onDimensions),
+        durationInSeconds: Boolean(callbacks.onDurationInSeconds),
+        fps: Boolean(callbacks.onFps),
+        internalStats: Boolean(callbacks.onInternalStats),
+        isHdr: Boolean(callbacks.onIsHdr),
+        location: Boolean(callbacks.onLocation),
+        metadata: Boolean(callbacks.onMetadata),
+        mimeType: Boolean(callbacks.onMimeType),
+        name: Boolean(callbacks.onName),
+        rotation: Boolean(callbacks.onRotation),
+        size: Boolean(callbacks.onSize),
+        structure: Boolean(callbacks.onStructure),
+        tracks: Boolean(callbacks.onTracks),
+        unrotatedDimensions: Boolean(callbacks.onUnrotatedDimensions),
+        videoCodec: Boolean(callbacks.onVideoCodec),
+        ...fields,
+    };
+    return newFields;
+};
+exports.getFieldsFromCallback = getFieldsFromCallback;

package/dist/has-all-info.d.ts

@@ -1,7 +1,11 @@
 import type { Options, ParseMediaFields } from './options';
 import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getAvailableInfo: (options: Options<ParseMediaFields>, structure: Structure | null, state: ParserState) => Record<keyof Options<ParseMediaFields>, boolean>;
+export declare const getAvailableInfo: ({ fieldsToFetch, structure, state, }: {
+    fieldsToFetch: Options<ParseMediaFields>;
+    structure: Structure | null;
+    state: ParserState;
+}) => Record<keyof Options<ParseMediaFields>, boolean>;
 export declare const hasAllInfo: ({ fields, state, structure, }: {
     structure: Structure | null;
     fields: Options<ParseMediaFields>;

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,6 +45,9 @@ const getAvailableInfo = (options, structure, state) => {
         if (key === 'size') {
             return true;
         }
+        if (key === 'mimeType') {
+            return true;
+        }
         if (key === 'name') {
             return true;
         }
@@ -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';
@@ -45,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 = {