@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha10

package/dist/take-frame-and-compose.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeFrameAndCompose = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const compose_1 = require("./compositor/compose");
+const provide_screenshot_1 = require("./provide-screenshot");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const truthy_1 = require("./truthy");
+const takeFrameAndCompose = async ({ freePage, imageFormat, jpegQuality, frame, width, height, output, scale, downloadMap, wantsBuffer, compositor, }) => {
+    var _a;
+    const [clipRegion, collectedAssets] = await Promise.all([
+        (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+            pageFunction: () => {
+                if (typeof window.remotion_getClipRegion === 'undefined') {
+                    return null;
+                }
+                return window.remotion_getClipRegion();
+            },
+            args: [],
+            frame,
+            page: freePage,
+        }),
+        (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+            pageFunction: () => {
+                return window.remotion_collectAssets();
+            },
+            args: [],
+            frame,
+            page: freePage,
+        }),
+    ]);
+    if (imageFormat === 'none') {
+        return { buffer: null, collectedAssets };
+    }
+    const needsComposing = clipRegion === null
+        ? null
+        : {
+            tmpFile: node_path_1.default.join(downloadMap.compositingDir, `${frame}.${imageFormat}`),
+            finalOutFile: output !== null && output !== void 0 ? output : node_path_1.default.join(downloadMap.compositingDir, `${frame}-final.${imageFormat}`),
+            clipRegion: clipRegion,
+        };
+    if (clipRegion !== 'hide') {
+        const shouldMakeBuffer = wantsBuffer && !needsComposing;
+        const buf = await (0, provide_screenshot_1.provideScreenshot)({
+            page: freePage,
+            imageFormat,
+            jpegQuality,
+            options: {
+                frame,
+                output: shouldMakeBuffer ? null : (_a = needsComposing === null || needsComposing === void 0 ? void 0 : needsComposing.tmpFile) !== null && _a !== void 0 ? _a : output,
+            },
+            height,
+            width,
+            clipRegion,
+        });
+        if (shouldMakeBuffer) {
+            return { buffer: buf, collectedAssets };
+        }
+    }
+    if (needsComposing) {
+        if (imageFormat === 'pdf') {
+            throw new Error("You cannot use compositor APIs (like <Clipper>) if `imageFormat` is 'pdf'.");
+        }
+        if (imageFormat === 'webp') {
+            throw new Error("You cannot use compositor APIs (like <Clipper>) if `imageFormat` is 'webp'.");
+        }
+        await (0, compose_1.compose)({
+            height: height * scale,
+            width: width * scale,
+            layers: [
+                needsComposing.clipRegion === 'hide'
+                    ? null
+                    : {
+                        type: imageFormat === 'jpeg'
+                            ? 'JpgImage'
+                            : 'PngImage',
+                        params: {
+                            height: needsComposing.clipRegion.height * scale,
+                            width: needsComposing.clipRegion.width * scale,
+                            src: needsComposing.tmpFile,
+                            x: needsComposing.clipRegion.x * scale,
+                            y: needsComposing.clipRegion.y * scale,
+                        },
+                    },
+            ].filter(truthy_1.truthy),
+            output: needsComposing.finalOutFile,
+            downloadMap,
+            imageFormat: imageFormat === 'jpeg' ? 'Jpeg' : 'Png',
+            compositor,
+        });
+        if (wantsBuffer) {
+            const buffer = await node_fs_1.default.promises.readFile(needsComposing.finalOutFile);
+            await node_fs_1.default.promises.unlink(needsComposing.finalOutFile);
+            return { buffer, collectedAssets };
+        }
+    }
+    return { buffer: null, collectedAssets };
+};
+exports.takeFrameAndCompose = takeFrameAndCompose;

package/dist/tmp-dir.js

