@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/open-browser.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = exports.internalOpenBrowser = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const browser_download_progress_bar_1 = require("./browser/browser-download-progress-bar");
+const Launcher_1 = require("./browser/Launcher");
+const ensure_browser_1 = require("./ensure-browser");
+const get_local_browser_executable_1 = require("./get-local-browser-executable");
+const get_video_threads_flag_1 = require("./get-video-threads-flag");
+const logger_1 = require("./logger");
+const gl_1 = require("./options/gl");
+const featuresToEnable = (option) => {
+    const renderer = option !== null && option !== void 0 ? option : gl_1.DEFAULT_OPENGL_RENDERER;
+    const enableAlways = ['NetworkService', 'NetworkServiceInProcess'];
+    if (renderer === 'vulkan') {
+        return [...enableAlways, 'Vulkan', 'UseSkiaRenderer'];
+    }
+    if (renderer === 'angle-egl') {
+        return [...enableAlways, 'VaapiVideoDecoder'];
+    }
+    return enableAlways;
+};
+const getOpenGlRenderer = (option) => {
+    const renderer = option !== null && option !== void 0 ? option : gl_1.DEFAULT_OPENGL_RENDERER;
+    (0, gl_1.validateOpenGlRenderer)(renderer);
+    if (renderer === 'swangle') {
+        return ['--use-gl=angle', '--use-angle=swiftshader'];
+    }
+    if (renderer === 'angle-egl') {
+        return ['--use-gl=angle', '--use-angle=gl-egl'];
+    }
+    if (renderer === 'vulkan') {
+        return [
+            '--use-angle=vulkan',
+            '--use-vulkan=native',
+            '--disable-vulkan-fallback-to-gl-for-testing',
+            '--disable-vulkan-surface',
+            '--ignore-gpu-blocklist',
+            '--enable-gpu',
+        ];
+    }
+    if (renderer === null) {
+        return [];
+    }
+    return [`--use-gl=${renderer}`];
+};
+const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, onBrowserDownload, chromeMode, }) => {
+    var _a, _b, _c, _d;
+    // @ts-expect-error Firefox
+    if (browser === 'firefox') {
+        throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
+    }
+    logger_1.Log.verbose({ indent, logLevel }, 'Ensuring browser executable');
+    await (0, ensure_browser_1.internalEnsureBrowser)({
+        browserExecutable,
+        logLevel,
+        indent,
+        onBrowserDownload,
+        chromeMode,
+    });
+    logger_1.Log.verbose({ indent, logLevel }, 'Ensured browser is available.');
+    const executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)({
+        preferredBrowserExecutable: browserExecutable,
+        logLevel,
+        indent,
+        chromeMode,
+    });
+    const customGlRenderer = getOpenGlRenderer((_a = chromiumOptions.gl) !== null && _a !== void 0 ? _a : null);
+    const enableMultiProcessOnLinux = (_b = chromiumOptions.enableMultiProcessOnLinux) !== null && _b !== void 0 ? _b : true;
+    logger_1.Log.verbose({ indent, logLevel, tag: 'openBrowser()' }, `Opening browser: gl = ${chromiumOptions.gl}, executable = ${executablePath}, enableMultiProcessOnLinux = ${enableMultiProcessOnLinux}`);
+    if (chromiumOptions.userAgent) {
+        logger_1.Log.verbose({ indent, logLevel, tag: 'openBrowser()' }, `Using custom user agent: ${chromiumOptions.userAgent}`);
+    }
+    const userDataDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'puppeteer_dev_chrome_profile-'));
+    const browserInstance = await (0, Launcher_1.launchChrome)({
+        executablePath,
+        logLevel,
+        indent,
+        userDataDir,
+        timeout: 25000,
+        args: [
+            'about:blank',
+            '--allow-pre-commit-input',
+            '--disable-background-networking',
+            `--enable-features=${featuresToEnable(chromiumOptions.gl).join(',')}`,
+            '--disable-background-timer-throttling',
+            '--disable-backgrounding-occluded-windows',
+            '--disable-breakpad',
+            '--disable-client-side-phishing-detection',
+            '--disable-component-extensions-with-background-pages',
+            '--disable-default-apps',
+            '--disable-dev-shm-usage',
+            '--no-proxy-server',
+            "--proxy-server='direct://'",
+            '--proxy-bypass-list=*',
+            '--force-gpu-mem-available-mb=4096',
+            '--disable-hang-monitor',
+            '--disable-extensions',
+            '--allow-chrome-scheme-url',
+            '--disable-ipc-flooding-protection',
+            '--disable-popup-blocking',
+            '--disable-prompt-on-repost',
+            '--disable-renderer-backgrounding',
+            '--disable-sync',
+            '--force-color-profile=srgb',
+            '--metrics-recording-only',
+            '--mute-audio',
+            '--no-first-run',
+            `--video-threads=${(0, get_video_threads_flag_1.getIdealVideoThreadsFlag)(logLevel)}`,
+            '--enable-automation',
+            '--password-store=basic',
+            '--use-mock-keychain',
+            '--enable-blink-features=IdleDetection',
+            '--export-tagged-pdf',
+            '--intensive-wake-up-throttling-policy=0',
+            ((_c = chromiumOptions.headless) !== null && _c !== void 0 ? _c : true)
+                ? chromeMode === 'chrome-for-testing'
+                    ? '--headless=new'
+                    : '--headless=old'
+                : null,
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            ...customGlRenderer,
+            '--disable-background-media-suspend',
+            process.platform === 'linux' &&
+                chromiumOptions.gl !== 'vulkan' &&
+                !enableMultiProcessOnLinux
+                ? '--single-process'
+                : null,
+            '--allow-running-insecure-content', // https://source.chromium.org/search?q=lang:cpp+symbol:kAllowRunningInsecureContent&ss=chromium
+            '--disable-component-update', // https://source.chromium.org/search?q=lang:cpp+symbol:kDisableComponentUpdate&ss=chromium
+            '--disable-domain-reliability', // https://source.chromium.org/search?q=lang:cpp+symbol:kDisableDomainReliability&ss=chromium
+            '--disable-features=AudioServiceOutOfProcess,IsolateOrigins,site-per-process,Translate,BackForwardCache,AvoidUnnecessaryBeforeUnloadCheckSync,IntensiveWakeUpThrottling', // https://source.chromium.org/search?q=file:content_features.cc&ss=chromium
+            '--disable-print-preview', // https://source.chromium.org/search?q=lang:cpp+symbol:kDisablePrintPreview&ss=chromium
+            '--disable-site-isolation-trials', // https://source.chromium.org/search?q=lang:cpp+symbol:kDisableSiteIsolation&ss=chromium
+            '--disk-cache-size=268435456', // https://source.chromium.org/search?q=lang:cpp+symbol:kDiskCacheSize&ss=chromium
+            '--hide-scrollbars', // https://source.chromium.org/search?q=lang:cpp+symbol:kHideScrollbars&ss=chromium
+            '--no-default-browser-check', // https://source.chromium.org/search?q=lang:cpp+symbol:kNoDefaultBrowserCheck&ss=chromium
+            '--no-pings', // https://source.chromium.org/search?q=lang:cpp+symbol:kNoPings&ss=chromium
+            '--font-render-hinting=none',
+            '--no-zygote', // https://source.chromium.org/search?q=lang:cpp+symbol:kNoZygote&ss=chromium,
+            '--ignore-gpu-blocklist',
+            '--enable-unsafe-webgpu',
+            typeof forceDeviceScaleFactor === 'undefined'
+                ? null
+                : `--force-device-scale-factor=${forceDeviceScaleFactor}`,
+            chromiumOptions.ignoreCertificateErrors
+                ? '--ignore-certificate-errors'
+                : null,
+            ...((chromiumOptions === null || chromiumOptions === void 0 ? void 0 : chromiumOptions.disableWebSecurity)
+                ? ['--disable-web-security']
+                : []),
+            (chromiumOptions === null || chromiumOptions === void 0 ? void 0 : chromiumOptions.userAgent)
+                ? `--user-agent="${chromiumOptions.userAgent}"`
+                : null,
+            '--remote-debugging-port=0',
+            `--user-data-dir=${userDataDir}`,
+        ].filter(Boolean),
+        defaultViewport: viewport !== null && viewport !== void 0 ? viewport : {
+            height: 720,
+            width: 1280,
+            deviceScaleFactor: 1,
+        },
+    });
+    const pages = await browserInstance.pages();
+    await ((_d = pages[0]) === null || _d === void 0 ? void 0 : _d.close());
+    return browserInstance;
+};
+exports.internalOpenBrowser = internalOpenBrowser;
+/*
+ * @description Opens a Chrome or Chromium browser instance. By reusing an instance across various rendering and compositional API calls, significant time can be saved by avoiding the repeated opening and closing of browsers.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/open-browser)
+ */
+const openBrowser = (browser, options) => {
+    var _a, _b;
+    const { browserExecutable, chromiumOptions, forceDeviceScaleFactor } = options !== null && options !== void 0 ? options : {};
+    const indent = false;
+    const logLevel = (_a = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _a !== void 0 ? _a : ((options === null || options === void 0 ? void 0 : options.shouldDumpIo) ? 'verbose' : 'info');
+    return (0, exports.internalOpenBrowser)({
+        browser,
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        forceDeviceScaleFactor,
+        indent,
+        viewport: null,
+        logLevel,
+        onBrowserDownload: (0, browser_download_progress_bar_1.defaultBrowserDownloadProgress)({
+            indent,
+            logLevel,
+            api: 'openBrowser()',
+        }),
+        chromeMode: (_b = options === null || options === void 0 ? void 0 : options.chromeMode) !== null && _b !== void 0 ? _b : 'headless-shell',
+    });
+};
+exports.openBrowser = openBrowser;

package/package/dist/options/api-key.d.ts

@@ -0,0 +1,15 @@
+export declare const apiKeyOption: {
+    name: string;
+    cliFlag: "api-key";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "apiKey";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+};

package/package/dist/options/api-key.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let currentApiKey = null;
+const cliFlag = 'api-key';
+exports.apiKeyOption = {
+    name: 'API key',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["API key for sending a usage event using ", (0, jsx_runtime_1.jsx)("code", { children: "@remotion/licensing" }), "."] })),
+    ssrName: 'apiKey',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    type: null,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        return {
+            source: 'default',
+            value: currentApiKey,
+        };
+    },
+    setConfig: (value) => {
+        currentApiKey = value;
+    },
+};

