@remotion/renderer 4.0.0-oops.3 → 4.0.0-prefetch.10

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

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
+const execa_1 = __importDefault(require("execa"));
+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");
+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) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
+// if the video is corrupted
+const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${duration * 1000 - offset}ms`;
+    const command = [
+        '-itsoffset',
+        actualOffset,
+        ...determineVcodecFfmepgFlags(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...determineResizeParams(needsResize),
+        '-',
+    ].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');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        if (offset > 70) {
+            throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
+        }
+        return getFrameOfVideoSlow({
+            ffmpegExecutable,
+            duration,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            imageFormat,
+            specialVCodecForTransparency,
+            needsResize,
+            fps,
+        });
+    }
+    return stdoutBuffer;
+};
+const getLastFrameOfVideoFastUnlimited = async (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, 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.`);
+    }
+    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
+        const last = await getFrameOfVideoSlow({
+            duration,
+            ffmpegExecutable,
+            src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+            offset: offset - 1000 / (fps === null ? 10 : fps),
+            fps,
+        });
+        return last;
+    }
+    const actualOffset = `${duration * 1000 - offset}ms`;
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+        '-ss',
+        actualOffset,
+        ...determineVcodecFfmepgFlags(options.specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...determineResizeParams(options.needsResize),
+        '-',
+    ].filter(truthy_1.truthy));
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => {
+            stdoutChunks.push(d);
+        });
+        stdout.on('error', (err) => {
+            reject(err);
+        });
+        stdout.on('end', () => {
+            resolve(Buffer.concat(stdoutChunks));
+        });
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    const isEmpty = stdErr.includes('Output file is empty');
+    if (isEmpty) {
+        const unlimited = await getLastFrameOfVideoFastUnlimited({
+            ffmpegExecutable,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
+            src,
+            ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+            downloadMap: options.downloadMap,
+        });
+        return unlimited;
+    }
+    return stdoutBuffer;
+};
+const getLastFrameOfVideo = async (options) => {
+    const result = await lastFrameLimit(getLastFrameOfVideoFastUnlimited, options);
+    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
+    return result;
+};
+exports.getLastFrameOfVideo = getLastFrameOfVideo;
+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)(downloadMap, options.src);
+    const { specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable);
+    if (specialVcodec === 'vp8') {
+        const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable);
+        return getFrameOfVideoSlow({
+            ffmpegExecutable,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            src,
+            duration: time,
+            needsResize,
+            offset: 0,
+            fps,
+        });
+    }
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
+        const lastFrame = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+        });
+        return lastFrame;
+    }
+    const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
+    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+        '-ss',
+        ffmpegTimestamp,
+        ...determineVcodecFfmepgFlags(specialVcodec),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2pipe',
+        '-vcodec',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        ...determineResizeParams(needsResize),
+        '-',
+    ].filter(truthy_1.truthy), {
+        buffer: false,
+    });
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const stderrStringProm = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf8')));
+    });
+    const stdoutBuffer = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => stdoutChunks.push(d));
+        stdout.on('error', (err) => reject(err));
+        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
+    });
+    const [stderrStr, stdOut] = await Promise.all([
+        stderrStringProm,
+        stdoutBuffer,
+    ]);
+    if (stderrStr.includes('Output file is empty')) {
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(downloadMap, src, time);
+        const last = await (0, exports.getLastFrameOfVideo)({
+            ffmpegExecutable,
+            ffprobeExecutable,
+            offset: 0,
+            src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+        });
+        return last;
+    }
+    if (stdOut.length === 0) {
+        console.log('FFMPEG Logs:');
+        console.log(stderrStr);
+        throw new Error("Couldn't extract frame from video - FFMPEG did not return any data. Check logs to see more information");
+    }
+    return stdOut;
+};
+const extractFrameFromVideo = async (options) => {
+    const perf = (0, perf_1.startPerfMeasure)('extract-frame');
+    const res = await mainLimit(extractFrameFromVideoFn, options);
+    (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/ffmpeg-filter-file.d.ts

@@ -1,4 +1,5 @@
-export declare const makeFfmpegFilterFile: (complexFilter: string) => Promise<{
+import type { DownloadMap } from './assets/download-map';
+export declare const makeFfmpegFilterFile: (complexFilter: string, downloadMap: DownloadMap) => Promise<{
     file: string;
     cleanup: () => void;
 }>;

package/dist/ffmpeg-filter-file.js

@@ -8,16 +8,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFfmpegFilterFile = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const delete_directory_1 = require("./delete-directory");
-const tmp_dir_1 = require("./tmp-dir");
-const makeFfmpegFilterFile = async (complexFilter) => {
-    const tempPath = (0, tmp_dir_1.tmpDir)('remotion-complex-filter');
-    const filterFile = path_1.default.join(tempPath, 'complex-filter.txt');
+const makeFfmpegFilterFile = async (complexFilter, downloadMap) => {
+    const random = Math.random().toString().replace('.', '');
+    const filterFile = path_1.default.join(downloadMap.complexFilter, 'complex-filter-' + random + '.txt');
     await fs_1.default.promises.writeFile(filterFile, complexFilter);
     return {
         file: filterFile,
         cleanup: () => {
-            (0, delete_directory_1.deleteDirectory)(filterFile);
+            fs_1.default.unlinkSync(filterFile);
         },
     };
 };

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/frame-to-ffmpeg-timestamp.d.ts

@@ -0,0 +1 @@
+export declare const frameToFfmpegTimestamp: (time: number) => string;

package/dist/frame-to-ffmpeg-timestamp.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frameToFfmpegTimestamp = void 0;
+const frameToFfmpegTimestamp = (time) => {
+    // We ceil because FFMPEG seeks to the closest frame BEFORE the position
+    return (Math.ceil(time * 1000000) / 1000).toFixed(3) + 'ms';
+};
+exports.frameToFfmpegTimestamp = frameToFfmpegTimestamp;

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

@@ -1,2 +1,2 @@
-import { 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,6 +1,7 @@
-import { Browser, Page } from 'puppeteer-core';
-import { BrowserExecutable } from 'remotion';
-import { ChromiumOptions } from './open-browser';
+import type { BrowserExecutable } from './browser-executable';
+import type { Browser } from './browser/Browser';
+import type { Page } from './browser/BrowserPage';
+import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
     passedInInstance: Browser | undefined;
     browserExecutable: BrowserExecutable | null;

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 { 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') {
@@ -21,6 +21,9 @@ const getCodecName = (codec) => {
     if (codec === 'prores') {
         return 'prores_ks';
     }
+    if (codec === 'gif') {
+        return 'gif';
+    }
     throw new TypeError(`Cannot find FFMPEG codec for ${codec}`);
 };
 exports.getCodecName = getCodecName;

package/dist/get-compositions.d.ts

@@ -1,7 +1,10 @@
-import { Browser } from 'puppeteer-core';
-import { BrowserExecutable, TCompMetadata } from 'remotion';
-import { BrowserLog } from './browser-log';
-import { ChromiumOptions } from './open-browser';
+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;
     envVariables?: Record<string, string>;
@@ -10,6 +13,13 @@ declare type GetCompositionsConfig = {
     browserExecutable?: BrowserExecutable;
     timeoutInMilliseconds?: number;
     chromiumOptions?: ChromiumOptions;
+    ffmpegExecutable?: FfmpegExecutable;
+    ffprobeExecutable?: FfmpegExecutable;
+    port?: number | null;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    downloadMap?: DownloadMap;
 };
-export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig | undefined) => Promise<TCompMetadata[]>;
+export declare const getCompositions: (serveUrlOrWebpackUrl: string, config?: GetCompositionsConfig) => Promise<TCompMetadata[]>;
 export {};

package/dist/get-compositions.js

@@ -1,20 +1,21 @@
 "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 prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
-const innerGetCompositions = async (serveUrl, page, config) => {
+const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
         page.on('console', (log) => {
             var _a;
             (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
                 stackTrace: log.stackTrace(),
-                text: log.text(),
-                type: log.type(),
+                text: log.text,
+                type: log.type,
             });
         });
     }
@@ -26,6 +27,10 @@ const innerGetCompositions = async (serveUrl, page, config) => {
         serveUrl,
         initialFrame: 0,
         timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
+        proxyPort,
+        retriesRemaining: 2,
+        audioEnabled: false,
+        videoEnabled: false,
     });
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
@@ -37,7 +42,7 @@ const innerGetCompositions = async (serveUrl, page, config) => {
         frame: null,
         args: [],
     });
-    await page.waitForFunction('window.ready === true');
+    await page.waitForFunction(page.browser, 'window.ready === true');
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();
@@ -49,28 +54,47 @@ const innerGetCompositions = async (serveUrl, page, config) => {
     return result;
 };
 const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b;
-    const { serveUrl, closeServer } = await (0, prepare_server_1.prepareServer)(serveUrlOrWebpackUrl);
+    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;
+        const onError = (err) => reject(err);
         const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
             page,
             frame: null,
-            onError: (err) => reject(err),
+            onError,
         });
