@remotion/renderer 3.0.17 → 3.0.18

package/dist/combine-videos.js

@@ -30,6 +30,9 @@ const combineVideos = async ({ files, filelistDir, output, onProgress, numberOfF
             remotion_1.Internals.isAudioCodec(codec) ? null : 'copy',
             '-c:a',
             (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            // Set max bitrate up to 1024kbps, will choose lower if that's too much
+            '-b:a',
+            '512K',
             codec === 'h264' ? '-movflags' : null,
             codec === 'h264' ? 'faststart' : null,
             '-shortest',

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -1,4 +1,7 @@
 export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
-    complexFilterFlag: [string, string] | null;
+    complexFilterFlag: [
+        string,
+        string
+    ] | null;
     cleanup: () => void;
 }>;

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

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 import { Readable } from 'stream';
 import { LastFrameOptions } from './last-frame-from-video-cache';

package/dist/get-port.js

@@ -5,16 +5,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const getAvailablePort = (portToTry) => new Promise((resolve, reject) => {
-    const server = net_1.default.createServer();
-    server.unref();
-    server.on('error', reject);
-    server.listen({ port: portToTry }, () => {
-        const { port } = server.address();
-        server.close(() => {
-            resolve(port);
-        });
+const p_limit_1 = require("./p-limit");
+const getAvailablePort = (portToTry) => new Promise((resolve) => {
+    let status = 'unavailable';
+    const host = '127.0.0.1';
+    const socket = new net_1.default.Socket();
+    socket.on('connect', () => {
+        status = 'unavailable';
+        socket.destroy();
     });
+    socket.setTimeout(1000);
+    socket.on('timeout', () => {
+        status = 'unavailable';
+        socket.destroy();
+        resolve(status);
+    });
+    socket.on('error', () => {
+        status = 'available';
+    });
+    socket.on('close', () => resolve(status));
+    socket.connect(portToTry, host);
 });
 const portCheckSequence = function* (ports) {
     if (ports) {
@@ -22,30 +32,18 @@ const portCheckSequence = function* (ports) {
     }
     yield 0; // Fall back to 0 if anything else failed
 };
-const isPortAvailable = async (port) => {
-    try {
-        await getAvailablePort(port);
-        return true;
-    }
-    catch (error) {
-        if (!['EADDRINUSE', 'EACCES'].includes(error.code)) {
-            throw error;
-        }
-        return false;
-    }
-};
 const getPort = async (from, to) => {
     const ports = makeRange(from, to);
     for (const port of portCheckSequence(ports)) {
-        if (await isPortAvailable(port)) {
+        if ((await getAvailablePort(port)) === 'available') {
             return port;
         }
     }
     throw new Error('No available ports found');
 };
-const getDesiredPort = async (desiredPort, from, to) => {
+const getDesiredPortUnlimited = async (desiredPort, from, to) => {
     if (typeof desiredPort !== 'undefined' &&
-        (await isPortAvailable(desiredPort))) {
+        (await getAvailablePort(desiredPort)) === 'available') {
         return desiredPort;
     }
     const actualPort = await getPort(from, to);
@@ -55,6 +53,10 @@ const getDesiredPort = async (desiredPort, from, to) => {
     }
     return actualPort;
 };
+const limit = (0, p_limit_1.pLimit)(1);
+const getDesiredPort = (desiredPort, from, to) => {
+    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+};
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {
     if (!Number.isInteger(from) || !Number.isInteger(to)) {

package/dist/last-frame-from-video-cache.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { FfmpegExecutable } from 'remotion';
 export declare type LastFrameOptions = {
     ffmpegExecutable: FfmpegExecutable;

package/dist/provide-screenshot.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import puppeteer from 'puppeteer-core';
 import { ImageFormat } from 'remotion';
 export declare const provideScreenshot: ({ page, imageFormat, options, quality, }: {

package/dist/puppeteer-screenshot.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 import { Page, ScreenshotOptions } from 'puppeteer-core';
 export declare const screenshot: (page: Page, options?: ScreenshotOptions) => Promise<Buffer | string | void>;

package/dist/render-gif.d.ts

@@ -0,0 +1,2 @@
+import { RenderMediaOptions } from './render-media';
+export declare const renderGif: ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }: RenderMediaOptions) => Promise<void>;

package/dist/render-gif.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGif = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const ensure_frames_in_order_1 = require("./ensure-frames-in-order");
+const ensure_output_directory_1 = require("./ensure-output-directory");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_extension_of_filename_1 = require("./get-extension-of-filename");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const legacy_webpack_config_1 = require("./legacy-webpack-config");
+const make_cancel_signal_1 = require("./make-cancel-signal");
+const prespawn_ffmpeg_1 = require("./prespawn-ffmpeg");
+const render_frames_1 = require("./render-frames");
+const stitch_frames_to_gif_1 = require("./stitch-frames-to-gif");
+const tmp_dir_1 = require("./tmp-dir");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_output_filename_1 = require("./validate-output-filename");
+const validate_scale_1 = require("./validate-scale");
+const renderGif = ({ parallelism, proResProfile, crf, composition, imageFormat, ffmpegExecutable, inputProps, pixelFormat, codec, envVariables, quality, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, loop, skipNFrames, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, ...options }) => {
+    remotion_1.Internals.validateQuality(quality);
+    if (typeof crf !== 'undefined' && crf !== null) {
+        remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    }
+    (0, validate_output_filename_1.validateOutputFilename)(codec, (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation));
+    (0, validate_scale_1.validateScale)(scale);
+    const serveUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
+    let stitchStage = 'encoding';
+    let stitcherFfmpeg;
+    let preStitcher = null;
+    let encodedFrames = 0;
+    let renderedFrames = 0;
+    let renderedDoneIn = null;
+    let encodedDoneIn = null;
+    let cancelled = false;
+    const renderStart = Date.now();
+    const tmpdir = (0, tmp_dir_1.tmpDir)('pre-encode');
+    const parallelEncoding = (0, can_use_parallel_encoding_1.canUseParallelEncoding)(codec);
+    const actualImageFormat = imageFormat !== null && imageFormat !== void 0 ? imageFormat : 'jpeg';
+    const preEncodedFileLocation = parallelEncoding
+        ? path_1.default.join(tmpdir, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, 'chunk'))
+        : null;
+    const outputDir = parallelEncoding
+        ? null
+        : fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'react-motion-render'));
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        codec,
+        height: composition.height,
+        scale: scale !== null && scale !== void 0 ? scale : 1,
+        width: composition.width,
+    });
+    const callUpdate = () => {
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+            encodedDoneIn,
+            encodedFrames,
+            renderedDoneIn,
+            renderedFrames,
+            stitchStage,
+        });
+    };
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange !== null && frameRange !== void 0 ? frameRange : null);
+    const cancelRenderFrames = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelPrestitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    const cancelStitcher = (0, make_cancel_signal_1.makeCancelSignal)();
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        cancelRenderFrames.cancel();
+    });
+    const { waitForRightTimeOfFrameToBeInserted, setFrameToStitch, waitForFinish } = (0, ensure_frames_in_order_1.ensureFramesInOrder)(realFrameRange);
+    const actualGifFps = Math.floor(composition.fps / (skipNFrames + 1));
+    const createPrestitcherIfNecessary = async () => {
+        if (preEncodedFileLocation) {
+            preStitcher = await (0, prespawn_ffmpeg_1.prespawnFfmpeg)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation: preEncodedFileLocation,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                onProgress: (frame) => {
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                ffmpegExecutable,
+                imageFormat: actualImageFormat,
+                signal: cancelPrestitcher.cancelSignal,
+            });
+            stitcherFfmpeg = preStitcher.task;
+        }
+    };
+    const waitForPrestitcherIfNecessary = async () => {
+        var _a;
+        if (stitcherFfmpeg) {
+            await waitForFinish();
+            (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.end();
+            try {
+                await stitcherFfmpeg;
+            }
+            catch (err) {
+                throw new Error(preStitcher === null || preStitcher === void 0 ? void 0 : preStitcher.getLogs());
+            }
+        }
+    };
+    const happyPath = createPrestitcherIfNecessary()
+        .then(() => {
+        const renderFramesProc = (0, render_frames_1.renderFrames)({
+            config: composition,
+            onFrameUpdate: (frame) => {
+                stitchStage = 'gif';
+                renderedFrames = frame;
+                callUpdate();
+            },
+            parallelism,
+            outputDir,
+            skipNFrames,
+            onStart: (data) => {
+                renderedFrames = 0;
+                callUpdate();
+                onStart === null || onStart === void 0 ? void 0 : onStart(data);
+            },
+            inputProps,
+            envVariables,
+            imageFormat: actualImageFormat,
+            quality,
+            frameRange: frameRange !== null && frameRange !== void 0 ? frameRange : null,
+            puppeteerInstance,
+            onFrameBuffer: parallelEncoding
+                ? async (buffer, frame) => {
+                    var _a;
+                    await waitForRightTimeOfFrameToBeInserted(frame);
+                    if (cancelled) {
+                        return;
+                    }
+                    (_a = stitcherFfmpeg === null || stitcherFfmpeg === void 0 ? void 0 : stitcherFfmpeg.stdin) === null || _a === void 0 ? void 0 : _a.write(buffer);
+                    setFrameToStitch(frame + 1);
+                }
+                : undefined,
+            serveUrl,
+            dumpBrowserLogs,
+            onBrowserLog,
+            onDownload,
+            timeoutInMilliseconds,
+            chromiumOptions,
+            scale,
+            ffmpegExecutable,
+            browserExecutable,
+            port,
+            cancelSignal: cancelRenderFrames.cancelSignal,
+        });
+        return renderFramesProc;
+    })
+        .then((renderFramesReturn) => {
+        return Promise.all([renderFramesReturn, waitForPrestitcherIfNecessary()]);
+    })
+        .then(([{ assetsInfo }]) => {
+        renderedDoneIn = Date.now() - renderStart;
+        callUpdate();
+        (0, ensure_output_directory_1.ensureOutputDirectory)(outputLocation);
+        const stitchStart = Date.now();
+        return Promise.all([
+            (0, stitch_frames_to_gif_1.stitchFramesToGif)({
+                width: composition.width * (scale !== null && scale !== void 0 ? scale : 1),
+                height: composition.height * (scale !== null && scale !== void 0 ? scale : 1),
+                fps: actualGifFps,
+                outputLocation,
+                internalOptions: {
+                    preEncodedFileLocation,
+                    imageFormat: actualImageFormat,
+                },
+                force: overwrite !== null && overwrite !== void 0 ? overwrite : remotion_1.Internals.DEFAULT_OVERWRITE,
+                pixelFormat,
+                codec,
+                proResProfile,
+                crf,
+                loop,
+                assetsInfo,
+                ffmpegExecutable,
+                onProgress: (frame) => {
+                    stitchStage = 'gif';
+                    encodedFrames = frame;
+                    callUpdate();
+                },
+                verbose: remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), 'verbose'),
+                dir: outputDir !== null && outputDir !== void 0 ? outputDir : undefined,
+                cancelSignal: cancelStitcher.cancelSignal,
+            }),
+            stitchStart,
+        ]);
+    })
+        .then(([, stitchStart]) => {
+        encodedFrames = (0, get_duration_from_frame_range_1.getDurationFromFrameRange)(frameRange !== null && frameRange !== void 0 ? frameRange : null, composition.durationInFrames, skipNFrames);
+        encodedDoneIn = Date.now() - stitchStart;
+        callUpdate();
+    })
+        .catch((err) => {
+        /**
+         * When an error is thrown in renderFrames(...) (e.g., when delayRender() is used incorrectly), fs.unlinkSync(...) throws an error that the file is locked because ffmpeg is still running, and renderMedia returns it.
+         * Therefore we first kill the FFMPEG process before deleting the file
+         */
+        cancelled = true;
+        cancelRenderFrames.cancel();
+        cancelStitcher.cancel();
+        cancelPrestitcher.cancel();
+        if (stitcherFfmpeg !== undefined && stitcherFfmpeg.exitCode === null) {
+            const promise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 2000);
+                stitcherFfmpeg.on('close', resolve);
+            });
+            stitcherFfmpeg.kill();
+            return promise.then(() => {
+                throw err;
+            });
+        }
+        throw err;
+    })
+        .finally(() => {
+        if (preEncodedFileLocation !== null &&
+            fs_1.default.existsSync(preEncodedFileLocation)) {
+            fs_1.default.unlinkSync(preEncodedFileLocation);
+        }
+    });
+    return Promise.race([
+        happyPath,
+        new Promise((_resolve, reject) => {
+            cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+                reject(new Error('renderMedia() got cancelled'));
+            });
+        }),
+    ]);
+};
+exports.renderGif = renderGif;