package/package/dist/options/audio-bitrate.d.ts

@@ -0,0 +1,18 @@
+export declare const audioBitrateOption: {
+    name: string;
+    cliFlag: "audio-bitrate";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: string;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (value: string | null) => void;
+};

package/package/dist/options/audio-bitrate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioBitrateOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'audio-bitrate';
+let audioBitrate = null;
+exports.audioBitrateOption = {
+    name: 'Audio Bitrate',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Specify the target bitrate for the generated video. The syntax for FFmpeg", "'", "s ", (0, jsx_runtime_1.jsx)("code", { children: "-b:a" }), " parameter should be used. FFmpeg may encode the video in a way that will not result in the exact audio bitrate specified. Example values: ", (0, jsx_runtime_1.jsx)("code", { children: "512K" }), " for 512 kbps, ", (0, jsx_runtime_1.jsx)("code", { children: "1M" }), " for 1 Mbps. Default: ", (0, jsx_runtime_1.jsx)("code", { children: "320k" })] })),
+    ssrName: 'audioBitrate',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#audiobitrate-',
+    type: '0',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (audioBitrate) {
+            return {
+                value: audioBitrate,
+                source: 'config file',
+            };
+        }
+        return {
+            value: null,
+            source: 'default',
+        };
+    },
+    setConfig: (value) => {
+        audioBitrate = value;
+    },
+};

