@remotion/media-parser 4.0.191

package/dist/buffer-iterator.js

@@ -0,0 +1,263 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OffsetCounter_offset, _OffsetCounter_discardedBytes;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+class OffsetCounter {
+    constructor(initial) {
+        _OffsetCounter_offset.set(this, void 0);
+        _OffsetCounter_discardedBytes.set(this, void 0);
+        __classPrivateFieldSet(this, _OffsetCounter_offset, initial, "f");
+        __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, 0, "f");
+    }
+    increment(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot increment by a negative amount: ' + amount);
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") + amount, "f");
+    }
+    getOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f");
+    }
+    getDiscardedOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f") - __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f");
+    }
+    discardBytes(amount) {
+        __classPrivateFieldSet(this, _OffsetCounter_discardedBytes, __classPrivateFieldGet(this, _OffsetCounter_discardedBytes, "f") + amount, "f");
+    }
+    decrement(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot decrement by a negative amount');
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") - amount, "f");
+    }
+}
+exports.OffsetCounter = OffsetCounter;
+_OffsetCounter_offset = new WeakMap(), _OffsetCounter_discardedBytes = new WeakMap();
+const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+const webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+const makeOffsetCounter = () => {
+    return new OffsetCounter(0);
+};
+const getArrayBufferIterator = (initialData) => {
+    let data = initialData;
+    let view = new DataView(data.buffer);
+    const counter = makeOffsetCounter();
+    const getSlice = (amount) => {
+        const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
+        counter.increment(amount);
+        return value;
+    };
+    const getUint8 = () => {
+        const val = view.getUint8(counter.getDiscardedOffset());
+        counter.increment(1);
+        return val;
+    };
+    const getFourByteNumber = () => {
+        return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
+    };
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getDiscardedOffset());
+        counter.increment(4);
+        return val;
+    };
+    const addData = (newData) => {
+        const newArray = new Uint8Array(data.buffer.byteLength + newData.byteLength);
+        newArray.set(data);
+        newArray.set(new Uint8Array(newData), data.byteLength);
+        data = newArray;
+        view = new DataView(data.buffer);
+    };
+    const byteLength = () => {
+        return data.byteLength;
+    };
+    const bytesRemaining = () => {
+        return data.byteLength - counter.getDiscardedOffset();
+    };
+    const isIsoBaseMedia = () => {
+        return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+    };
+    const isWebm = () => {
+        return matchesPattern(webmPattern)(data.subarray(0, 4));
+    };
+    const removeBytesRead = () => {
+        const bytesToRemove = counter.getDiscardedOffset();
+        counter.discardBytes(bytesToRemove);
+        const newArray = new Uint8Array(data.buffer.byteLength - bytesToRemove);
+        newArray.set(data.slice(bytesToRemove));
+        data = newArray;
+        view = new DataView(data.buffer);
+    };
+    return {
+        addData,
+        counter,
+        byteLength,
+        bytesRemaining,
+        isIsoBaseMedia,
+        discardFirstBytes: removeBytesRead,
+        isWebm,
+        discard: (length) => {
+            counter.increment(length);
+        },
+        getFourByteNumber,
+        getSlice,
+        getAtom: () => {
+            const atom = getSlice(4);
+            return new TextDecoder().decode(atom);
+        },
+        getMatroskaSegmentId: () => {
+            const first = getSlice(1);
+            const firstOneString = `0x${Array.from(new Uint8Array(first))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            // Catch void block
+            // https://www.matroska.org/technical/elements.html
+            const knownIdsWithOneLength = [
+                '0xec',
+                '0xae',
+                '0xd7',
+                '0x9c',
+                '0x86',
+                '0x83',
+                '0xe0',
+                '0xb0',
+                '0xba',
+            ];
+            if (knownIdsWithOneLength.includes(firstOneString)) {
+                return firstOneString;
+            }
+            const firstTwo = getSlice(1);
+            const knownIdsWithTwoLength = [
+                '0x4dbb',
+                '0x53ac',
+                '0xec01',
+                '0x73c5',
+                '0x53c0',
+                '0x4d80',
+                '0x5741',
+                '0x4489',
+                '0x55ee',
+                '0x55b0',
+            ];
+            const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+                return firstTwoString;
+            }
+            const knownIdsWithThreeLength = [
+                '0x4d808c',
+                '0x57418c',
+                '0x448988',
+                '0x22b59c',
+                '0x23e383',
+            ];
+            const firstThree = getSlice(1);
+            const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithThreeLength.includes(firstThreeString)) {
+                return firstThreeString;
+            }
+            const segmentId = getSlice(1);
+            return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+        },
+        getVint: () => {
+            const firstByte = getUint8();
+            const totalLength = firstByte;
+            if (totalLength === 0) {
+                return 0;
+            }
+            // Calculate the actual length of the data based on the first set bit
+            let actualLength = 0;
+            while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
+                actualLength++;
+            }
+            const slice = getSlice(actualLength);
+            const d = [firstByte, ...Array.from(new Uint8Array(slice))];
+            actualLength += 1; // Include the first byte set as 1
+            // Combine the numbers to form the integer value
+            let value = 0;
+            // Mask the first byte properly then start combining
+            value = totalLength & (0xff >> actualLength);
+            for (let i = 1; i < actualLength; i++) {
+                value = (value << 8) | d[i];
+            }
+            return value;
+        },
+        getUint8,
+        getEBML: () => {
+            const val = getUint8();
+            // https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
+            // You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
+            const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
+            return actualValue;
+        },
+        getInt8: () => {
+            const val = view.getInt8(counter.getDiscardedOffset());
+            counter.increment(1);
+            return val;
+        },
+        getUint16: () => {
+            const val = view.getUint16(counter.getDiscardedOffset());
+            counter.increment(2);
+            return val;
+        },
+        getInt16: () => {
+            const val = view.getInt16(counter.getDiscardedOffset());
+            counter.increment(2);
+            return val;
+        },
+        getUint32,
+        // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
+        // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
+        getFixedPoint1616Number: () => {
+            const val = getUint32();
+            return val / 2 ** 16;
+        },
+        getPascalString: () => {
+            const val = getSlice(32);
+            return [...Array.from(new Uint8Array(val))];
+        },
+        getDecimalBytes(length) {
+            const bytes = getSlice(length);
+            const numbers = [...Array.from(new Uint8Array(bytes))];
+            return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
+        },
+        getByteString(length) {
+            const bytes = getSlice(length);
+            return new TextDecoder().decode(bytes).trim();
+        },
+        getFloat64: () => {
+            const val = view.getFloat64(counter.getDiscardedOffset());
+            counter.increment(8);
+            return val;
+        },
+    };
+};
+exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/from-node.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const nodeReader: ReaderInterface;

package/dist/from-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const stream_1 = require("stream");
+exports.nodeReader = {
+    read: (src, range) => {
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : range[0],
+            end: range === null ? Infinity : range[1],
+        });
+        return Promise.resolve(stream_1.Readable.toWeb(stream).getReader());
+    },
+    getLength: async (src) => {
+        const stats = await (0, promises_1.stat)(src);
+        return stats.size;
+    },
+};

package/dist/from-web.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const webReader: ReaderInterface;

package/dist/from-web.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webReader = void 0;
+exports.webReader = {
+    read: async (src, range) => {
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin).toString()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !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 `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : {
+                    Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                },
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const reader = res.body.getReader();
+        return reader;
+    },
+    getLength: async (src) => {
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/get-dimensions.d.ts

@@ -0,0 +1,7 @@
+import type { AnySegment } from './parse-result';
+export type Dimensions = {
+    width: number;
+    height: number;
+};
+export declare const getDimensions: (boxes: AnySegment[]) => Dimensions;
+export declare const hasDimensions: (boxes: AnySegment[]) => boolean;

package/dist/get-dimensions.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDimensions = exports.getDimensions = void 0;
+const getDimensionsFromMatroska = (segments) => {
+    const tracksSegment = segments.children.find((b) => b.type === 'tracks-segment');
+    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+        throw new Error('No tracks segment');
+    }
+    // TODO: What if there are multiple video tracks, or audio track is first?
+    const trackEntrySegment = tracksSegment.children.find((b) => b.type === 'track-entry-segment');
+    if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
+        throw new Error('No track entry segment');
+    }
+    const videoSegment = trackEntrySegment.children.find((b) => b.type === 'video-segment');
+    if (!videoSegment || videoSegment.type !== 'video-segment') {
+        throw new Error('No video segment');
+    }
+    const widthSegment = videoSegment.children.find((b) => b.type === 'width-segment');
+    if (!widthSegment || widthSegment.type !== 'width-segment') {
+        throw new Error('No width segment');
+    }
+    const heightSegment = videoSegment.children.find((b) => b.type === 'height-segment');
+    if (!heightSegment || heightSegment.type !== 'height-segment') {
+        throw new Error('No height segment');
+    }
+    return {
+        width: widthSegment.width,
+        height: heightSegment.height,
+    };
+};
+const getDimensions = (boxes) => {
+    const matroskaBox = boxes.find((b) => b.type === 'main-segment');
+    if (matroskaBox && matroskaBox.type === 'main-segment') {
+        return getDimensionsFromMatroska(matroskaBox);
+    }
+    const moovBox = boxes.find((b) => b.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        throw new Error('Expected moov box');
+    }
+    const { children } = moovBox;
+    if (!children) {
+        throw new Error('Expected moov box children');
+    }
+    const t = children.find((b) => b.type === 'trak-box');
+    if (!t || t.type !== 'trak-box') {
+        throw new Error('Expected trak box');
+    }
+    const mdiaBox = t.children.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    const tkhdBox = t.children.find((c) => c.type === 'tkhd-box');
+    if (tkhdBox && tkhdBox.type === 'tkhd-box') {
+        return {
+            width: tkhdBox.width,
+            height: tkhdBox.height,
+        };
+    }
+    if (!mdiaBox) {
+        throw new Error('Expected mdia box');
+    }
+    if (mdiaBox.type !== 'regular-box') {
+        throw new Error('Expected mdia box');
+    }
+    const minfBox = mdiaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
+    if (!minfBox) {
+        throw new Error('Expected minf box');
+    }
+    if (minfBox.type !== 'regular-box') {
+        throw new Error('Expected minf box');
+    }
+    const stblBox = minfBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
+    if (!stblBox) {
+        throw new Error('Expected stbl box');
+    }
+    if (stblBox.type !== 'regular-box') {
+        throw new Error('Expected stbl box');
+    }
+    const stsdBox = stblBox.children.find((c) => c.type === 'stsd-box');
+    if (!stsdBox) {
+        throw new Error('Expected stsd box');
+    }
+    if (stsdBox.type !== 'stsd-box') {
+        throw new Error('Expected stsd box');
+    }
+    const videoSamples = stsdBox.samples.filter((s) => s.type === 'video');
+    if (videoSamples.length === 0) {
+        throw new Error('Has no video stream');
+    }
+    const [firstTrack] = videoSamples;
+    if (firstTrack.type !== 'video') {
+        throw new Error('Expected video track');
+    }
+    return { width: firstTrack.width, height: firstTrack.height };
+};
+exports.getDimensions = getDimensions;
+// TODO: An audio track should return 'hasDimensions' = true on an audio file
+// and stop parsing
+const hasDimensions = (boxes) => {
+    try {
+        return (0, exports.getDimensions)(boxes) !== null;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasDimensions = hasDimensions;

package/dist/get-duration.d.ts

@@ -0,0 +1,3 @@
+import type { AnySegment } from './parse-result';
+export declare const getDuration: (boxes: AnySegment[]) => number | null;
+export declare const hasDuration: (boxes: AnySegment[]) => boolean;

package/dist/get-duration.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDuration = exports.getDuration = void 0;
+const getDurationFromMatroska = (segments) => {
+    const mainSegment = segments.find((s) => s.type === 'main-segment');
+    if (!mainSegment || mainSegment.type !== 'main-segment') {
+        return null;
+    }
+    const { children } = mainSegment;
+    if (!children) {
+        return null;
+    }
+    const infoSegment = children.find((s) => s.type === 'info-segment');
+    const relevantBoxes = [
+        ...mainSegment.children,
+        ...(infoSegment && infoSegment.type === 'info-segment'
+            ? infoSegment.children
+            : []),
+    ];
+    const timestampScale = relevantBoxes.find((s) => s.type === 'timestamp-scale-segment');
+    if (!timestampScale || timestampScale.type !== 'timestamp-scale-segment') {
+        return null;
+    }
+    const duration = relevantBoxes.find((s) => s.type === 'duration-segment');
+    if (!duration || duration.type !== 'duration-segment') {
+        return null;
+    }
+    return (duration.duration / timestampScale.timestampScale) * 1000;
+};
+const getDuration = (boxes) => {
+    const matroskaBox = boxes.find((b) => b.type === 'main-segment');
+    if (matroskaBox) {
+        return getDurationFromMatroska(boxes);
+    }
+    const moovBox = boxes.find((b) => b.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        return null;
+    }
+    const { children } = moovBox;
+    if (!children) {
+        return null;
+    }
+    const mvhdBox = children.find((b) => b.type === 'mvhd-box');
+    if (!mvhdBox) {
+        return null;
+    }
+    if (mvhdBox.type !== 'mvhd-box') {
+        throw new Error('Expected mvhd-box');
+    }
+    return mvhdBox.durationInSeconds;
+};
+exports.getDuration = getDuration;
+const hasDuration = (boxes) => {
+    try {
+        return (0, exports.getDuration)(boxes) !== null;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasDuration = hasDuration;

package/dist/get-fps.d.ts

@@ -0,0 +1,3 @@
+import type { AnySegment } from './parse-result';
+export declare const getFps: (segments: AnySegment[]) => number | null;
+export declare const hasFps: (boxes: AnySegment[]) => boolean;

package/dist/get-fps.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFps = exports.getFps = void 0;
+const calculateFps = (sttsBox, timeScale) => {
+    let sum = 0;
+    let totalSamples = 0;
+    for (const sample of sttsBox.sampleDistribution) {
+        sum += sample.sampleCount * sample.sampleDelta;
+        totalSamples += sample.sampleCount;
+    }
+    return timeScale / (sum / totalSamples);
+};
+const getFps = (segments) => {
+    const moovBox = segments.find((s) => s.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        return null;
+    }
+    const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
+    if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
+        return null;
+    }
+    const { timeScale } = mvhdBox;
+    const { children } = moovBox;
+    const trackBoxes = children.filter((c) => c.type === 'trak-box');
+    if (!trackBoxes || trackBoxes.length === 0) {
+        return null;
+    }
+    // TODO: What if the video track is not the first track?
+    const trackBox = trackBoxes[0];
+    if (!trackBox || trackBox.type !== 'trak-box') {
+        return null;
+    }
+    const trackBoxChildren = trackBox.children;
+    if (!trackBoxChildren || trackBoxChildren.length === 0) {
+        return null;
+    }
+    const mdiaBox = trackBoxChildren.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    if (!mdiaBox ||
+        mdiaBox.type !== 'regular-box' ||
+        mdiaBox.boxType !== 'mdia') {
+        return null;
+    }
+    const minfBox = mdiaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
+    if (!minfBox ||
+        minfBox.type !== 'regular-box' ||
+        minfBox.boxType !== 'minf') {
+        return null;
+    }
+    const stblBox = minfBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
+    if (!stblBox ||
+        stblBox.type !== 'regular-box' ||
+        stblBox.boxType !== 'stbl') {
+        return null;
+    }
+    const sttsBox = stblBox.children.find((c) => c.type === 'stts-box');
+    if (!sttsBox || sttsBox.type !== 'stts-box') {
+        return null;
+    }
+    return calculateFps(sttsBox, timeScale);
+};
+exports.getFps = getFps;
+const hasFps = (boxes) => {
+    try {
+        return (0, exports.getFps)(boxes) !== null;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasFps = hasFps;

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

@@ -0,0 +1,3 @@
+import type { Options } from './options';
+import type { ParseResult } from './parse-result';
+export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;

package/dist/has-all-info.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllInfo = void 0;
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const hasAllInfo = (options, parseResult) => {
+    const keys = Object.entries(options)
+        .filter(([, value]) => value)
+        .map(([key]) => key);
+    return keys.every((key) => {
+        if (key === 'boxes') {
+            return parseResult.status === 'done';
+        }
+        if (key === 'durationInSeconds') {
+            return (0, get_duration_1.hasDuration)(parseResult.segments);
+        }
+        if (key === 'dimensions') {
+            return (0, get_dimensions_1.hasDimensions)(parseResult.segments);
+        }
+        if (key === 'fps') {
+            return (0, get_fps_1.hasFps)(parseResult.segments) !== null;
+        }
+        throw new Error(`Unknown key: ${key}`);
+    });
+};
+exports.hasAllInfo = hasAllInfo;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { parseMedia } from './parse-media';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+var parse_media_1 = require("./parse-media");
+Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });

package/dist/options.d.ts

@@ -0,0 +1,19 @@
+import type { Dimensions } from './get-dimensions';
+import type { AnySegment } from './parse-result';
+import type { ReaderInterface } from './reader';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean> = {
+    dimensions?: EnableDimensions;
+    durationInSeconds?: EnableDuration;
+    boxes?: EnableBoxes;
+    fps?: EnableFps;
+};
+export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean> = (EnableDimensions extends true ? {
+    dimensions: Dimensions;
+} : {}) & (EnableDuration extends true ? {
+    durationInSeconds: number | null;
+} : {}) & (EnableBoxes extends true ? {
+    boxes: AnySegment[];
+} : {}) & (EnableFps extends true ? {
+    fps: number | null;
+} : {});
+export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>>;

package/dist/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parse-media.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMedia } from './options';
+export declare const parseMedia: ParseMedia;