-        innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {})
+        let close = null;
+        (0, prepare_server_1.prepareServer)({
+            webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
+            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;
+            return innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {}, offthreadPort);
+        })
             .then((comp) => resolve(comp))
             .catch((err) => {
             reject(err);
         })
             .finally(() => {
             cleanup();
-            closeServer();
+            close === null || close === void 0 ? void 0 : close();
             cleanupPageError();
+            // Clean download map if it was not passed in
+            if (!(config === null || config === void 0 ? void 0 : config.downloadMap)) {
+                (0, download_map_1.cleanDownloadMap)(downloadMap);
+            }
         });
     });
 };

package/dist/get-duration-from-frame-range.d.ts

@@ -1,2 +1 @@
-import { FrameRange } from 'remotion';
-export declare const getDurationFromFrameRange: (frameRange: FrameRange | null, durationInFrames: number) => number;
+export declare const getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];

package/dist/get-duration-from-frame-range.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDurationFromFrameRange = void 0;
-const getDurationFromFrameRange = (frameRange, durationInFrames) => {
-    if (frameRange === null) {
-        return durationInFrames;
+exports.getFramesToRender = void 0;
+const getFramesToRender = (frameRange, everyNthFrame) => {
+    if (everyNthFrame === 0) {
+        throw new Error('everyNthFrame cannot be 0');
     }
-    if (typeof frameRange === 'number') {
-        return 1;
-    }
-    return frameRange[1] - frameRange[0] + 1;
+    return new Array(frameRange[1] - frameRange[0] + 1)
+        .fill(true)
+        .map((_, index) => {
+        return index + frameRange[0];
+    })
+        .filter((index) => {
+        return index % everyNthFrame === 0;
+    });
 };
-exports.getDurationFromFrameRange = getDurationFromFrameRange;
+exports.getFramesToRender = getFramesToRender;

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

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

@@ -23,6 +23,11 @@ const getFileExtensionFromCodec = (codec, type) => {
             return 'webm';
         case 'vp9':
             return 'webm';
+        case 'gif':
+            if (type === 'chunk') {
+                return 'mkv';
+            }
+            return 'gif';
         case 'wav':
             return 'wav';
         default:

package/dist/get-extension-of-filename.d.ts

@@ -1 +1 @@
-export declare const getExtensionOfFilename: (filename: string) => string | null;
+export declare const getExtensionOfFilename: (filename: string | null) => string | null;

package/dist/get-extension-of-filename.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtensionOfFilename = void 0;
 const getExtensionOfFilename = (filename) => {
+    if (filename === null) {
+        return null;
+    }
     const filenameArr = filename.split('.');
     const hasExtension = filenameArr.length >= 2;
     const filenameArrLength = filenameArr.length;