@remotion/renderer 3.1.6 → 3.1.7

package/dist/compress-assets.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Since audio or video can be base64-encoded, those can be really long strings.
+ * Since we track the `src` property for every frame, Node.JS can run out of memory easily. Instead of duplicating the src for every frame, we save memory by replacing the full base 64 encoded data with a string `same-as-[asset-id]-[frame]` referencing a previous asset with the same src.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetCompressed = exports.compressAsset = void 0;
+const compressAsset = (previousAssets, newAsset) => {
+    if (newAsset.src.length < 400) {
+        return newAsset;
+    }
+    const assetWithSameSrc = previousAssets.find((a) => a.src === newAsset.src);
+    if (!assetWithSameSrc) {
+        return newAsset;
+    }
+    return {
+        ...newAsset,
+        src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`,
+    };
+};
+exports.compressAsset = compressAsset;
+const isAssetCompressed = (src) => {
+    return src.startsWith('same-as');
+};
+exports.isAssetCompressed = isAssetCompressed;

package/dist/convert-to-pcm.d.ts

@@ -1,4 +1,4 @@
-import type { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const convertToPcm: ({ ffmpegExecutable, input, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     input: string;

package/dist/create-ffmpeg-merge-filter.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegMergeFilter = void 0;
-const remotion_1 = require("remotion");
+const truthy_1 = require("./truthy");
 const createFfmpegMergeFilter = (inputs) => {
     const leftChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 0 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     const rightChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
 };

package/dist/create-silent-audio.d.ts

@@ -1,4 +1,4 @@
-import type { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;

package/dist/crf.d.ts

@@ -0,0 +1,5 @@
+import type { Codec } from './codec';
+export declare type Crf = number | undefined;
+export declare const getDefaultCrfForCodec: (codec: Codec) => number;
+export declare const getValidCrfRanges: (codec: Codec) => [number, number];
+export declare const validateSelectedCrfAndCodecCombination: (crf: unknown, codec: Codec) => void;

package/dist/crf.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedCrfAndCodecCombination = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+const is_audio_codec_1 = require("./is-audio-codec");
+const getDefaultCrfForCodec = (codec) => {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        return 0;
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return 18; // FFMPEG default 23
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return 23; // FFMPEG default 28
+    }
+    if (codec === 'vp8') {
+        return 9; // FFMPEG default 10
+    }
+    if (codec === 'vp9') {
+        return 28; // FFMPEG recommendation 31
+    }
+    if (codec === 'prores') {
+        return 0;
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
+const getValidCrfRanges = (codec) => {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        return [0, 0];
+    }
+    if (codec === 'prores') {
+        return [0, 0];
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return [1, 51];
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return [0, 51];
+    }
+    if (codec === 'vp8') {
+        return [4, 63];
+    }
+    if (codec === 'vp9') {
+        return [0, 63];
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getValidCrfRanges = getValidCrfRanges;
+const validateSelectedCrfAndCodecCombination = (crf, codec) => {
+    if (crf === null) {
+        return;
+    }
+    if (typeof crf !== 'number') {
+        throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
+    }
+    const range = (0, exports.getValidCrfRanges)(codec);
+    if (crf === 0 && (codec === 'h264' || codec === 'h264-mkv')) {
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably want. Set CRF to a higher value to fix this error.");
+    }
+    if (crf < range[0] || crf > range[1]) {
+        throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
+    }
+};
+exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;

package/dist/ensure-presentation-timestamp.d.ts

@@ -1 +1,2 @@
-export declare const ensurePresentationTimestamps: (src: string) => Promise<string>;
+import type { DownloadMap } from './assets/download-map';
+export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -6,9 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensurePresentationTimestamps = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
-const remotion_1 = require("remotion");
 const guess_extension_for_media_1 = require("./guess-extension-for-media");
-const ensureFileHasPresentationTimestamp = {};
+const truthy_1 = require("./truthy");
 let callbacks = [];
 const getTemporaryOutputName = async (src) => {
     const parts = src.split(path_1.default.sep);
@@ -20,14 +19,14 @@ const getTemporaryOutputName = async (src) => {
     return parts
         .map((p, i) => {
         if (i === parts.length - 1) {
-            return [`pts-${p}`, extraExtension].filter(remotion_1.Internals.truthy).join('.');
+            return [`pts-${p}`, extraExtension].filter(truthy_1.truthy).join('.');
         }
         return p;
     })
         .join(path_1.default.sep);
 };
-const ensurePresentationTimestamps = async (src) => {
-    const elem = ensureFileHasPresentationTimestamp[src];
+const ensurePresentationTimestamps = async (downloadMap, src) => {
+    const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
         return new Promise((resolve) => {
             callbacks.push({
@@ -39,7 +38,7 @@ const ensurePresentationTimestamps = async (src) => {
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'done') {
         return elem.src;
     }
-    ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
+    downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
     // If there is no file extension for the video, then we need to tempoa
     const output = await getTemporaryOutputName(src);
     await (0, execa_1.default)('ffmpeg', [
@@ -61,7 +60,10 @@ const ensurePresentationTimestamps = async (src) => {
         }
         return true;
     });
-    ensureFileHasPresentationTimestamp[src] = { type: 'done', src: output };
+    downloadMap.ensureFileHasPresentationTimestamp[src] = {
+        type: 'done',
+        src: output,
+    };
     return output;
 };
 exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

package/dist/extract-frame-from-video.d.ts

@@ -1,4 +1,7 @@
-import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
+/// <reference types="node" />
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { LastFrameOptions } from './last-frame-from-video-cache';
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
@@ -7,6 +10,7 @@ declare type Options = {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
     imageFormat: OffthreadVideoImageFormat;
+    downloadMap: DownloadMap;
 };
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

package/dist/extract-frame-from-video.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
 const execa_1 = __importDefault(require("execa"));
-const remotion_1 = require("remotion");
 const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
 const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
@@ -13,6 +12,8 @@ const get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
+const perf_1 = require("./perf");
+const truthy_1 = require("./truthy");
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
 const determineVcodecFfmepgFlags = (vcodecFlag) => {
@@ -21,7 +22,7 @@ const determineVcodecFfmepgFlags = (vcodecFlag) => {
         vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
         vcodecFlag === 'vp8' ? '-vcodec' : null,
         vcodecFlag === 'vp8' ? 'libvpx' : null,
-    ].filter(remotion_1.Internals.truthy);
+    ].filter(truthy_1.truthy);
 };
 const determineResizeParams = (needsResize) => {
     if (needsResize === null) {
@@ -48,7 +49,7 @@ const getFrameOfVideoSlow = async ({ src, timestamp, ffmpegExecutable, imageForm
         'image2pipe',
         ...determineResizeParams(needsResize),
         '-',
-    ].filter(remotion_1.Internals.truthy);
+    ].filter(truthy_1.truthy);
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
@@ -76,12 +77,12 @@ const getFrameOfVideoSlow = async ({ src, timestamp, ffmpegExecutable, imageForm
     return stdoutBuffer;
 };
 const getLastFrameOfVideoFastUnlimited = async (options) => {
-    const { ffmpegExecutable, ffprobeExecutable, offset, src } = options;
+    const { ffmpegExecutable, ffprobeExecutable, offset, src, downloadMap } = options;
     const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
     if (fromCache) {
         return fromCache;
     }
-    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(src, ffprobeExecutable);
+    const { duration, fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable);
     if (duration === null) {
         throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
     }
@@ -96,7 +97,7 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
         });
         return last;
     }
-    const actualOffset = `${duration * 1000 - offset - 10}ms`;
+    const actualOffset = `${duration * 1000 - offset}ms`;
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
         actualOffset,
@@ -111,7 +112,7 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
         'image2pipe',
         ...determineResizeParams(options.needsResize),
         '-',
-    ].filter(remotion_1.Internals.truthy));
+    ].filter(truthy_1.truthy));
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
     }
@@ -141,12 +142,14 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     if (isEmpty) {
         const unlimited = await getLastFrameOfVideoFastUnlimited({
             ffmpegExecutable,
-            offset: offset + 10,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + 1000 / (fps === null ? 10 : fps),
             src,
             ffprobeExecutable,
             imageFormat: options.imageFormat,
             specialVCodecForTransparency: options.specialVCodecForTransparency,
             needsResize: options.needsResize,
+            downloadMap: options.downloadMap,
         });
         return unlimited;
     }
@@ -158,11 +161,11 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, ...options }) => {
+const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, downloadMap, ...options }) => {
     // We make a new copy of the video only for video because the conversion may affect
     // audio rendering, so we work with 2 different files
-    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(options.src);
-    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(src, ffprobeExecutable);
+    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(downloadMap, options.src);
+    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable);
     if (specialVcodec === 'vp8') {
         return getFrameOfVideoSlow({
             ffmpegExecutable,
@@ -173,7 +176,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             needsResize,
         });
     }
-    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
         const lastFrame = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
@@ -182,6 +185,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
             needsResize,
+            downloadMap,
         });
         return lastFrame;
     }
@@ -200,7 +204,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
         imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         ...determineResizeParams(needsResize),
         '-',
-    ].filter(remotion_1.Internals.truthy), {
+    ].filter(truthy_1.truthy), {
         buffer: false,
     });
     if (!stderr) {
@@ -226,7 +230,7 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
         stdoutBuffer,
     ]);
     if (stderrStr.includes('Output file is empty')) {
-        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(src, time);
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(downloadMap, src, time);
         const last = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
@@ -235,15 +239,16 @@ const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutab
             imageFormat,
             specialVCodecForTransparency: specialVcodec,
             needsResize,
+            downloadMap,
         });
         return last;
     }
     return stdOut;
 };
 const extractFrameFromVideo = async (options) => {
-    const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
+    const perf = (0, perf_1.startPerfMeasure)('extract-frame');
     const res = await mainLimit(extractFrameFromVideoFn, options);
-    remotion_1.Internals.perf.stopPerfMeasure(perf);
+    (0, perf_1.stopPerfMeasure)(perf);
     return res;
 };
 exports.extractFrameFromVideo = extractFrameFromVideo;

package/dist/ffmpeg-executable.d.ts

@@ -0,0 +1 @@
+export declare type FfmpegExecutable = string | null;

package/dist/ffmpeg-executable.js

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

package/dist/frame-range.d.ts

@@ -0,0 +1,2 @@
+export declare type FrameRange = number | [number, number];
+export declare const validateFrameRange: (frameRange: FrameRange | null) => void;

package/dist/frame-range.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFrameRange = void 0;
+const validateFrameRange = (frameRange) => {
+    if (frameRange === null) {
+        return;
+    }
+    if (typeof frameRange === 'number') {
+        if (frameRange < 0) {
+            throw new TypeError('Frame must be a non-negative number, got ' + frameRange);
+        }
+        if (!Number.isFinite(frameRange)) {
+            throw new TypeError('Frame must be a finite number, got ' + frameRange);
+        }
+        if (!Number.isInteger(frameRange)) {
+            throw new Error(`Frame must be an integer, but got a float (${frameRange})`);
+        }
+        return;
+    }
+    if (Array.isArray(frameRange)) {
+        if (frameRange.length !== 2) {
+            throw new TypeError('Frame range must be a tuple, got an array with length ' +
+                frameRange.length);
+        }
+        for (const value of frameRange) {
+            if (typeof value !== 'number') {
+                throw new Error(`Each value of frame range must be a number, but got ${typeof value} (${JSON.stringify(value)})`);
+            }
+            if (!Number.isFinite(value)) {
+                throw new TypeError('Each value of frame range must be finite, but got ' + value);
+            }
+            if (!Number.isInteger(value)) {
+                throw new Error(`Each value of frame range must be an integer, but got a float (${value})`);
+            }
+            if (value < 0) {
+                throw new Error(`Each value of frame range must be non-negative, but got ${value}`);
+            }
+        }
+        const [first, second] = frameRange;
+        if (second < first) {
+            throw new Error('The second value of frame range must be not smaller than the first one, but got ' +
+                frameRange.join('-'));
+        }
+        return;
+    }
+    throw new TypeError('Frame range must be a number or a tuple of numbers, but got object of type ' +
+        typeof frameRange);
+};
+exports.validateFrameRange = validateFrameRange;

package/dist/get-audio-codec-name.d.ts

@@ -1,2 +1,2 @@
-import type { Codec } from 'remotion';
+import type { Codec } from './codec';
 export declare const getAudioCodecName: (codec: Codec) => string | null;

package/dist/get-audio-codec-name.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioCodecName = void 0;
-const remotion_1 = require("remotion");
+const is_audio_codec_1 = require("./is-audio-codec");
 const getAudioCodecName = (codec) => {
-    if (!remotion_1.Internals.isAudioCodec(codec)) {
+    if (!(0, is_audio_codec_1.isAudioCodec)(codec)) {
         // The mkv container supports WAV, but MP4 does only support
         // AAC. Choose MKV codec for better quality because we can put in lossless audio
         if (codec === 'h264-mkv') {

package/dist/get-browser-instance.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserExecutable } from 'remotion';
+import type { BrowserExecutable } from './browser-executable';
 import type { Browser } from './browser/Browser';
 import type { Page } from './browser/BrowserPage';
 import type { ChromiumOptions } from './open-browser';

package/dist/get-browser-instance.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageAndCleanupFn = void 0;
-const remotion_1 = require("remotion");
+const browser_1 = require("./browser");
 const open_browser_1 = require("./open-browser");
 const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, }) => {
     if (passedInInstance) {
@@ -17,7 +17,7 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
             },
         };
     }
-    const browserInstance = await (0, open_browser_1.openBrowser)(remotion_1.Internals.DEFAULT_BROWSER, {
+    const browserInstance = await (0, open_browser_1.openBrowser)(browser_1.DEFAULT_BROWSER, {
         browserExecutable,
         chromiumOptions,
     });

package/dist/get-codec-name.d.ts

@@ -1,2 +1,2 @@
-import type { Codec } from 'remotion';
+import type { Codec } from './codec';
 export declare const getCodecName: (codec: Codec) => string | null;

package/dist/get-codec-name.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCodecName = void 0;
-const remotion_1 = require("remotion");
+const is_audio_codec_1 = require("./is-audio-codec");
 const getCodecName = (codec) => {
-    if (remotion_1.Internals.isAudioCodec(codec)) {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
         return null;
     }
     if (codec === 'h264' || codec === 'h264-mkv') {

package/dist/get-compositions.d.ts

@@ -1,6 +1,9 @@
-import type { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
+import type { TCompMetadata } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { Browser } from './browser/Browser';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;
@@ -13,6 +16,10 @@ declare type GetCompositionsConfig = {
     ffmpegExecutable?: FfmpegExecutable;
     ffprobeExecutable?: FfmpegExecutable;
     port?: number | null;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    downloadMap?: DownloadMap;
 };
 export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompositions = void 0;
+const download_map_1 = require("./assets/download-map");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
 const get_browser_instance_1 = require("./get-browser-instance");
-const make_assets_download_dir_1 = require("./make-assets-download-dir");
 const prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const set_props_and_env_1 = require("./set-props-and-env");
@@ -52,12 +52,12 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     return result;
 };
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b;
-    const downloadDir = (0, make_assets_download_dir_1.makeAssetsDownloadTmpDir)();
+    var _a, _b, _c;
+    const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
     const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
         passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_a = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _a !== void 0 ? _a : null,
-        chromiumOptions: (_b = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _b !== void 0 ? _b : {},
+        browserExecutable: (_b = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _b !== void 0 ? _b : null,
+        chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
     });
     return new Promise((resolve, reject) => {
         var _a, _b, _c;
@@ -70,12 +70,12 @@ const getCompositions = async (serveUrlOrWebpackUrl, config) => {
         let close = null;
         (0, prepare_server_1.prepareServer)({
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
-            downloadDir,
             onDownload: () => undefined,
             onError,
             ffmpegExecutable: (_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
             ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
             port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
+            downloadMap,
         })
             .then(({ serveUrl, closeServer, offthreadPort }) => {
             close = closeServer;

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,2 @@
-import type { Codec } from 'remotion';
+import type { Codec } from './codec';
 export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";

package/dist/get-frame-to-render.d.ts

@@ -1,2 +1,2 @@
-import type { FrameRange } from 'remotion';
+import type { FrameRange } from './frame-range';
 export declare const getRealFrameRange: (durationInFrames: number, frameRange: FrameRange | null) => [number, number];

package/dist/get-local-browser-executable.d.ts

@@ -1,3 +1,4 @@
-import type { Browser, BrowserExecutable } from 'remotion';
+import type { Browser } from './browser';
+import type { BrowserExecutable } from './browser-executable';
 export declare const ensureLocalBrowser: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => Promise<void>;
 export declare const getLocalBrowserExecutable: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => string;

package/dist/get-prores-profile-name.d.ts

@@ -1,2 +1,3 @@
-import type { Codec, ProResProfile } from 'remotion';
+import type { Codec } from './codec';
+import type { ProResProfile } from './prores-profile';
 export declare const getProResProfileName: (codec: Codec, proResProfile: ProResProfile | undefined) => string | null;

package/dist/get-video-info.d.ts

@@ -1,8 +1,3 @@
-import type { FfmpegExecutable } from 'remotion';
-declare type Result = {
-    specialVcodec: SpecialVCodecForTransparency;
-    needsResize: [number, number] | null;
-};
-export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
-export declare const getVideoInfo: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
-export {};
+import type { DownloadMap, Vp9Result } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -7,12 +7,11 @@ exports.getVideoInfo = void 0;
 const execa_1 = __importDefault(require("execa"));
 const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
 const p_limit_1 = require("./p-limit");
-const isVp9VideoCache = {};
 const limit = (0, p_limit_1.pLimit)(1);
-async function getVideoInfoUnlimited(src, ffprobeExecutable) {
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable) {
     var _a;
-    if (typeof isVp9VideoCache[src] !== 'undefined') {
-        return isVp9VideoCache[src];
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
     }
     const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [src]);
     const isVp9 = task.stderr.includes('Video: vp9');
@@ -41,10 +40,10 @@ async function getVideoInfoUnlimited(src, ffprobeExecutable) {
         specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
         needsResize,
     };
-    isVp9VideoCache[src] = result;
-    return isVp9VideoCache[src];
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
 }
-const getVideoInfo = (src, ffprobeExecutable) => {
-    return limit(() => getVideoInfoUnlimited(src, ffprobeExecutable));
+const getVideoInfo = (downloadMap, src, ffprobeExecutable) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable));
 };
 exports.getVideoInfo = getVideoInfo;

package/dist/image-format.d.ts

@@ -1,2 +1,7 @@
-import type { ImageFormat } from 'remotion';
+import type { PixelFormat } from './pixel-format';
+export declare const validImageFormats: readonly ["png", "jpeg", "none"];
+export declare type ImageFormat = typeof validImageFormats[number];
+export declare type StillImageFormat = 'png' | 'jpeg';
 export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat, imageFormat: ImageFormat) => 'none' | 'valid';
+export declare const validateNonNullImageFormat: (imageFormat: ImageFormat) => void;