@@ -27,9 +27,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tmpDir = void 0;
-const fs_1 = __importStar(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
 const randomHash = () => {
     return new Array(10)
@@ -40,15 +40,14 @@ const randomHash = () => {
         .join('');
 };
 const tmpDir = (str) => {
-    var _a;
-    const newDir = path_1.default.join(os_1.default.tmpdir(), str + randomHash());
-    if (fs_1.default.existsSync(newDir)) {
-        ((_a = fs_1.default.rmSync) !== null && _a !== void 0 ? _a : fs_1.default.rmdirSync)(newDir, {
+    const newDir = node_path_1.default.join(node_os_1.default.tmpdir(), str + randomHash());
+    if (node_fs_1.default.existsSync(newDir)) {
+        node_fs_1.default.rmSync(newDir, {
             recursive: true,
             force: true,
         });
     }
-    (0, fs_1.mkdirSync)(newDir);
+    (0, node_fs_1.mkdirSync)(newDir);
     return newDir;
 };
 exports.tmpDir = tmpDir;

package/dist/try-to-extract-frame-of-video-fast.d.ts

@@ -0,0 +1,12 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { NeedsResize, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const tryToExtractFrameOfVideoFast: ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: NeedsResize;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    actualOffset: string;
+}) => Promise<readonly [string, Buffer]>;

package/dist/try-to-extract-frame-of-video-fast.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToExtractFrameOfVideoFast = void 0;
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const tryToExtractFrameOfVideoFast = async ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }) => {
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-ss',
+        actualOffset,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(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]);
+    return [stdErr, stdoutBuffer];
+};
+exports.tryToExtractFrameOfVideoFast = tryToExtractFrameOfVideoFast;

package/dist/validate-concurrency.d.ts

@@ -1 +1,3 @@
 export declare const validateConcurrency: (value: unknown, setting: string) => void;
+export declare const getMaxConcurrency: () => any;
+export declare const getMinConcurrency: () => number;

package/dist/validate-concurrency.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateConcurrency = void 0;
+exports.getMinConcurrency = exports.getMaxConcurrency = exports.validateConcurrency = void 0;
 const validateConcurrency = (value, setting) => {
     if (typeof value === 'undefined') {
         return;
@@ -8,17 +8,28 @@ const validateConcurrency = (value, setting) => {
     if (value === null) {
         return;
     }
-    if (typeof value !== 'number') {
-        throw new Error(setting + ' must be a number but is ' + value);
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        throw new Error(setting + ' must a number or a string but is ' + value);
     }
-    if (value % 1 !== 0) {
-        throw new Error(setting + ' must be an integer, but is ' + value);
+    if (typeof value === 'number') {
+        if (value % 1 !== 0) {
+            throw new Error(setting + ' must be an integer, but is ' + value);
+        }
+        if (value < (0, exports.getMinConcurrency)()) {
+            throw new Error(`${setting} must be at least ${(0, exports.getMinConcurrency)()}, but is ${JSON.stringify(value)}`);
+        }
+        if (value > (0, exports.getMaxConcurrency)()) {
+            throw new Error(`${setting} is set higher than the amount of CPU cores available. Available CPU cores: ${(0, exports.getMaxConcurrency)()}, value set: ${value}`);
+        }
     }
-    if (value < 1) {
-        throw new Error(setting + ' must be at least 1, but is ' + value);
-    }
-    if (value > require('os').cpus().length) {
-        throw new Error(`${setting} is set higher than the amount of CPU cores available. Available CPU cores: ${require('os').cpus().length}, value set: ${value}`);
+    else if (!/^\d+(\.\d+)?%$/.test(value)) {
+        throw new Error(`${setting} must be a number or percentage, but is ${JSON.stringify(value)}`);
     }
 };
 exports.validateConcurrency = validateConcurrency;
+const getMaxConcurrency = () => {
+    return require('os').cpus().length;
+};
+exports.getMaxConcurrency = getMaxConcurrency;
+const getMinConcurrency = () => 1;
+exports.getMinConcurrency = getMinConcurrency;

package/dist/validate-every-nth-frame.d.ts

@@ -1 +1,2 @@
-export declare const validateEveryNthFrame: (everyNthFrame: unknown) => void;
+import type { Codec } from './codec';
+export declare const validateEveryNthFrame: (everyNthFrame: unknown, codec: Codec) => 1 | undefined;

package/dist/validate-every-nth-frame.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEveryNthFrame = void 0;
-const validateEveryNthFrame = (everyNthFrame) => {
+const validateEveryNthFrame = (everyNthFrame, codec) => {
     if (typeof everyNthFrame === 'undefined') {
         throw new TypeError(`Argument missing for parameter "everyNthFrame"`);
     }
@@ -17,5 +17,12 @@ const validateEveryNthFrame = (everyNthFrame) => {
     if (everyNthFrame % 1 !== 0) {
         throw new RangeError(`Argument for everyNthFrame must be an integer, but got ${everyNthFrame}`);
     }
+    if (everyNthFrame === 1) {
+        return everyNthFrame;
+    }
+    // h264-mkv because that is what is being used on Lambda
+    if (codec !== 'gif' && codec !== 'h264-mkv') {
+        throw new Error(`"everyNthFrame" can only be set if "codec" is set to "gif". The codec is "${codec}"`);
+    }
 };
 exports.validateEveryNthFrame = validateEveryNthFrame;

package/dist/validate-ffmpeg-override.d.ts

@@ -0,0 +1,2 @@
+import type { FfmpegOverrideFn } from './ffmpeg-override';
+export declare const validateFfmpegOverride: (ffmpegArgsHook?: FfmpegOverrideFn) => void;

package/dist/validate-ffmpeg-override.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFfmpegOverride = void 0;
+const validateFfmpegOverride = (ffmpegArgsHook) => {
+    if (typeof ffmpegArgsHook === 'undefined') {
+        return;
+    }
+    if (ffmpegArgsHook && typeof ffmpegArgsHook !== 'function') {
+        throw new TypeError(`Argument passed for "ffmpegArgsHook" is not a function: ${ffmpegArgsHook}`);
+    }
+};
+exports.validateFfmpegOverride = validateFfmpegOverride;

package/dist/validate-ffmpeg.d.ts

@@ -1,2 +1,7 @@
-export declare const binaryExists: (name: 'ffmpeg' | 'brew', localFFmpeg: string | null) => Promise<boolean>;
-export declare const validateFfmpeg: (customFfmpegBinary: string | null) => Promise<void>;
+export declare const customExecutableExists: (localExecutable: string) => boolean;
+export declare const binaryExists: (name: 'ffmpeg' | 'ffprobe') => boolean;
+export declare const checkAndValidateFfmpegVersion: (options: {
+    ffmpegExecutable: string | null;
+    remotionRoot: string;
+}) => Promise<void>;
+export declare const validateFfmpeg: (customFfmpegBinary: string | null, remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => Promise<void>;

package/dist/validate-ffmpeg.js

@@ -3,29 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateFfmpeg = exports.binaryExists = void 0;
+exports.validateFfmpeg = exports.checkAndValidateFfmpegVersion = exports.binaryExists = exports.customExecutableExists = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const warn_about_ffmpeg_version_1 = require("./warn-about-ffmpeg-version");
 const existsMap = {};
-const binaryExists = async (name, localFFmpeg) => {
-    if (typeof existsMap[name] !== 'undefined') {
-        return existsMap[name];
+const customExecutableExists = (localExecutable) => {
+    try {
+        (0, fs_1.statSync)(localExecutable);
+        existsMap[localExecutable] = true;
     }
-    if (name === 'ffmpeg' && localFFmpeg) {
-        try {
-            (0, fs_1.statSync)(localFFmpeg);
-            existsMap[name] = true;
-        }
-        catch (err) {
-            existsMap[name] = false;
-        }
+    catch (err) {
+        existsMap[localExecutable] = false;
+    }
+    return existsMap[localExecutable];
+};
+exports.customExecutableExists = customExecutableExists;
+const binaryExists = (name) => {
+    if (typeof existsMap[name] !== 'undefined') {
         return existsMap[name];
     }
     const isWin = os_1.default.platform() === 'win32';
     const where = isWin ? 'where' : 'which';
     try {
-        await (0, execa_1.default)(where, [name]);
+        execa_1.default.sync(where, [name]);
         existsMap[name] = true;
         return true;
     }
@@ -35,38 +38,40 @@ const binaryExists = async (name, localFFmpeg) => {
     }
 };
 exports.binaryExists = binaryExists;
-const isHomebrewInstalled = () => {
-    return (0, exports.binaryExists)('brew', null);
+const checkAndValidateFfmpegVersion = async (options) => {
+    const ffmpegVersion = await (0, ffmpeg_flags_1.getFfmpegVersion)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    const buildConf = await (0, ffmpeg_flags_1.getFfmpegBuildInfo)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    (0, warn_about_ffmpeg_version_1.warnAboutFfmpegVersion)({ ffmpegVersion, buildConf });
 };
-const validateFfmpeg = async (customFfmpegBinary) => {
-    const ffmpegExists = await (0, exports.binaryExists)('ffmpeg', customFfmpegBinary);
-    if (!ffmpegExists) {
-        if (customFfmpegBinary) {
-            console.error('FFmpeg executable not found:');
-            console.error(customFfmpegBinary);
-            process.exit(1);
-        }
-        console.error('It looks like FFMPEG is not installed');
-        if (os_1.default.platform() === 'darwin' && (await isHomebrewInstalled())) {
-            console.error('Run `brew install ffmpeg` to install ffmpeg');
-        }
-        else if (os_1.default.platform() === 'win32') {
-            console.error('1. Install FFMPEG for Windows here:');
-            console.error('https://github.com/adaptlearning/adapt_authoring/wiki/Installing-FFmpeg#installing-ffmpeg-in-windows');
-            console.error('2. Add FFMPEG to your PATH');
-            console.error('  a. Go to the settings app.');
-            console.error('  b. Click System.');
-            console.error('  c. Click About.');
-            console.error('  d. Click Advanced system settings.');
-            console.error('  e. Click Environment variables.');
-            console.error('  f. Search for PATH environemnt variable, click edit and the folder where you installed FFMPEG.');
-            console.error('  g. Important: Restart your terminal completely to apply the new PATH.');
-            console.error('3. Re-run this command.');
-        }
-        else {
-            console.error('See https://github.com/adaptlearning/adapt_authoring/wiki/Installing-FFmpeg on how to install FFMPEG.');
+exports.checkAndValidateFfmpegVersion = checkAndValidateFfmpegVersion;
+const validateFfmpeg = async (customFfmpegBinary, remotionRoot, binary) => {
+    const ffmpegExists = (0, exports.binaryExists)(binary);
+    if (ffmpegExists) {
+        return;
+    }
+    if (customFfmpegBinary) {
+        if (!(0, exports.customExecutableExists)(customFfmpegBinary)) {
+            throw new Error('Custom FFmpeg executable not found: ' + customFfmpegBinary);
         }
-        process.exit(1);
+        return;
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return;
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return;
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return (0, exports.validateFfmpeg)(customFfmpegBinary, remotionRoot, binary);
     }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
 };
 exports.validateFfmpeg = validateFfmpeg;

package/dist/validate-number-of-gif-loops.d.ts

@@ -0,0 +1,2 @@
+import type { Codec } from './codec';
+export declare const validateNumberOfGifLoops: (numberOfGifLoops: unknown, codec: Codec) => void;

package/dist/validate-number-of-gif-loops.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateNumberOfGifLoops = void 0;
+const validateNumberOfGifLoops = (numberOfGifLoops, codec) => {
+    if (typeof numberOfGifLoops === 'undefined' || numberOfGifLoops === null) {
+        return;
+    }
+    if (typeof numberOfGifLoops !== 'number') {
+        throw new TypeError(`Argument passed to "numberOfGifLoops" is not a number: ${numberOfGifLoops}`);
+    }
+    if (numberOfGifLoops < 0) {
+        throw new RangeError(`The value for "numberOfGifLoops" cannot be below 0, but is ${numberOfGifLoops}`);
+    }
+    if (!Number.isFinite(numberOfGifLoops)) {
+        throw new RangeError(`"numberOfGifLoops" ${numberOfGifLoops} is not finite`);
+    }
+    if (numberOfGifLoops % 1 !== 0) {
+        throw new RangeError(`Argument for numberOfGifLoops must be an integer, but got ${numberOfGifLoops}`);
+    }
+    if (codec !== 'gif') {
+        throw new Error(`"everyNthFrame" can only be set if "codec" is set to "gif". The codec is "${codec}"`);
+    }
+};
+exports.validateNumberOfGifLoops = validateNumberOfGifLoops;

package/dist/validate-output-filename.d.ts

@@ -1,2 +1,7 @@
-import type { Codec } from './codec';
-export declare const validateOutputFilename: (codec: Codec, extension: string | null) => void;
+import type { AudioCodec } from './audio-codec';
+export declare const validateOutputFilename: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+    codec: T;
+    audioCodec: AudioCodec | null;
+    extension: string;
+    preferLossless: boolean;
+}) => void;

package/dist/validate-output-filename.js

@@ -1,57 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOutputFilename = void 0;
-const validateOutputFilename = (codec, extension) => {
-    if (codec === 'h264') {
-        if (extension !== 'mp4' && extension !== 'mkv') {
-            throw new TypeError('When using the H264 codec, the output filename must end in .mp4 or .mkv.');
-        }
-    }
-    if (codec === 'h264-mkv') {
-        if (extension !== 'mkv') {
-            throw new TypeError('When using the "h264-mkv" codec, the output filename must end in ".mkv".');
-        }
-    }
-    if (codec === 'h265') {
-        if (extension !== 'mp4' && extension !== 'hevc') {
-            throw new TypeError('When using H265 codec, the output filename must end in .mp4 or .hevc.');
-        }
-    }
-    if (codec === 'vp8' || codec === 'vp9') {
-        if (extension !== 'webm') {
-            throw new TypeError(`When using the ${codec.toUpperCase()} codec, the output filename must end in .webm.`);
-        }
-    }
-    if (codec === 'prores') {
-        const allowedProResExtensions = ['mov', 'mkv', 'mxf'];
-        if (!extension || !allowedProResExtensions.includes(extension)) {
-            throw new TypeError(`When using the 'prores' codec, the output must end in one of those extensions: ${allowedProResExtensions
-                .map((a) => `.${a}`)
-                .join(', ')}`);
-        }
-    }
-    if (codec === 'mp3') {
-        if (extension !== 'mp3') {
-            throw new TypeError("When using the 'mp3' codec, the output must end in .mp3");
-        }
-    }
-    if (codec === 'aac') {
-        const allowedAacExtensions = ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'];
-        if (!extension || !allowedAacExtensions.includes(extension)) {
-            throw new TypeError(`When using the 'aac' codec, the output must end in one of those extensions: ${allowedAacExtensions
-                .map((a) => `.${a}`)
-                .join(', ')}`);
-        }
-    }
-    if (codec === 'wav') {
-        if (extension !== 'wav') {
-            throw new TypeError("When using the 'wav' codec, the output location must end in .wav.");
-        }
-    }
-    if (codec === 'gif') {
-        if (extension !== 'gif') {
-            throw new TypeError('When using the GIF codec, the output filename must end in .gif.');
-        }
+const audio_codec_1 = require("./audio-codec");
+const file_extensions_1 = require("./file-extensions");
+const validateOutputFilename = ({ codec, audioCodec, extension, preferLossless, }) => {
+    if (!file_extensions_1.defaultFileExtensionMap[codec]) {
+        throw new TypeError(`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(file_extensions_1.defaultFileExtensionMap).join(', ')}`);
+    }
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless });
+    if (resolvedAudioCodec === null) {
+        if (extension !== map.default) {
+            throw new TypeError(`When using the ${codec} codec, the output filename must end in .${map.default}.`);
+        }
+        return;
+    }
+    if (!(resolvedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${resolvedAudioCodec} is not supported for codec ${codec}`);
+    }
+    const acceptableExtensions = map.forAudioCodec[resolvedAudioCodec].possible;
+    if (!acceptableExtensions.includes(extension)) {
+        throw new TypeError(`When using the ${codec} codec with the ${resolvedAudioCodec} audio codec, the output filename must end in one of the following: ${acceptableExtensions.join(', ')}.`);
     }
 };
 exports.validateOutputFilename = validateOutputFilename;

package/dist/validate-puppeteer-timeout.js

@@ -8,7 +8,8 @@ const validatePuppeteerTimeout = (timeoutInMilliseconds) => {
     if (typeof timeoutInMilliseconds !== 'number') {
         throw new TypeError(`'timeoutInMilliseconds' should be a number, but is: ${JSON.stringify(timeoutInMilliseconds)}`);
     }
-    if (timeoutInMilliseconds < 7000) {
+    // Value also appears in packages/cli/src/editor/components/RenderModal/RenderModalAdvanced.tsx
+    if (timeoutInMilliseconds < 7000 && process.env.NODE_ENV !== 'test') {
         throw new TypeError(`'timeoutInMilliseconds' should be bigger or equal than 7000, but is ${timeoutInMilliseconds}`);
     }
     if (Number.isNaN(timeoutInMilliseconds)) {

package/dist/validate-videobitrate.d.ts

@@ -0,0 +1 @@
+export declare const validateBitrate: (bitrate: unknown, name: string) => void;

package/dist/validate-videobitrate.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBitrate = void 0;
+const validateBitrate = (bitrate, name) => {
+    if (bitrate === null || typeof bitrate === 'undefined') {
+        return;
+    }
+    if (typeof bitrate === 'number') {
+        throw new TypeError(`"${name}" must be a string ending in "K" or "M". Got a number: ${bitrate}`);
+    }
+    if (typeof bitrate !== 'string') {
+        throw new TypeError(`"${name}" must be a string or null, but got ${JSON.stringify(bitrate)}`);
+    }
+    if (!bitrate.endsWith('K') &&
+        !bitrate.endsWith('k') &&
+        !bitrate.endsWith('M')) {
+        throw new TypeError(`"${name}" must end in "K", "k" or "M", but got ${JSON.stringify(bitrate)}`);
+    }
+};
+exports.validateBitrate = validateBitrate;