package/package/dist/options/audio-codec.d.ts

@@ -0,0 +1,55 @@
+import type { Codec } from '../codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export type AudioCodec = (typeof validAudioCodecs)[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16", "mp3"];
+    readonly 'h264-mkv': readonly ["pcm-16", "mp3"];
+    readonly 'h264-ts': readonly ["pcm-16", "aac"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly avi: readonly [];
+    readonly gif: readonly [];
+    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"];
+};
+declare const audioCodecNames: readonly ["pcm_s16le", "libfdk_aac", "libmp3lame", "libopus"];
+type FfmpegAudioCodecName = (typeof audioCodecNames)[number];
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [_ in 'compressed' | 'lossless']: (typeof supportedAudioCodecs)[key][number] | null;
+    };
+};
+export declare const getExtensionFromAudioCodec: (audioCodec: AudioCodec) => "mp3" | "aac" | "wav" | "opus";
+export declare const resolveAudioCodec: ({ codec, setting, preferLossless, separateAudioTo, }: {
+    setting: AudioCodec | null;
+    codec: Codec;
+    preferLossless: boolean;
+    separateAudioTo: string | null;
+}) => "mp3" | "aac" | "pcm-16" | "opus" | null;
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: Codec;
+    preferLossless: boolean;
+}) => AudioCodec | null;
+export declare const audioCodecOption: {
+    cliFlag: "audio-codec";
+    setConfig: (audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => void;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: AudioCodec;
+    } | {
+        source: string;
+        value: null;
+    };
+    description: () => string;
+    docLink: string;
+    name: string;
+    ssrName: "audioCodec";
+    type: AudioCodec;
+};
+export {};

