@remotion/renderer 4.0.0-webhook.26 → 4.0.0

package/dist/call-ffmpeg.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFf = exports.dynamicLibraryPathOptions = void 0;
+const execa_1 = __importDefault(require("execa"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const get_executable_path_1 = require("./compositor/get-executable-path");
+const truthy_1 = require("./truthy");
+const dynamicLibraryPathOptions = () => {
+    const lib = node_path_1.default.join((0, get_executable_path_1.getExecutablePath)('ffmpeg-cwd'), 'remotion', 'lib');
+    return {
+        env: {
+            RUST_BACKTRACE: 'full',
+            ...(process.platform === 'darwin'
+                ? {
+                    DYLD_LIBRARY_PATH: lib,
+                }
+                : process.platform === 'win32'
+                    ? {
+                        PATH: `${process.env.PATH};${lib}`,
+                    }
+                    : {
+                        LD_LIBRARY_PATH: lib,
+                    }),
+        },
+    };
+};
+exports.dynamicLibraryPathOptions = dynamicLibraryPathOptions;
+const callFf = (bin, args, options) => {
+    const executablePath = (0, get_executable_path_1.getExecutablePath)(bin);
+    if (!process.env.READ_ONLY_FS) {
+        (0, node_fs_1.chmodSync)(executablePath, 0o755);
+    }
+    return (0, execa_1.default)(executablePath, args.filter(truthy_1.truthy), {
+        ...(0, exports.dynamicLibraryPathOptions)(),
+        ...options,
+    });
+};
+exports.callFf = callFf;

package/dist/chalk/index.d.ts

@@ -0,0 +1,55 @@
+type Style = {
+    codes: [number, number];
+    name: string;
+    wrap?: (input: string, newline: boolean) => string;
+};
+type Method = (str: string) => string;
+type Colors = {
+    enabled: () => boolean;
+    visible: boolean;
+    styles: Record<string, Style>;
+    keys: Record<string, string[]>;
+    alias?: (name: string, col: string) => void;
+};
+type ColorsWithMethods = Colors & {
+    reset: Method;
+    bold: Method;
+    dim: Method;
+    italic: Method;
+    underline: Method;
+    inverse: Method;
+    hidden: Method;
+    strikethrough: Method;
+    black: Method;
+    red: Method;
+    green: Method;
+    yellow: Method;
+    blue: Method;
+    magenta: Method;
+    cyan: Method;
+    white: Method;
+    gray: Method;
+    bgBlack: Method;
+    bgRed: Method;
+    bgGreen: Method;
+    bgYellow: Method;
+    bgBlue: Method;
+    bgMagenta: Method;
+    bgWhite: Method;
+    blackBright: Method;
+    redBright: Method;
+    greenBright: Method;
+    yellowBright: Method;
+    blueBright: Method;
+    magentaBright: Method;
+    whiteBright: Method;
+    bgBlackBright: Method;
+    bgRedBright: Method;
+    bgGreenBright: Method;
+    bgYellowBright: Method;
+    bgBlueBright: Method;
+    bgMagentaBright: Method;
+    bgWhiteBright: Method;
+};
+export declare const chalk: ColorsWithMethods;
+export {};

package/dist/chalk/index.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chalk = void 0;
+const is_color_supported_1 = require("./is-color-supported");
+exports.chalk = (() => {
+    const colors = {
+        enabled: () => (0, is_color_supported_1.isColorSupported)(),
+        visible: true,
+        styles: {},
+        keys: {},
+    };
+    const ansi = (st) => {
+        const open = `\u001b[${st.codes[0]}m`;
+        const close = `\u001b[${st.codes[1]}m`;
+        const regex = new RegExp(`\\u001b\\[${st.codes[1]}m`, 'g');
+        st.wrap = (input, newline) => {
+            if (input.includes(close))
+                input = input.replace(regex, close + open);
+            const output = open + input + close;
+            // see https://github.com/chalk/chalk/pull/92, thanks to the
+            // chalk contributors for this fix. However, we've confirmed that
+            // this issue is also present in Windows terminals
+            return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
+        };
+        return st;
+    };
+    const wrap = (sty, input, newline) => {
+        var _a;
+        return (_a = sty.wrap) === null || _a === void 0 ? void 0 : _a.call(sty, input, newline);
+    };
+    const style = (input, stack) => {
+        if (input === '' || input === null || input === undefined)
+            return '';
+        if (colors.enabled() === false)
+            return input;
+        if (colors.visible === false)
+            return '';
+        let str = String(input);
+        const nl = str.includes('\n');
+        let n = stack.length;
+        while (n-- > 0)
+            str = wrap(colors.styles[stack[n]], str, nl);
+        return str;
+    };
+    const define = (name, codes, type) => {
+        colors.styles[name] = ansi({ name, codes });
+        const keys = colors.keys[type] || (colors.keys[type] = []);
+        keys.push(name);
+        Reflect.defineProperty(colors, name, {
+            configurable: true,
+            enumerable: true,
+            set(value) {
+                var _a;
+                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
+            },
+            get() {
+                const color = (input) => style(input, color.stack);
+                Reflect.setPrototypeOf(color, colors);
+                color.stack = this.stack ? this.stack.concat(name) : [name];
+                return color;
+            },
+        });
+    };
+    define('reset', [0, 0], 'modifier');
+    define('bold', [1, 22], 'modifier');
+    define('dim', [2, 22], 'modifier');
+    define('italic', [3, 23], 'modifier');
+    define('underline', [4, 24], 'modifier');
+    define('inverse', [7, 27], 'modifier');
+    define('hidden', [8, 28], 'modifier');
+    define('strikethrough', [9, 29], 'modifier');
+    define('black', [30, 39], 'color');
+    define('red', [31, 39], 'color');
+    define('green', [32, 39], 'color');
+    define('yellow', [33, 39], 'color');
+    define('blue', [34, 39], 'color');
+    define('magenta', [35, 39], 'color');
+    define('cyan', [36, 39], 'color');
+    define('white', [37, 39], 'color');
+    define('gray', [90, 39], 'color');
+    define('grey', [90, 39], 'color');
+    define('bgBlack', [40, 49], 'bg');
+    define('bgRed', [41, 49], 'bg');
+    define('bgGreen', [42, 49], 'bg');
+    define('bgYellow', [43, 49], 'bg');
+    define('bgBlue', [44, 49], 'bg');
+    define('bgMagenta', [45, 49], 'bg');
+    define('bgWhite', [47, 49], 'bg');
+    define('blackBright', [90, 39], 'bright');
+    define('redBright', [91, 39], 'bright');
+    define('greenBright', [92, 39], 'bright');
+    define('yellowBright', [93, 39], 'bright');
+    define('blueBright', [94, 39], 'bright');
+    define('magentaBright', [95, 39], 'bright');
+    define('whiteBright', [97, 39], 'bright');
+    define('bgBlackBright', [100, 49], 'bgBright');
+    define('bgRedBright', [101, 49], 'bgBright');
+    define('bgGreenBright', [102, 49], 'bgBright');
+    define('bgYellowBright', [103, 49], 'bgBright');
+    define('bgBlueBright', [104, 49], 'bgBright');
+    define('bgMagentaBright', [105, 49], 'bgBright');
+    define('bgWhiteBright', [107, 49], 'bgBright');
+    colors.alias = (name, color) => {
+        // @ts-expect-error
+        const fn = colors[color];
+        if (typeof fn !== 'function') {
+            throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
+        }
+        if (!fn.stack) {
+            Reflect.defineProperty(fn, 'name', { value: name });
+            colors.styles[name] = fn;
+            fn.stack = [name];
+        }
+        Reflect.defineProperty(colors, name, {
+            configurable: true,
+            enumerable: true,
+            set(value) {
+                var _a;
+                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
+            },
+            get() {
+                const col = (input) => style(input, col.stack);
+                Reflect.setPrototypeOf(col, colors);
+                col.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
+                return col;
+            },
+        });
+    };
+    return colors;
+})();

package/dist/chalk/is-color-supported.d.ts

@@ -0,0 +1 @@
+export declare const isColorSupported: () => boolean;

package/dist/chalk/is-color-supported.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isColorSupported = void 0;
+const tty = __importStar(require("tty"));
+const isColorSupported = () => {
+    var _a;
+    const env = process.env || {};
+    const isForceDisabled = 'NO_COLOR' in env;
+    if (isForceDisabled) {
+        return false;
+    }
+    const isForced = 'FORCE_COLOR' in env;
+    if (isForced) {
+        return true;
+    }
+    const isWindows = process.platform === 'win32';
+    const isCompatibleTerminal = ((_a = tty === null || tty === void 0 ? void 0 : tty.isatty) === null || _a === void 0 ? void 0 : _a.call(tty, 1)) && env.TERM && env.TERM !== 'dumb';
+    const isCI = 'CI' in env &&
+        ('GITHUB_ACTIONS' in env || 'GITLAB_CI' in env || 'CIRCLECI' in env);
+    return isWindows || isCompatibleTerminal || isCI;
+};
+exports.isColorSupported = isColorSupported;

package/dist/check-apple-silicon.d.ts

@@ -1 +1 @@
-export declare const warnIfAppleSiliconIsNotUsingArm64Architecture: () => void;
+export declare const checkNodeVersionAndWarnAboutRosetta: () => void;

package/dist/check-apple-silicon.js

@@ -1,51 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnIfAppleSiliconIsNotUsingArm64Architecture = void 0;
-const os = __importStar(require("os"));
-const warnIfAppleSiliconIsNotUsingArm64Architecture = () => {
-    // see https://github.com/nodejs/node/issues/41900#issuecomment-1113511254
-    const cpus = os.cpus();
-    const isAppleSilicon = cpus[0].model.includes('Apple');
-    const isArm64 = os.arch() === 'arm64';
-    if (isAppleSilicon && !isArm64) {
-        const recommendedNodeVersion = 16;
-        const version = process.version.replace('v', '').split('.');
-        const majorVersion = Number(version[0]);
-        const recommendNodeUpgrade = majorVersion < recommendedNodeVersion;
-        console.warn([
-            `⚠️  Apple Silicon detected but Node.JS running under Rosetta. This will cause performance issues.\n`,
-            `Recommended actions:\n`,
-            recommendNodeUpgrade
-                ? ` - Upgrade to Node ${recommendedNodeVersion} or later\n`
-                : ' - Run Node using `arch -arm64` architecture\n',
-            'See https://remotion.dev/docs/troubleshooting/rosetta for more information.',
-            '---',
-        ]
-            .filter(Boolean)
-            .join('\n'));
+exports.checkNodeVersionAndWarnAboutRosetta = void 0;
+const checkNodeVersionAndWarnAboutRosetta = () => {
+    const version = process.version.replace('v', '').split('.');
+    const majorVersion = Number(version[0]);
+    const requiredNodeVersion = 16;
+    if (majorVersion < 16) {
+        throw new Error(`Remotion requires at least Node ${requiredNodeVersion}. You currently have ${process.version}. Update your node version to ${requiredNodeVersion} to use Remotion.`);
     }
 };
-exports.warnIfAppleSiliconIsNotUsingArm64Architecture = warnIfAppleSiliconIsNotUsingArm64Architecture;
+exports.checkNodeVersionAndWarnAboutRosetta = checkNodeVersionAndWarnAboutRosetta;

package/dist/client.d.ts

@@ -0,0 +1,204 @@
+export declare const BrowserSafeApis: {
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
+    validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
+    getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
+    isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
+    validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
+    DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: const[];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["aac", "pcm-16"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                [x: string]: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+    };
+    defaultAudioCodecs: {
+        h264: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        h265: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        vp8: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        vp9: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        mp3: {
+            compressed: "mp3" | "pcm-16" | null;
+            lossless: "mp3" | "pcm-16" | null;
+        };
+        aac: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        wav: {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        prores: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        "h264-mkv": {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        gif: {
+            compressed: any;
+            lossless: any;
+        };
+    };
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
+    validateOutputFilename: <T_1 extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+        codec: T_1;
+        audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+        extension: string;
+        preferLossless: boolean;
+    }) => void;
+    options: {
+        scaleOption: import(".").RemotionOption;
+        crfOption: import(".").RemotionOption;
+        jpegQualityOption: import(".").RemotionOption;
+        videoBitrate: import(".").RemotionOption;
+        audioBitrateOption: import(".").RemotionOption;
+        enforceAudioOption: import(".").RemotionOption;
+        muteOption: import(".").RemotionOption;
+        videoCodecOption: import(".").RemotionOption;
+    };
+    codecSupportsCrf: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    codecSupportsVideoBitrate: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+};

package/dist/client.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserSafeApis = void 0;
+const audio_codec_1 = require("./audio-codec");
+const codec_1 = require("./codec");
+const codec_supports_media_1 = require("./codec-supports-media");
+const crf_1 = require("./crf");
+const file_extensions_1 = require("./file-extensions");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const is_audio_codec_1 = require("./is-audio-codec");
+const audio_bitrate_1 = require("./options/audio-bitrate");
+const crf_2 = require("./options/crf");
+const enforce_audio_1 = require("./options/enforce-audio");
+const jpeg_quality_1 = require("./options/jpeg-quality");
+const mute_1 = require("./options/mute");
+const scale_1 = require("./options/scale");
+const video_bitrate_1 = require("./options/video-bitrate");
+const video_codec_1 = require("./options/video-codec");
+const pixel_format_1 = require("./pixel-format");
+const prores_profile_1 = require("./prores-profile");
+const validate_output_filename_1 = require("./validate-output-filename");
+exports.BrowserSafeApis = {
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+    validCodecs: codec_1.validCodecs,
+    validAudioCodecs: audio_codec_1.validAudioCodecs,
+    getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
+    getValidCrfRanges: crf_1.getValidCrfRanges,
+    isAudioCodec: is_audio_codec_1.isAudioCodec,
+    proResProfileOptions: prores_profile_1.proResProfileOptions,
+    validPixelFormats: pixel_format_1.validPixelFormats,
+    DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    supportedAudioCodecs: audio_codec_1.supportedAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    defaultAudioCodecs: audio_codec_1.defaultAudioCodecs,
+    defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
+    validateOutputFilename: validate_output_filename_1.validateOutputFilename,
+    options: {
+        scaleOption: scale_1.scaleOption,
+        crfOption: crf_2.crfOption,
+        jpegQualityOption: jpeg_quality_1.jpegQualityOption,
+        videoBitrate: video_bitrate_1.videoBitrate,
+        audioBitrateOption: audio_bitrate_1.audioBitrateOption,
+        enforceAudioOption: enforce_audio_1.enforceAudioOption,
+        muteOption: mute_1.muteOption,
+        videoCodecOption: video_codec_1.videoCodecOption,
+    },
+    codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
+    codecSupportsVideoBitrate: codec_supports_media_1.codecSupportsVideoBitrate,
+};

package/dist/codec-supports-media.d.ts

@@ -1,8 +1,9 @@
 import type { Codec } from './codec';
-declare type MediaSupport = {
+type MediaSupport = {
     video: boolean;
     audio: boolean;
 };
 export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
-export declare const codecSupportsCrf: (codec: Codec) => boolean | "" | null;
+export declare const codecSupportsCrf: (codec: Codec) => boolean;
+export declare const codecSupportsVideoBitrate: (codec: Codec) => boolean;
 export {};

package/dist/codec-supports-media.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codecSupportsCrf = exports.codecSupportsMedia = void 0;
-const get_codec_name_1 = require("./get-codec-name");
+exports.codecSupportsVideoBitrate = exports.codecSupportsCrf = exports.codecSupportsMedia = void 0;
+const crf_1 = require("./crf");
 const support = {
     'h264-mkv': {
         audio: true,
@@ -48,9 +48,24 @@ const codecSupportsMedia = (codec) => {
     return support[codec];
 };
 exports.codecSupportsMedia = codecSupportsMedia;
+const codecSupportsVideoBitrateMap = {
+    'h264-mkv': true,
+    aac: false,
+    gif: false,
+    h264: true,
+    h265: true,
+    mp3: false,
+    prores: false,
+    vp8: true,
+    vp9: true,
+    wav: false,
+};
 const codecSupportsCrf = (codec) => {
-    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
-    const supportsCrf = encoderName && codec !== 'prores';
-    return supportsCrf;
+    const range = (0, crf_1.getValidCrfRanges)(codec);
+    return range[0] !== range[1];
 };
 exports.codecSupportsCrf = codecSupportsCrf;
+const codecSupportsVideoBitrate = (codec) => {
+    return codecSupportsVideoBitrateMap[codec];
+};
+exports.codecSupportsVideoBitrate = codecSupportsVideoBitrate;

package/dist/codec.d.ts

@@ -1,4 +1,4 @@
 export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
-export declare type Codec = typeof validCodecs[number];
-export declare type CodecOrUndefined = Codec | undefined;
+export type Codec = typeof validCodecs[number];
+export type CodecOrUndefined = Codec | undefined;
 export declare const DEFAULT_CODEC: Codec;