@remotion/media-parser 4.0.270 → 4.0.271

package/dist/readers/from-fetch.js

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchReader = void 0;
-exports.parseContentRange = parseContentRange;
 /* eslint-disable eqeqeq */
 /* eslint-disable no-eq-null */
-const errors_1 = require("../errors");
-const get_body_and_reader_1 = require("./fetch/get-body-and-reader");
-const resolve_url_1 = require("./fetch/resolve-url");
+import { MediaParserAbortError } from '../errors';
+import { getLengthAndReader } from './fetch/get-body-and-reader';
+import { resolveUrl } from './fetch/resolve-url';
 /**
  * Parse Content-Range header.
  * From: https://github.com/gregberge/content-range/blob/main/src/index.ts
  */
-function parseContentRange(input) {
+export function parseContentRange(input) {
     const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
     if (!matches)
         return null;
@@ -27,101 +23,120 @@ function parseContentRange(input) {
     }
     return range;
 }
-const validateContentRangeAndDetectIfSupported = ({ actualRange, parsedContentRange, statusCode, }) => {
+const validateContentRangeAndDetectIfSupported = ({ requestedRange, parsedContentRange, statusCode, }) => {
     if (statusCode === 206) {
         return { supportsContentRange: true };
     }
-    if (typeof actualRange === 'number' &&
-        (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== actualRange) {
-        if (actualRange === 0) {
+    if (typeof requestedRange === 'number' &&
+        (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== requestedRange) {
+        if (requestedRange === 0) {
             return { supportsContentRange: false };
         }
-        throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+        throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
     }
-    if (actualRange !== null &&
-        typeof actualRange !== 'number' &&
-        ((parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== actualRange[0] ||
-            (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.end) !== actualRange[1])) {
-        throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
+    if (requestedRange !== null &&
+        typeof requestedRange !== 'number' &&
+        ((parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start) !== requestedRange[0] ||
+            (parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.end) !== requestedRange[1])) {
+        throw new Error(`Range header (${requestedRange}) does not match content-range header (${parsedContentRange === null || parsedContentRange === void 0 ? void 0 : parsedContentRange.start})`);
     }
     return { supportsContentRange: true };
 };
-exports.fetchReader = {
-    read: async ({ src, range, controller }) => {
-        var _a;
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `fetchReader`');
-        }
-        const resolvedUrl = (0, resolve_url_1.resolveUrl)(src);
-        const resolvedUrlString = resolvedUrl.toString();
-        if (!resolvedUrlString.startsWith('https://') &&
-            !resolvedUrlString.startsWith('blob:') &&
-            !resolvedUrlString.startsWith('http://')) {
-            return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
-        }
-        const ownController = new AbortController();
-        const cache = typeof navigator !== 'undefined' &&
-            navigator.userAgent.includes('Cloudflare-Workers')
-            ? undefined
-            : // Disable Next.js caching
-                'no-store';
-        const actualRange = range === null ? 0 : range;
-        const asString = typeof resolvedUrl === 'string' ? resolvedUrl : resolvedUrl.pathname;
-        const requestWithoutRange = asString.endsWith('.m3u8');
-        const canLiveWithoutContentLength = asString.endsWith('.m3u8') || asString.endsWith('.ts');
-        const headers = actualRange === 0 && requestWithoutRange
-            ? {}
-            : typeof actualRange === 'number'
-                ? {
-                    Range: `bytes=${actualRange}-`,
-                }
-                : {
-                    Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`,
-                };
-        const res = await fetch(resolvedUrl, {
-            headers,
-            signal: ownController.signal,
-            cache,
-        });
-        const contentRange = res.headers.get('content-range');
-        const parsedContentRange = contentRange
-            ? parseContentRange(contentRange)
-            : null;
-        const { supportsContentRange } = validateContentRangeAndDetectIfSupported({
-            actualRange,
-            parsedContentRange,
-            statusCode: res.status,
-        });
+export const fetchReadContent = async ({ src, range, controller, }) => {
+    var _a;
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const resolvedUrl = resolveUrl(src);
+    const resolvedUrlString = resolvedUrl.toString();
+    if (!resolvedUrlString.startsWith('https://') &&
+        !resolvedUrlString.startsWith('blob:') &&
+        !resolvedUrlString.startsWith('http://')) {
+        return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
+    }
+    const ownController = new AbortController();
+    const cache = typeof navigator !== 'undefined' &&
+        navigator.userAgent.includes('Cloudflare-Workers')
+        ? undefined
+        : // Disable Next.js caching
+            'no-store';
+    const requestedRange = range === null ? 0 : range;
+    const asString = typeof resolvedUrl === 'string' ? resolvedUrl : resolvedUrl.pathname;
+    const requestWithoutRange = asString.endsWith('.m3u8');
+    const canLiveWithoutContentLength = asString.endsWith('.m3u8') || asString.endsWith('.ts');
+    const headers = requestedRange === 0 && requestWithoutRange
+        ? {}
+        : typeof requestedRange === 'number'
+            ? {
+                Range: `bytes=${requestedRange}-`,
+            }
+            : {
+                Range: `bytes=${`${requestedRange[0]}-${requestedRange[1]}`}`,
+            };
+    const res = await fetch(resolvedUrl, {
+        headers,
+        signal: ownController.signal,
+        cache,
+    });
+    const contentRange = res.headers.get('content-range');
+    const parsedContentRange = contentRange
+        ? parseContentRange(contentRange)
+        : null;
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported({
+        requestedRange,
+        parsedContentRange,
+        statusCode: res.status,
+    });
+    controller._internals.signal.addEventListener('abort', () => {
+        ownController.abort(new MediaParserAbortError('Aborted by user'));
+    }, { once: true });
+    if (res.status.toString().startsWith('4') ||
+        res.status.toString().startsWith('5')) {
+        throw new Error(`Server returned status code ${res.status} for ${src} and range ${requestedRange}`);
+    }
+    const contentDisposition = res.headers.get('content-disposition');
+    const name = (_a = contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.match(/filename="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1];
+    const fallbackName = src.toString().split('/').pop();
+    const { contentLength, needsContentRange, reader } = await getLengthAndReader({
+        canLiveWithoutContentLength,
+        res,
+        ownController,
+        requestedWithoutRange: requestWithoutRange,
+    });
+    if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
-            ownController.abort(new errors_1.MediaParserAbortError('Aborted by user'));
+            reader.reader.cancel().catch(() => {
+                // Prevent unhandled rejection in Firefox
+            });
         }, { once: true });
-        if (res.status.toString().startsWith('4') ||
-            res.status.toString().startsWith('5')) {
-            throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
-        }
-        const contentDisposition = res.headers.get('content-disposition');
-        const name = (_a = contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.match(/filename="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1];
-        const fallbackName = src.split('/').pop();
-        const { contentLength, needsContentRange, reader } = await (0, get_body_and_reader_1.getLengthAndReader)({
-            canLiveWithoutContentLength,
-            res,
-            ownController,
-            requestedWithoutRange: requestWithoutRange,
-        });
-        if (controller) {
-            controller._internals.signal.addEventListener('abort', () => {
-                reader.reader.cancel().catch(() => {
-                    // Prevent unhandled rejection in Firefox
-                });
-            }, { once: true });
-        }
-        return {
-            reader,
-            contentLength,
-            contentType: res.headers.get('content-type'),
-            name: name !== null && name !== void 0 ? name : fallbackName,
-            supportsContentRange,
-            needsContentRange,
-        };
-    },
+    }
+    return {
+        reader,
+        contentLength,
+        contentType: res.headers.get('content-type'),
+        name: name !== null && name !== void 0 ? name : fallbackName,
+        supportsContentRange,
+        needsContentRange,
+    };
+};
+export const fetchReadWholeAsText = async (src) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string when using `fetchReader`');
+    }
+    const res = await fetch(src);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${src} (HTTP code: ${res.status})`);
+    }
+    return res.text();
+};
+export const fetchCreateAdjacentFileSource = (relativePath, src) => {
+    if (typeof src !== 'string' && src instanceof URL === false) {
+        throw new Error('src must be a string or URL when using `fetchReader`');
+    }
+    return new URL(relativePath, src).toString();
+};
+export const fetchReader = {
+    read: fetchReadContent,
+    readWholeAsText: fetchReadWholeAsText,
+    createAdjacentFileSource: fetchCreateAdjacentFileSource,
 };

package/dist/readers/from-node.d.ts

@@ -1,2 +1,5 @@
-import type { ReaderInterface } from './reader';
+import type { CreateAdjacentFileSource, ReadContent, ReadWholeAsText, ReaderInterface } from './reader';
+export declare const nodeReadContent: ReadContent;
+export declare const nodeReadWholeAsText: ReadWholeAsText;
+export declare const nodeCreateAdjacentFileSource: CreateAdjacentFileSource;
 export declare const nodeReader: ReaderInterface;

package/dist/readers/from-node.js

@@ -1,46 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeReader = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const stream_1 = require("stream");
-exports.nodeReader = {
-    read: ({ src, range, controller }) => {
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `nodeReader`');
-        }
-        const ownController = new AbortController();
-        const stream = (0, fs_1.createReadStream)(src, {
-            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
-            end: range === null
+import { createReadStream, promises, statSync } from 'fs';
+import { dirname, join, relative, sep } from 'path';
+import { Readable } from 'stream';
+export const nodeReadContent = ({ src, range, controller }) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    const ownController = new AbortController();
+    const stream = createReadStream(src, {
+        start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+        end: range === null
+            ? Infinity
+            : typeof range === 'number'
                 ? Infinity
-                : typeof range === 'number'
-                    ? Infinity
-                    : range[1],
-            signal: ownController.signal,
-        });
+                : range[1],
+        signal: ownController.signal,
+    });
+    controller._internals.signal.addEventListener('abort', () => {
+        ownController.abort();
+    }, { once: true });
+    const stats = statSync(src);
+    const reader = Readable.toWeb(stream).getReader();
+    if (controller) {
         controller._internals.signal.addEventListener('abort', () => {
-            ownController.abort();
+            reader.cancel().catch(() => { });
         }, { once: true });
-        const stats = (0, fs_1.statSync)(src);
-        const reader = stream_1.Readable.toWeb(stream).getReader();
-        if (controller) {
-            controller._internals.signal.addEventListener('abort', () => {
-                reader.cancel().catch(() => { });
-            }, { once: true });
-        }
-        return Promise.resolve({
-            reader: {
-                reader,
-                abort: () => {
-                    ownController.abort();
-                },
+    }
+    return Promise.resolve({
+        reader: {
+            reader,
+            abort: () => {
+                ownController.abort();
             },
-            contentLength: stats.size,
-            contentType: null,
-            name: src.split(path_1.sep).pop(),
-            supportsContentRange: true,
-            needsContentRange: true,
-        });
-    },
+        },
+        contentLength: stats.size,
+        contentType: null,
+        name: src.split(sep).pop(),
+        supportsContentRange: true,
+        needsContentRange: true,
+    });
+};
+export const nodeReadWholeAsText = (src) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    return promises.readFile(src, 'utf8');
+};
+export const nodeCreateAdjacentFileSource = (relativePath, src) => {
+    if (typeof src !== 'string') {
+        throw new Error('src must be a string when using `nodeReader`');
+    }
+    const result = join(dirname(src), relativePath);
+    const rel = relative(dirname(src), result);
+    if (rel.startsWith('..')) {
+        throw new Error('Path is outside of the parent directory - not allowing reading of arbitrary files');
+    }
+    return result;
+};
+export const nodeReader = {
+    read: nodeReadContent,
+    readWholeAsText: nodeReadWholeAsText,
+    createAdjacentFileSource: nodeCreateAdjacentFileSource,
 };

package/dist/readers/from-web-file.d.ts

@@ -1,2 +1,5 @@
-import type { ReaderInterface } from './reader';
+import type { CreateAdjacentFileSource, ReadContent, ReaderInterface, ReadWholeAsText } from './reader';
+export declare const webFileReadContent: ReadContent;
+export declare const webFileReadWholeAsText: ReadWholeAsText;
+export declare const webFileCreateAdjacentFileSource: CreateAdjacentFileSource;
 export declare const webFileReader: ReaderInterface;

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

@@ -1,51 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webFileReader = void 0;
-exports.webFileReader = {
-    read: ({ src, range, controller }) => {
-        if (typeof src === 'string') {
-            throw new Error('`inputTypeFileReader` only supports `File` objects');
-        }
-        const part = range === null
-            ? src
-            : typeof range === 'number'
-                ? src.slice(range)
-                : src.slice(range[0], range[1]);
-        const reader = new FileReader();
-        reader.readAsArrayBuffer(src);
-        const ownController = new AbortController();
-        if (ownController) {
-            ownController.signal.addEventListener('abort', () => {
-                reader.abort();
-            }, { once: true });
-        }
-        if (controller) {
-            controller._internals.signal.addEventListener('abort', () => {
-                ownController.abort();
-            }, { once: true });
-        }
-        return new Promise((resolve, reject) => {
-            reader.onload = () => {
-                const stream = part.stream();
-                const streamReader = stream.getReader();
-                resolve({
-                    reader: {
-                        reader: streamReader,
-                        abort() {
-                            streamReader.cancel();
-                            ownController.abort();
-                        },
+export const webFileReadContent = ({ src, range, controller }) => {
+    if (typeof src === 'string' || src instanceof URL) {
+        throw new Error('`inputTypeFileReader` only supports `File` objects');
+    }
+    const part = range === null
+        ? src
+        : typeof range === 'number'
+            ? src.slice(range)
+            : src.slice(range[0], range[1]);
+    const reader = new FileReader();
+    reader.readAsArrayBuffer(src);
+    const ownController = new AbortController();
+    if (ownController) {
+        ownController.signal.addEventListener('abort', () => {
+            reader.abort();
+        }, { once: true });
+    }
+    if (controller) {
+        controller._internals.signal.addEventListener('abort', () => {
+            ownController.abort();
+        }, { once: true });
+    }
+    return new Promise((resolve, reject) => {
+        reader.onload = () => {
+            const stream = part.stream();
+            const streamReader = stream.getReader();
+            resolve({
+                reader: {
+                    reader: streamReader,
+                    abort() {
+                        streamReader.cancel();
+                        ownController.abort();
                     },
-                    contentLength: src.size,
-                    name: src.name,
-                    supportsContentRange: true,
-                    contentType: src.type,
-                    needsContentRange: true,
-                });
-            };
-            reader.onerror = (error) => {
-                reject(error);
-            };
-        });
-    },
+                },
+                contentLength: src.size,
+                name: src.name,
+                supportsContentRange: true,
+                contentType: src.type,
+                needsContentRange: true,
+            });
+        };
+        reader.onerror = () => {
+            reject(reader.error);
+        };
+    });
+};
+export const webFileReadWholeAsText = () => {
+    throw new Error('`webFileReader` cannot read auxiliary files.');
+};
+export const webFileCreateAdjacentFileSource = () => {
+    throw new Error('`webFileReader` cannot create adjacent file sources.');
+};
+export const webFileReader = {
+    read: webFileReadContent,
+    readWholeAsText: webFileReadWholeAsText,
+    createAdjacentFileSource: webFileCreateAdjacentFileSource,
 };

package/dist/readers/reader.d.ts

@@ -12,12 +12,16 @@ type ReadResult = {
     supportsContentRange: boolean;
     needsContentRange: boolean;
 };
-type ReadContent = (options: {
+export type ReadContent = (options: {
     src: ParseMediaSrc;
     range: [number, number] | number | null;
     controller: MediaParserController;
 }) => Promise<ReadResult>;
+export type ReadWholeAsText = (src: ParseMediaSrc) => Promise<string>;
+export type CreateAdjacentFileSource = (relativePath: string, src: ParseMediaSrc) => string;
 export type ReaderInterface = {
     read: ReadContent;
+    readWholeAsText: ReadWholeAsText;
+    createAdjacentFileSource: CreateAdjacentFileSource;
 };
 export {};

package/dist/readers/reader.js

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

package/dist/readers/universal.d.ts

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

package/dist/readers/universal.js

@@ -0,0 +1,35 @@
+import { fetchCreateAdjacentFileSource, fetchReadContent, fetchReadWholeAsText, } from './from-fetch';
+import { nodeCreateAdjacentFileSource, nodeReadContent, nodeReadWholeAsText, } from './from-node';
+import { webFileCreateAdjacentFileSource, webFileReadContent, webFileReadWholeAsText, } from './from-web-file';
+export const universalReader = {
+    read: (params) => {
+        if (params.src instanceof Blob) {
+            return webFileReadContent(params);
+        }
+        if (params.src.toString().startsWith('http') ||
+            params.src.toString().startsWith('blob:')) {
+            return fetchReadContent(params);
+        }
+        return nodeReadContent(params);
+    },
+    readWholeAsText: (src) => {
+        if (src instanceof Blob) {
+            return webFileReadWholeAsText(src);
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return fetchReadWholeAsText(src);
+        }
+        return nodeReadWholeAsText(src);
+    },
+    createAdjacentFileSource: (relativePath, src) => {
+        if (src instanceof Blob) {
+            return webFileCreateAdjacentFileSource(relativePath, src);
+        }
+        if (src.toString().startsWith('http') ||
+            src.toString().startsWith('blob:')) {
+            return fetchCreateAdjacentFileSource(relativePath, src);
+        }
+        return nodeCreateAdjacentFileSource(relativePath, src);
+    },
+};

package/dist/readers/web.d.ts

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

package/dist/readers/web.js

@@ -0,0 +1,22 @@
+import { fetchCreateAdjacentFileSource, fetchReadContent, fetchReadWholeAsText, } from './from-fetch';
+import { webFileCreateAdjacentFileSource, webFileReadContent, webFileReadWholeAsText, } from './from-web-file';
+export const webReader = {
+    read: (params) => {
+        if (params.src instanceof Blob) {
+            return webFileReadContent(params);
+        }
+        return fetchReadContent(params);
+    },
+    createAdjacentFileSource: (relativePath, src) => {
+        if (src instanceof Blob) {
+            return webFileCreateAdjacentFileSource(relativePath, src);
+        }
+        return fetchCreateAdjacentFileSource(relativePath, src);
+    },
+    readWholeAsText: (src) => {
+        if (src instanceof Blob) {
+            return webFileReadWholeAsText(src);
+        }
+        return fetchReadWholeAsText(src);
+    },
+};

package/dist/register-track.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerVideoTrackWhenProfileIsAvailable = exports.registerAudioTrack = exports.registerVideoTrack = void 0;
-const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
-const log_1 = require("./log");
-const registerVideoTrack = async ({ state, track, container, }) => {
+import { addAvcProfileToTrack } from './add-avc-profile-to-track';
+import { Log } from './log';
+export const registerVideoTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
-        log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+        Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
     }
     if (track.type !== 'video') {
@@ -19,10 +16,9 @@ const registerVideoTrack = async ({ state, track, container, }) => {
     await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
     return callback;
 };
-exports.registerVideoTrack = registerVideoTrack;
-const registerAudioTrack = async ({ state, track, container, }) => {
+export const registerAudioTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
-        log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
+        Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
         return null;
     }
     if (track.type !== 'audio') {
@@ -36,14 +32,12 @@ const registerAudioTrack = async ({ state, track, container, }) => {
     await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
     return callback;
 };
-exports.registerAudioTrack = registerAudioTrack;
-const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
+export const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
     state.riff.registerOnAvcProfileCallback(async (profile) => {
-        await (0, exports.registerVideoTrack)({
+        await registerVideoTrack({
             state,
-            track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
+            track: addAvcProfileToTrack(track, profile),
             container,
         });
     });
 };
-exports.registerVideoTrackWhenProfileIsAvailable = registerVideoTrackWhenProfileIsAvailable;

package/dist/remotion-license-acknowledge.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnIfRemotionLicenseNotAcknowledged = void 0;
-const log_1 = require("./log");
+import { Log } from './log';
 let warningShown = false;
-const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicense, logLevel, apiName, }) => {
+export const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicense, logLevel, apiName, }) => {
     if (acknowledgeRemotionLicense) {
         return;
     }
@@ -11,7 +8,6 @@ const warnIfRemotionLicenseNotAcknowledged = ({ acknowledgeRemotionLicense, logL
         return;
     }
     warningShown = true;
-    log_1.Log.warn(logLevel, 'Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license');
-    log_1.Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
+    Log.warn(logLevel, 'Note: Some companies are required to obtain a license to use @remotion/media-parser. See: https://remotion.dev/license');
+    Log.warn(logLevel, `Pass \`acknowledgeRemotionLicense: true\` to \`${apiName}\` function to make this message disappear.`);
 };
-exports.warnIfRemotionLicenseNotAcknowledged = warnIfRemotionLicenseNotAcknowledged;