package/dist/screenshot-dom-element.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import puppeteer from 'puppeteer-core';
 import { ImageFormat } from 'remotion';
 export declare const screenshotDOMElement: ({ page, imageFormat, quality, opts, }: {

package/dist/screenshot-task.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Page, ScreenshotOptions } from 'puppeteer-core';
 import { StillImageFormat } from 'remotion';
 export declare const _screenshotTask: (page: Page, format: StillImageFormat, options: ScreenshotOptions) => Promise<Buffer | string>;

package/dist/serve-handler/glob-slash.d.ts

@@ -0,0 +1 @@
+export declare const slasher: (value: string) => string;

package/dist/serve-handler/glob-slash.js

@@ -0,0 +1,12 @@
+"use strict";
+/* ! The MIT License (MIT) Copyright (c) 2014 Scott Corgan */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slasher = void 0;
+// This is adopted from https://github.com/scottcorgan/glob-slash/
+const path_1 = __importDefault(require("path"));
+const normalize = (value) => path_1.default.posix.normalize(path_1.default.posix.join('/', value));
+const slasher = (value) => value.charAt(0) === '!' ? `!${normalize(value.substr(1))}` : normalize(value);
+exports.slasher = slasher;

package/dist/serve-handler/index.d.ts

@@ -0,0 +1,4 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const serveHandler: (request: IncomingMessage, response: ServerResponse, config: {
+    public: string;
+}) => Promise<void>;

package/dist/serve-handler/index.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveHandler = void 0;
+// Native
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+// Packages
+const mime_types_1 = __importDefault(require("mime-types"));
+const is_path_inside_1 = require("./is-path-inside");
+const range_parser_1 = require("./range-parser");
+const getHeaders = (absolutePath, stats) => {
+    const related = {};
+    const { base } = path_1.default.parse(absolutePath);
+    let defaultHeaders = {};
+    if (stats) {
+        defaultHeaders = {
+            'Content-Length': String(stats.size),
+            'Accept-Ranges': 'bytes',
+        };
+        defaultHeaders['Last-Modified'] = stats.mtime.toUTCString();
+        const contentType = mime_types_1.default.contentType(base);
+        if (contentType) {
+            defaultHeaders['Content-Type'] = contentType;
+        }
+    }
+    const headers = Object.assign(defaultHeaders, related);
+    for (const key in headers) {
+        if (headers[key] === null) {
+            delete headers[key];
+        }
+    }
+    return headers;
+};
+const getPossiblePaths = (relativePath, extension) => [
+    path_1.default.join(relativePath, `index${extension}`),
+    relativePath.endsWith('/')
+        ? relativePath.replace(/\/$/g, extension)
+        : relativePath + extension,
+].filter((item) => path_1.default.basename(item) !== extension);
+const findRelated = async (current, relativePath) => {
+    const possible = getPossiblePaths(relativePath, '.html');
+    let stats = null;
+    for (let index = 0; index < possible.length; index++) {
+        const related = possible[index];
+        const absolutePath = path_1.default.join(current, related);
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                throw err;
+            }
+        }
+        if (stats) {
+            return {
+                stats,
+                absolutePath,
+            };
+        }
+    }
+    return null;
+};
+const sendError = (absolutePath, response, spec) => {
+    const { message, statusCode } = spec;
+    response.statusCode = statusCode;
+    const headers = getHeaders(absolutePath, null);
+    response.writeHead(statusCode, headers);
+    response.setHeader('content-type', 'application/json');
+    response.end(JSON.stringify({ statusCode, message }));
+};
+const internalError = (absolutePath, response) => {
+    return sendError(absolutePath, response, {
+        statusCode: 500,
+        code: 'internal_server_error',
+        message: 'A server error has occurred',
+    });
+};
+const serveHandler = async (request, response, config) => {
+    const cwd = process.cwd();
+    const current = path_1.default.resolve(cwd, config.public);
+    let relativePath = null;
+    try {
+        relativePath = decodeURIComponent(url_1.default.parse(request.url).pathname);
+    }
+    catch (err) {
+        return sendError('/', response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let absolutePath = path_1.default.join(current, relativePath);
+    // Prevent path traversal vulnerabilities. We could do this
+    // by ourselves, but using the package covers all the edge cases.
+    if (!(0, is_path_inside_1.isPathInside)(absolutePath, current)) {
+        return sendError(absolutePath, response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let stats = null;
+    // It's extremely important that we're doing multiple stat calls. This one
+    // right here could technically be removed, but then the program
+    // would be slower. Because for directories, we always want to see if a related file
+    // exists and then (after that), fetch the directory itself if no
+    // related file was found. However (for files, of which most have extensions), we should
+    // always stat right away.
+    //
+    // When simulating a file system without directory indexes, calculating whether a
+    // directory exists requires loading all the file paths and then checking if
+    // one of them includes the path of the directory. As that's a very
+    // performance-expensive thing to do, we need to ensure it's not happening if not really necessary.
+    if (path_1.default.extname(relativePath) !== '') {
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (!stats) {
+        try {
+            const related = await findRelated(current, relativePath);
+            if (related) {
+                ({ stats, absolutePath } = related);
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+        try {
+            stats = await fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) {
+        const directory = null;
+        const singleFile = null;
+        if (directory) {
+            const contentType = 'text/html; charset=utf-8';
+            response.statusCode = 200;
+            response.setHeader('Content-Type', contentType);
+            response.end('Is a directory');
+            return;
+        }
+        if (!singleFile) {
+            // The directory listing is disabled, so we want to
+            // render a 404 error.
+            stats = null;
+        }
+    }
+    const isSymLink = stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink();
+    // There are two scenarios in which we want to reply with
+    // a 404 error: Either the path does not exist, or it is a
+    // symlink while the `symlinks` option is disabled (which it is by default).
+    if (!stats || isSymLink) {
+        // allow for custom 404 handling
+        return sendError(absolutePath, response, {
+            statusCode: 404,
+            code: 'not_found',
+            message: 'The requested path could not be found',
+        });
+    }
+    let streamOpts = null;
+    if (request.headers.range && stats.size) {
+        const range = (0, range_parser_1.rangeParser)(stats.size, request.headers.range);
+        if (typeof range === 'object' && range.type === 'bytes') {
+            const { start, end } = range.ranges[0];
+            streamOpts = {
+                start,
+                end,
+            };
+            response.statusCode = 206;
+        }
+        else {
+            response.statusCode = 416;
+            response.setHeader('Content-Range', `bytes */${stats.size}`);
+        }
+    }
+    let stream = null;
+    try {
+        stream = (0, fs_1.createReadStream)(absolutePath, streamOpts !== null && streamOpts !== void 0 ? streamOpts : {});
+    }
+    catch (err) {
+        return internalError(absolutePath, response);
+    }
+    const headers = getHeaders(absolutePath, stats);
+    if (streamOpts !== null) {
+        headers['Content-Range'] = `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
+        headers['Content-Length'] = String(streamOpts.end - streamOpts.start + 1);
+    }
+    response.writeHead(response.statusCode || 200, headers);
+    stream.pipe(response);
+};
+exports.serveHandler = serveHandler;

package/dist/serve-handler/is-path-inside.d.ts

@@ -0,0 +1 @@
+export declare const isPathInside: (thePath: string, potentialParent: string) => boolean;

package/dist/serve-handler/is-path-inside.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathInside = void 0;
+const path_1 = __importDefault(require("path"));
+const isPathInside = function (thePath, potentialParent) {
+    // For inside-directory checking, we want to allow trailing slashes, so normalize.
+    thePath = stripTrailingSep(thePath);
+    potentialParent = stripTrailingSep(potentialParent);
+    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
+    if (process.platform === 'win32') {
+        thePath = thePath.toLowerCase();
+        potentialParent = potentialParent.toLowerCase();
+    }
+    return (thePath.lastIndexOf(potentialParent, 0) === 0 &&
+        (thePath[potentialParent.length] === path_1.default.sep ||
+            thePath[potentialParent.length] === undefined));
+};
+exports.isPathInside = isPathInside;
+function stripTrailingSep(thePath) {
+    if (thePath[thePath.length - 1] === path_1.default.sep) {
+        return thePath.slice(0, -1);
+    }
+    return thePath;
+}

package/dist/serve-handler/range-parser.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export declare const rangeParser: (size: number, str: string) => -1 | {
+    type: string;
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+} | -2;

package/dist/serve-handler/range-parser.js

@@ -0,0 +1,57 @@
+"use strict";
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeParser = void 0;
+const rangeParser = (size, str) => {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const index = str.indexOf('=');
+    if (index === -1) {
+        return -2;
+    }
+    // split the range string
+    const arr = str.slice(index + 1).split(',');
+    const ranges = [];
+    // add ranges type
+    const type = str.slice(0, index);
+    // parse all ranges
+    for (let i = 0; i < arr.length; i++) {
+        const range = arr[i].split('-');
+        let start = parseInt(range[0], 10);
+        let end = parseInt(range[1], 10);
+        // -nnn
+        if (isNaN(start)) {
+            start = size - end;
+            end = size - 1;
+            // nnn-
+        }
+        else if (isNaN(end)) {
+            end = size - 1;
+        }
+        // limit last-byte-pos to current length
+        if (end > size - 1) {
+            end = size - 1;
+        }
+        // invalid or unsatisifiable
+        if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+            continue;
+        }
+        // add range
+        ranges.push({
+            start,
+            end,
+        });
+    }
+    if (ranges.length < 1) {
+        // unsatisifiable
+        return -1;
+    }
+    return { ranges, type };
+};
+exports.rangeParser = rangeParser;

package/dist/serve-static.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.serveStatic = void 0;
 const http_1 = __importDefault(require("http"));
 const remotion_1 = require("remotion");
-const serve_handler_1 = __importDefault(require("serve-handler"));
 const get_port_1 = require("./get-port");
 const offthread_video_server_1 = require("./offthread-video-server");
+const serve_handler_1 = require("./serve-handler");
 const serveStatic = async (path, options) => {
     var _a, _b;
     const port = await (0, get_port_1.getDesiredPort)((_b = (_a = options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : remotion_1.Internals.getServerPort()) !== null && _b !== void 0 ? _b : undefined, 3000, 3100);
@@ -31,10 +31,8 @@ const serveStatic = async (path, options) => {
                 response.end('Server only supports /proxy');
                 return;
             }
-            (0, serve_handler_1.default)(request, response, {
+            (0, serve_handler_1.serveHandler)(request, response, {
                 public: path,
-                directoryListing: false,
-                cleanUrls: false,
             }).catch(() => {
                 response.statusCode = 500;
                 response.end('Error serving file');

package/dist/stitch-frames-to-gif.d.ts

@@ -0,0 +1,8 @@
+import { StitcherOptions } from './stitch-frames-to-video';
+declare type ReturnType = {
+    task: Promise<unknown>;
+    getLogs: () => string;
+};
+export declare const spawnFfmpeg: (options: StitcherOptions) => Promise<ReturnType>;
+export declare const stitchFramesToGif: (options: StitcherOptions) => Promise<void>;
+export {};

package/dist/stitch-frames-to-gif.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchFramesToGif = exports.spawnFfmpeg = void 0;
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const get_codec_name_1 = require("./get-codec-name");
+const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const packageJsonPath = path_1.default.join(__dirname, '..', 'package.json');
+const packageJson = fs_1.default.existsSync(packageJsonPath)
+    ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
+    : null;
+const spawnFfmpeg = async (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateFps(options.fps, 'passed to `stitchFramesToVideo()`');
+    const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : remotion_1.Internals.DEFAULT_CODEC;
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        width: options.width,
+        height: options.height,
+        codec,
+        scale: 1,
+    });
+    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : remotion_1.Internals.getDefaultCrfForCodec(codec);
+    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : remotion_1.Internals.DEFAULT_PIXEL_FORMAT;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
+    const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
+    const supportsCrf = encoderName && codec !== 'prores';
+    if (options.verbose) {
+        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
+        console.log('[verbose] encoder', encoderName);
+        console.log('[verbose] pixelFormat', pixelFormat);
+        if (supportsCrf) {
+            console.log('[verbose] crf', crf);
+        }
+        console.log('[verbose] codec', codec);
+        console.log('[verbose] proResProfileName', proResProfileName);
+    }
+    remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    remotion_1.Internals.validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
+    const expectedFrames = options.assetsInfo.assets.length;
+    const updateProgress = (preStitchProgress, muxProgress) => {
+        var _a;
+        const totalFrameProgress = 0.5 * preStitchProgress * expectedFrames + muxProgress * 0.5;
+        (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, Math.round(totalFrameProgress));
+    };
+    const ffmpegArgs = [
+        ['-r', String(options.fps)],
+        ...(((_f = options.internalOptions) === null || _f === void 0 ? void 0 : _f.preEncodedFileLocation)
+            ? [['-i', (_g = options.internalOptions) === null || _g === void 0 ? void 0 : _g.preEncodedFileLocation]]
+            : [
+                ['-f', 'image2'],
+                ['-s', `${options.width}x${options.height}`],
+                ['-start_number', String(options.assetsInfo.firstFrameIndex)],
+                ['-i', options.assetsInfo.imageSequenceName],
+            ]),
+        // -c:v is the same as -vcodec as -codec:video
+        // and specified the video codec.
+        options.loop === null
+            ? null
+            : ['-loop', typeof options.loop === 'number' ? options.loop : '-1'],
+        // Ignore metadata that may come from remote media
+        ['-map_metadata', '-1'],
+        [
+            '-metadata',
+            `comment=` +
+                [`Made with Remotion`, packageJson ? packageJson.version : null].join(' '),
+        ],
+        options.force ? '-y' : null,
+        options.outputLocation,
+    ];
+    if (options.verbose) {
+        console.log('Generated FFMPEG command:');
+        console.log(ffmpegArgs);
+    }
+    const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
+    const task = (0, execa_1.default)((_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : 'ffmpeg', ffmpegString, {
+        cwd: options.dir,
+    });
+    (_j = options.cancelSignal) === null || _j === void 0 ? void 0 : _j.call(options, () => {
+        task.kill();
+    });
+    let ffmpegOutput = '';
+    let isFinished = false;
+    (_k = task.stderr) === null || _k === void 0 ? void 0 : _k.on('data', (data) => {
+        var _a;
+        const str = data.toString();
+        ffmpegOutput += str;
+        if (options.onProgress) {
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(str);
+            // FFMPEG bug: In some cases, FFMPEG does hang after it is finished with it's job
+            // Example repo: https://github.com/JonnyBurger/ffmpeg-repro (access can be given upon request)
+            if (parsed !== undefined) {
+                // If two times in a row the finishing frame is logged, we quit the render
+                if (parsed === expectedFrames) {
+                    if (isFinished) {
+                        (_a = task.stdin) === null || _a === void 0 ? void 0 : _a.write('q');
+                    }
+                    else {
+                        isFinished = true;
+                    }
+                }
+                updateProgress(1, parsed);
+            }
+        }
+    });
+    return { task, getLogs: () => ffmpegOutput };
+};
+exports.spawnFfmpeg = spawnFfmpeg;
+const stitchFramesToGif = async (options) => {
+    const { task, getLogs } = await (0, exports.spawnFfmpeg)(options);
+    try {
+        await task;
+    }
+    catch (err) {
+        throw new Error(getLogs());
+    }
+};
+exports.stitchFramesToGif = stitchFramesToGif;

package/dist/stitch-frames-to-video.js

@@ -128,6 +128,9 @@ const spawnFfmpeg = async (options) => {
             audio,
             '-c:a',
             audioCodecName,
+            // Set bitrate up to 320k, for aac it might effectively be lower
+            '-b:a',
+            '320k',
             options.force ? '-y' : null,
             options.outputLocation,
         ].filter(remotion_1.Internals.truthy));
@@ -168,6 +171,8 @@ const spawnFfmpeg = async (options) => {
             ]),
         codec === 'h264' ? ['-movflags', 'faststart'] : null,
         audioCodecName ? ['-c:a', audioCodecName] : null,
+        // Set max bitrate up to 1024kbps, will choose lower if that's too much
+        audioCodecName ? ['-b:a', '512K'] : null,
         // Ignore metadata that may come from remote media
         ['-map_metadata', '-1'],
         [

package/dist/validate-fps-for-gif.d.ts

@@ -0,0 +1,2 @@
+import { Codec } from 'remotion';
+export declare const validateFpsForGif: (codec: Codec, fps: number) => void;

package/dist/validate-fps-for-gif.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFpsForGif = void 0;
+const validateFpsForGif = (codec, fps) => {
+    if (codec === 'gif' && (fps > 50 || fps < 1)) {
+        throw new Error(`To render a GIF, the FPS must be less than or equal to 50 and greater than 0 but got ${fps} instead`);
+    }
+};
+exports.validateFpsForGif = validateFpsForGif;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.0.17",
+	"version": "3.0.18",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -21,9 +21,9 @@
 	},
 	"dependencies": {
 		"execa": "5.1.1",
+		"mime-types": "2.1.35",
 		"puppeteer-core": "13.5.1",
-		"remotion": "3.0.17",
-		"serve-handler": "6.1.3",
+		"remotion": "3.0.18",
 		"source-map": "^0.8.0-beta.0"
 	},
 	"peerDependencies": {
@@ -35,10 +35,10 @@
 		"@testing-library/dom": "^8.7.2",
 		"@testing-library/react": "13.1.1",
 		"@types/jest": "^27.4.0",
+		"@types/mime-types": "2.1.1",
 		"@types/node": "^16.7.5",
 		"@types/react": "18.0.1",
 		"@types/react-dom": "18.0.0",
-		"@types/serve-handler": "^6.1.0",
 		"eslint": "8.13.0",
 		"jest": "^27.2.4",
 		"prettier": "^2.0.5",
@@ -59,5 +59,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "c973653a9ced0d8793ce0cb03ce5f837b149d865"
+	"gitHead": "64eadd48b303d0f627ed5883f9200345af002ee2"
 }