@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/symbolicate-stacktrace.d.ts

@@ -1,15 +1,28 @@
+import type { BasicSourceMapConsumer, IndexedSourceMapConsumer } from 'source-map';
+import { SourceMapConsumer } from 'source-map';
 import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
-declare type ScriptLine = {
+type ScriptLine = {
     lineNumber: number;
     content: string;
     highlight: boolean;
 };
-export declare type SymbolicatedStackFrame = {
+export type SymbolicatedStackFrame = {
     originalFunctionName: string | null;
     originalFileName: string | null;
     originalLineNumber: number | null;
     originalColumnNumber: number | null;
     originalScriptCode: ScriptLine[] | null;
 };
-export declare const symbolicateStackTrace: (frames: UnsymbolicatedStackFrame[]) => Promise<SymbolicatedStackFrame[]>;
+export declare const symbolicateStackTraceFromRemoteFrames: (frames: UnsymbolicatedStackFrame[]) => Promise<SymbolicatedStackFrame[]>;
+export declare const symbolicateFromSources: (frames: UnsymbolicatedStackFrame[], mapValues: Record<string, SourceMapConsumer | null>) => SymbolicatedStackFrame[];
+export declare const symbolicateStackFrame: (frame: UnsymbolicatedStackFrame, map: SourceMapConsumer) => {
+    originalColumnNumber: number | null;
+    originalFileName: string | null;
+    originalFunctionName: string | null;
+    originalLineNumber: number | null;
+    originalScriptCode: ScriptLine[] | null;
+};
+export declare const getSourceMapFromRemoteFile: (fileName: string) => Promise<IndexedSourceMapConsumer | null>;
+export declare const getSourceMapFromLocalFile: (fileName: string) => Promise<IndexedSourceMapConsumer | null>;
+export type AnySourceMapConsumer = BasicSourceMapConsumer | IndexedSourceMapConsumer;
 export {};

package/dist/symbolicate-stacktrace.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbolicateStackTrace = void 0;
+exports.getSourceMapFromLocalFile = exports.getSourceMapFromRemoteFile = exports.symbolicateStackFrame = exports.symbolicateFromSources = exports.symbolicateStackTraceFromRemoteFrames = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
 const source_map_1 = require("source-map");
 const read_file_1 = require("./assets/read-file");
 const truthy_1 = require("./truthy");
@@ -19,7 +24,7 @@ function extractSourceMapUrl(fileContents) {
     }
     return match[1].toString();
 }
-async function getSourceMap(fileUri, fileContents) {
+const getSourceMap = async (filePath, fileContents, type) => {
     const sm = extractSourceMapUrl(fileContents);
     if (sm === null) {
         return null;
@@ -33,11 +38,16 @@ async function getSourceMap(fileUri, fileContents) {
         const converted = window.atob(sm.substring(match2[0].length));
         return new source_map_1.SourceMapConsumer(JSON.parse(converted));
     }
-    const index = fileUri.lastIndexOf('/');
-    const url = fileUri.substring(0, index + 1) + sm;
+    if (type === 'local') {
+        // Find adjacent file: bundle.js -> bundle.js.map
+        const newFilePath = path_1.default.join(path_1.default.dirname(filePath), sm);
+        return new source_map_1.SourceMapConsumer((0, fs_1.readFileSync)(newFilePath, 'utf8'));
+    }
+    const index = filePath.lastIndexOf('/');
+    const url = filePath.substring(0, index + 1) + sm;
     const obj = await fetchUrl(url);
     return new source_map_1.SourceMapConsumer(obj);
-}
+};
 const fetchUrl = async (url) => {
     const res = await (0, read_file_1.readFile)(url);
     return new Promise((resolve, reject) => {
@@ -69,42 +79,57 @@ const getOriginalPosition = (source_map, line, column) => {
     });
     return { line: result.line, column: result.column, source: result.source };
 };
-const symbolicateStackTrace = async (frames) => {
+const symbolicateStackTraceFromRemoteFrames = async (frames) => {
     const uniqueFileNames = [
         ...new Set(frames
             .map((f) => f.fileName)
             .filter((f) => f.startsWith('http://') || f.startsWith('https://'))
             .filter(truthy_1.truthy)),
     ];
-    const maps = await Promise.all(uniqueFileNames.map(async (fileName) => {
-        const fileContents = await fetchUrl(fileName);
-        return getSourceMap(fileName, fileContents);
+    const maps = await Promise.all(uniqueFileNames.map((fileName) => {
+        return (0, exports.getSourceMapFromRemoteFile)(fileName);
     }));
     const mapValues = {};
     for (let i = 0; i < uniqueFileNames.length; i++) {
         mapValues[uniqueFileNames[i]] = maps[i];
     }
+    return (0, exports.symbolicateFromSources)(frames, mapValues);
+};
+exports.symbolicateStackTraceFromRemoteFrames = symbolicateStackTraceFromRemoteFrames;
+const symbolicateFromSources = (frames, mapValues) => {
     return frames
         .map((frame) => {
         const map = mapValues[frame.fileName];
         if (!map) {
             return null;
         }
-        const pos = getOriginalPosition(map, frame.lineNumber, frame.columnNumber);
-        const { functionName } = frame;
-        let hasSource = null;
-        hasSource = pos.source ? map.sourceContentFor(pos.source, false) : null;
-        const scriptCode = hasSource && pos.line
-            ? getLinesAround(pos.line, 3, hasSource.split('\n'))
-            : null;
-        return {
-            originalColumnNumber: pos.column,
-            originalFileName: pos.source,
-            originalFunctionName: functionName,
-            originalLineNumber: pos.line ? pos.line : null,
-            originalScriptCode: scriptCode,
-        };
+        return (0, exports.symbolicateStackFrame)(frame, map);
     })
         .filter(truthy_1.truthy);
 };
-exports.symbolicateStackTrace = symbolicateStackTrace;
+exports.symbolicateFromSources = symbolicateFromSources;
+const symbolicateStackFrame = (frame, map) => {
+    const pos = getOriginalPosition(map, frame.lineNumber, frame.columnNumber);
+    const hasSource = pos.source ? map.sourceContentFor(pos.source, false) : null;
+    const scriptCode = hasSource && pos.line
+        ? getLinesAround(pos.line, 3, hasSource.split('\n'))
+        : null;
+    return {
+        originalColumnNumber: pos.column,
+        originalFileName: pos.source,
+        originalFunctionName: frame.functionName,
+        originalLineNumber: pos.line,
+        originalScriptCode: scriptCode,
+    };
+};
+exports.symbolicateStackFrame = symbolicateStackFrame;
+const getSourceMapFromRemoteFile = async (fileName) => {
+    const fileContents = await fetchUrl(fileName);
+    return getSourceMap(fileName, fileContents, 'remote');
+};
+exports.getSourceMapFromRemoteFile = getSourceMapFromRemoteFile;
+const getSourceMapFromLocalFile = (fileName) => {
+    const fileContents = (0, fs_1.readFileSync)(fileName, 'utf8');
+    return getSourceMap(fileName, fileContents, 'local');
+};
+exports.getSourceMapFromLocalFile = getSourceMapFromLocalFile;

package/dist/take-frame-and-compose.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { TAsset } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { Page } from './browser/BrowserPage';
+import type { Compositor } from './compositor/compositor';
+import type { StillImageFormat, VideoImageFormat } from './image-format';
+export declare const takeFrameAndCompose: ({ freePage, imageFormat, jpegQuality, frame, width, height, output, scale, downloadMap, wantsBuffer, compositor, }: {
+    freePage: Page;
+    imageFormat: VideoImageFormat | StillImageFormat;
+    jpegQuality: number | undefined;
+    frame: number;
+    height: number;
+    width: number;
+    output: string | null;
+    scale: number;
+    downloadMap: DownloadMap;
+    wantsBuffer: boolean;
+    compositor: Compositor;
+}) => Promise<{
+    buffer: Buffer | null;
+    collectedAssets: TAsset[];
+}>;

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/truthy.d.ts

@@ -1,3 +1,3 @@
-declare type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
 export declare function truthy<T>(value: T): value is Truthy<T>;
 export {};

package/dist/types.d.ts

@@ -1,8 +1,8 @@
 import type { RenderAssetInfo } from './assets/download-map';
-export declare type RenderFramesOutput = {
+export type RenderFramesOutput = {
     frameCount: number;
     assetsInfo: RenderAssetInfo;
 };
-export declare type OnStartData = {
+export type OnStartData = {
     frameCount: number;
 };

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-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-opengl-renderer.d.ts

@@ -1,5 +1,4 @@
-declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
-export declare type OpenGlRenderer = typeof validRenderers[number];
+export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
+export type OpenGlRenderer = typeof validOpenGlRenderers[number];
 export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
 export declare const validateOpenGlRenderer: (option: OpenGlRenderer | null) => OpenGlRenderer | null;
-export {};

package/dist/validate-opengl-renderer.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOpenGlRenderer = exports.DEFAULT_OPENGL_RENDERER = void 0;
-const validRenderers = ['swangle', 'angle', 'egl', 'swiftshader'];
+exports.validateOpenGlRenderer = exports.DEFAULT_OPENGL_RENDERER = exports.validOpenGlRenderers = void 0;
+exports.validOpenGlRenderers = [
+    'swangle',
+    'angle',
+    'egl',
+    'swiftshader',
+];
 exports.DEFAULT_OPENGL_RENDERER = null;
 const validateOpenGlRenderer = (option) => {
     if (option === null) {
         return null;
     }
-    if (!validRenderers.includes(option)) {
-        throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${validRenderers.join(', ')}`);
+    if (!exports.validOpenGlRenderers.includes(option)) {
+        throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${exports.validOpenGlRenderers.join(', ')}`);
     }
     return option;
 };

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,6 +8,7 @@ const validatePuppeteerTimeout = (timeoutInMilliseconds) => {
     if (typeof timeoutInMilliseconds !== 'number') {
         throw new TypeError(`'timeoutInMilliseconds' should be a number, but is: ${JSON.stringify(timeoutInMilliseconds)}`);
     }
+    // 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}`);
     }

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;