package/package/dist/options/audio-codec.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioCodecOption = exports.getDefaultAudioCodec = exports.resolveAudioCodec = exports.getExtensionFromAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+const separate_audio_1 = require("./separate-audio");
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16', 'mp3'],
+    'h264-mkv': ['pcm-16', 'mp3'],
+    'h264-ts': ['pcm-16', 'aac'],
+    aac: ['aac', 'pcm-16'],
+    avi: [],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const audioCodecNames = [
+    'pcm_s16le',
+    'libfdk_aac',
+    'libmp3lame',
+    'libopus',
+];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'libfdk_aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+const cliFlag = 'audio-codec';
+const ssrName = 'audioCodec';
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    'h264-ts': {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const extensionMap = {
+    aac: 'aac',
+    mp3: 'mp3',
+    opus: 'opus',
+    'pcm-16': 'wav',
+};
+const getExtensionFromAudioCodec = (audioCodec) => {
+    if (extensionMap[audioCodec]) {
+        return extensionMap[audioCodec];
+    }
+    throw new Error(`Unsupported audio codec: ${audioCodec}`);
+};
+exports.getExtensionFromAudioCodec = getExtensionFromAudioCodec;
+const resolveAudioCodec = ({ codec, setting, preferLossless, separateAudioTo, }) => {
+    let derivedFromSeparateAudioToExtension = null;
+    if (separateAudioTo) {
+        const extension = separateAudioTo.split('.').pop();
+        for (const [key, value] of Object.entries(extensionMap)) {
+            if (value === extension) {
+                derivedFromSeparateAudioToExtension = key;
+                if (!exports.supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) &&
+                    derivedFromSeparateAudioToExtension) {
+                    throw new Error(`The codec is ${codec} but the audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${exports.supportedAudioCodecs[codec].join(', ')}`);
+                }
+            }
+        }
+    }
+    // Explanation: https://github.com/remotion-dev/remotion/issues/1647
+    if (preferLossless) {
+        const selected = (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+        if (derivedFromSeparateAudioToExtension &&
+            selected !== derivedFromSeparateAudioToExtension) {
+            throw new Error(`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+        }
+        return selected;
+    }
+    if (setting === null) {
+        if (derivedFromSeparateAudioToExtension) {
+            return derivedFromSeparateAudioToExtension;
+        }
+        return (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+    }
+    if (derivedFromSeparateAudioToExtension !== setting &&
+        derivedFromSeparateAudioToExtension) {
+        throw new Error(`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${exports.audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+    }
+    return setting;
+};
+exports.resolveAudioCodec = resolveAudioCodec;
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;
+let _audioCodec = null;
+exports.audioCodecOption = {
+    cliFlag,
+    setConfig: (audioCodec) => {
+        if (audioCodec === null) {
+            _audioCodec = null;
+            return;
+        }
+        if (!exports.validAudioCodecs.includes(audioCodec)) {
+            throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${audioCodec}`);
+        }
+        _audioCodec = audioCodec;
+    },
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            const codec = commandLine[cliFlag];
+            if (!exports.validAudioCodecs.includes(commandLine[cliFlag])) {
+                throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${codec}`);
+            }
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (_audioCodec !== null) {
+            return {
+                source: 'config',
+                value: _audioCodec,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
+    docLink: 'https://www.remotion.dev/docs/encoding/#audio-codec',
+    name: 'Audio Codec',
+    ssrName,
+    type: 'aac',
+};

package/package/dist/options/beep-on-finish.d.ts

@@ -0,0 +1,15 @@
+export declare const beepOnFinishOption: {
+    name: string;
+    cliFlag: "beep-on-finish";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

package/package/dist/options/beep-on-finish.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beepOnFinishOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let beepOnFinish = false;
+const cliFlag = 'beep-on-finish';
+exports.beepOnFinishOption = {
+    name: 'Beep on finish',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "Whether the Remotion Studio tab should beep when the render is finished." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setbeeponfinish',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (beepOnFinish !== false) {
+            return {
+                value: beepOnFinish,
+                source: 'config',
+            };
+        }
+        return {
+            value: false,
+            source: 'default',
+        };
+    },
+    setConfig(value) {
+        beepOnFinish = value;
+    },
+};

package/package/dist/options/binaries-directory.d.ts

@@ -0,0 +1,15 @@
+export declare const binariesDirectoryOption: {
+    name: string;
+    cliFlag: "binaries-directory";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "binariesDirectory";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+};

package/package/dist/options/binaries-directory.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binariesDirectoryOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'binaries-directory';
+let currentDirectory = null;
+exports.binariesDirectoryOption = {
+    name: 'Binaries Directory',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["The directory where the platform-specific binaries and libraries that Remotion needs are located. Those include an ", (0, jsx_runtime_1.jsx)("code", { children: "ffmpeg" }), " and", ' ', (0, jsx_runtime_1.jsx)("code", { children: "ffprobe" }), " binary, a Rust binary for various tasks, and various shared libraries. If the value is set to ", (0, jsx_runtime_1.jsx)("code", { children: "null" }), ", which is the default, then the path of a platform-specific package located at", ' ', (0, jsx_runtime_1.jsx)("code", { children: "node_modules/@remotion/compositor-*" }), " is selected.", (0, jsx_runtime_1.jsx)("br", {}), "This option is useful in environments where Remotion is not officially supported to run like bundled serverless functions or Electron."] })),
+    ssrName: 'binariesDirectory',
+    docLink: 'https://www.remotion.dev/docs/renderer',
+    type: '',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentDirectory !== null) {
+            return {
+                source: 'config',
+                value: currentDirectory,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentDirectory = value;
+    },
+};

package/package/dist/options/chrome-mode.d.ts

@@ -0,0 +1,17 @@
+export declare const validChromeModeOptions: readonly ["headless-shell", "chrome-for-testing"];
+export type ChromeMode = (typeof validChromeModeOptions)[number];
+export declare const chromeModeOption: {
+    cliFlag: "chrome-mode";
+    name: string;
+    ssrName: string;
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: ChromeMode;
+        source: string;
+    };
+    setConfig: (newChromeMode: ChromeMode) => void;
+    type: ChromeMode;
+};