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

package/dist/browser/NodeWebSocketTransport.js

@@ -28,8 +28,8 @@ exports.NodeWebSocketTransport = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const dns_1 = require("dns");
-const url_1 = require("url");
+const node_dns_1 = require("node:dns");
+const node_url_1 = require("node:url");
 const ws_types_1 = require("../ws/ws-types");
 class NodeWebSocketTransport {
     constructor(ws) {
@@ -56,9 +56,9 @@ class NodeWebSocketTransport {
         // manually with the previous behavior according to:
         // - https://nodejs.org/api/dns.html#dnslookuphostname-options-callback
         // because of https://bugzilla.mozilla.org/show_bug.cgi?id=1769994.
-        const url = new url_1.URL(urlString);
+        const url = new node_url_1.URL(urlString);
         if (url.hostname === 'localhost') {
-            const { address } = await dns_1.promises.lookup(url.hostname, { verbatim: false });
+            const { address } = await node_dns_1.promises.lookup(url.hostname, { verbatim: false });
             url.hostname = address;
         }
         return new Promise((resolve, reject) => {

package/dist/browser/PuppeteerNode.d.ts

@@ -13,10 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Browser } from './Browser';
+import type { HeadlessBrowser } from './Browser';
 import type { BrowserConnectOptions } from './BrowserConnector';
-import type { BrowserFetcherOptions } from './BrowserFetcher';
-import { BrowserFetcher } from './BrowserFetcher';
 import type { ProductLauncher } from './Launcher';
 import type { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
 import type { Product } from './Product';
@@ -31,10 +29,9 @@ export declare class PuppeteerNode {
         preferredRevision: string;
         productName?: Product;
     });
-    launch(options: PuppeteerLaunchOptions): Promise<Browser>;
+    launch(options: PuppeteerLaunchOptions): Promise<HeadlessBrowser>;
     executablePath(channel?: string): string;
     get _launcher(): ProductLauncher;
     get product(): string;
-    createBrowserFetcher(options: BrowserFetcherOptions): BrowserFetcher;
 }
 export {};

package/dist/browser/PuppeteerNode.js

@@ -28,7 +28,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _PuppeteerNode_lazyLauncher, _PuppeteerNode_productName;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PuppeteerNode = void 0;
-const BrowserFetcher_1 = require("./BrowserFetcher");
 const Launcher_1 = require("./Launcher");
 const revisions_1 = require("./revisions");
 class PuppeteerNode {
@@ -40,7 +39,6 @@ class PuppeteerNode {
         this._preferredRevision = preferredRevision;
         this.launch = this.launch.bind(this);
         this.executablePath = this.executablePath.bind(this);
-        this.createBrowserFetcher = this.createBrowserFetcher.bind(this);
     }
     launch(options) {
         if (options.product) {
@@ -66,9 +64,6 @@ class PuppeteerNode {
     get product() {
         return this._launcher.product;
     }
-    createBrowserFetcher(options) {
-        return new BrowserFetcher_1.BrowserFetcher(options);
-    }
 }
 exports.PuppeteerNode = PuppeteerNode;
 _PuppeteerNode_lazyLauncher = new WeakMap(), _PuppeteerNode_productName = new WeakMap();

package/dist/browser/Target.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Browser, BrowserContext } from './Browser';
+import type { BrowserContext, HeadlessBrowser } from './Browser';
 import { Page } from './BrowserPage';
 import type { CDPSession } from './Connection';
 import type { TargetInfo } from './devtools-types';
@@ -48,7 +48,7 @@ export declare class Target {
     /**
      * Get the browser the target belongs to.
      */
-    browser(): Browser;
+    browser(): HeadlessBrowser;
     /**
      * Get the browser context the target belongs to.
      */

package/dist/browser/create-browser-fetcher.js

@@ -16,62 +16,48 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadBrowser = void 0;
-const node_1 = require("./node");
+const BrowserFetcher_1 = require("./BrowserFetcher");
 const revisions_1 = require("./revisions");
 const supportedProducts = {
     chrome: 'Chromium',
     firefox: 'Firefox Nightly',
 };
-async function downloadBrowser(product) {
-    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
-        product,
-        path: null,
-        platform: null,
-    });
-    const revision = await getRevision();
-    await fetchBinary(revision);
-    function getRevision() {
-        if (product === 'chrome') {
-            return revisions_1.PUPPETEER_REVISIONS.chromium;
-        }
-        throw new Error(`Unsupported product ${product}`);
+function getRevision(product) {
+    if (product === 'chrome') {
+        return revisions_1.PUPPETEER_REVISIONS.chromium;
     }
-    function fetchBinary(_revision) {
-        const revisionInfo = browserFetcher.revisionInfo(_revision);
-        // Do nothing if the revision is already downloaded.
-        if (revisionInfo.local) {
-            console.log(`${supportedProducts[product]} is already in ${revisionInfo.folderPath}; skipping download.`);
-            return;
-        }
-        function onSuccess(localRevisions) {
-            console.log(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
-            localRevisions = localRevisions.filter((__revision) => {
-                return __revision !== revisionInfo.revision;
-            });
-            const cleanupOldVersions = localRevisions.map((__revision) => {
-                return browserFetcher.remove(__revision);
-            });
-            Promise.all([...cleanupOldVersions]);
-        }
-        function onError(error) {
-            console.error(`ERROR: Failed to set up ${supportedProducts[product]} r${_revision}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`);
-            console.error(error);
-            process.exit(1);
-        }
-        function onProgress(downloadedBytes, totalBytes) {
-            console.log('Downloading', supportedProducts[product], toMegabytes(downloadedBytes) + '/' + toMegabytes(totalBytes));
-        }
-        return browserFetcher
-            .download(revisionInfo.revision, onProgress)
-            .then(() => {
-            return browserFetcher.localRevisions();
+    throw new Error(`Unsupported product ${product}`);
+}
+async function downloadBrowser(product) {
+    const revision = getRevision(product);
+    const revisionInfo = (0, BrowserFetcher_1.getRevisionInfo)(revision, product);
+    try {
+        await (0, BrowserFetcher_1.download)({
+            revision: revisionInfo.revision,
+            progressCallback: (downloadedBytes, totalBytes) => {
+                console.log('Downloading', supportedProducts[product], toMegabytes(downloadedBytes) + '/' + toMegabytes(totalBytes));
+            },
+            product,
+            platform: (0, BrowserFetcher_1.getPlatform)(product),
+            downloadHost: (0, BrowserFetcher_1.getDownloadHost)(product),
+            downloadsFolder: (0, BrowserFetcher_1.getDownloadsFolder)(product),
+        });
+        const _localRevisions = await (0, BrowserFetcher_1.localRevisions)((0, BrowserFetcher_1.getDownloadsFolder)(product), product, (0, BrowserFetcher_1.getPlatform)(product));
+        console.log(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
+        await Promise.all(_localRevisions
+            .filter((__revision) => {
+            return __revision !== revisionInfo.revision;
         })
-            .then(onSuccess)
-            .catch(onError);
+            .map((__revision) => {
+            return (0, BrowserFetcher_1.removeBrowser)(__revision, (0, BrowserFetcher_1.getFolderPath)(revision, (0, BrowserFetcher_1.getDownloadsFolder)(product), (0, BrowserFetcher_1.getPlatform)(product)));
+        }));
     }
-    function toMegabytes(bytes) {
-        const mb = bytes / 1024 / 1024;
-        return `${Math.round(mb * 10) / 10} Mb`;
+    catch (err) {
+        throw new Error(`Failed to set up ${supportedProducts[product]} r${revision}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`);
     }
 }
 exports.downloadBrowser = downloadBrowser;
+function toMegabytes(bytes) {
+    const mb = bytes / 1024 / 1024;
+    return `${Math.round(mb * 10) / 10} Mb`;
+}

package/dist/browser/get-download-destination.js

@@ -4,20 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDownloadsCacheDir = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const getDownloadsCacheDir = () => {
     const cwd = process.cwd();
     let dir = cwd;
     for (;;) {
         try {
-            if (fs_1.default.statSync(path_1.default.join(dir, 'package.json')).isFile()) {
+            if (node_fs_1.default.statSync(node_path_1.default.join(dir, 'package.json')).isFile()) {
                 break;
             }
             // eslint-disable-next-line no-empty
         }
         catch (e) { }
-        const parent = path_1.default.dirname(dir);
+        const parent = node_path_1.default.dirname(dir);
         if (dir === parent) {
             dir = undefined;
             break;
@@ -25,14 +25,14 @@ const getDownloadsCacheDir = () => {
         dir = parent;
     }
     if (!dir) {
-        return path_1.default.resolve(cwd, '.remotion');
+        return node_path_1.default.resolve(cwd, '.remotion');
     }
     if (process.versions.pnp === '1') {
-        return path_1.default.resolve(dir, '.pnp/.remotion');
+        return node_path_1.default.resolve(dir, '.pnp/.remotion');
     }
     if (process.versions.pnp === '3') {
-        return path_1.default.resolve(dir, '.yarn/.remotion');
+        return node_path_1.default.resolve(dir, '.yarn/.remotion');
     }
-    return path_1.default.resolve(dir, 'node_modules/.remotion');
+    return node_path_1.default.resolve(dir, 'node_modules/.remotion');
 };
 exports.getDownloadsCacheDir = getDownloadsCacheDir;

package/dist/browser/util.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 /// <reference types="node" />
-import type { Browser } from './Browser';
+import type { HeadlessBrowser } from './Browser';
 import type { CDPSession } from './Connection';
 import type { DevtoolsRemoteObject, ExceptionDetails } from './devtools-types';
 import type { CommonEventEmitter } from './EventEmitter';
@@ -37,7 +37,7 @@ export declare function evaluationString(fun: Function | string, ...args: unknow
 export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
 export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
 export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
-export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number, browser: Browser): Promise<T>;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number, browser: HeadlessBrowser): Promise<T>;
 interface ErrorLike extends Error {
     name: string;
     message: string;

package/dist/call-ffmpeg.d.ts

@@ -1,17 +1,14 @@
 import execa from 'execa';
-export declare const callFfExtraOptions: () => {
+export declare const dynamicLibraryPathOptions: () => {
     env: {
         DYLD_LIBRARY_PATH: string;
-        PATH?: undefined;
-        LD_LIBRARY_PATH?: undefined;
+        RUST_BACKTRACE: string;
     } | {
         PATH: string;
-        DYLD_LIBRARY_PATH?: undefined;
-        LD_LIBRARY_PATH?: undefined;
+        RUST_BACKTRACE: string;
     } | {
         LD_LIBRARY_PATH: string;
-        DYLD_LIBRARY_PATH?: undefined;
-        PATH?: undefined;
+        RUST_BACKTRACE: string;
     };
 };
 export declare const callFf: (bin: 'ffmpeg' | 'ffprobe', args: (string | null)[], options?: execa.Options<string>) => execa.ExecaChildProcess<string>;

package/dist/call-ffmpeg.js

@@ -3,31 +3,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callFf = exports.callFfExtraOptions = void 0;
+exports.callFf = exports.dynamicLibraryPathOptions = void 0;
 const execa_1 = __importDefault(require("execa"));
-const path_1 = __importDefault(require("path"));
+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 callFfExtraOptions = () => {
-    const lib = path_1.default.join((0, get_executable_path_1.getExecutablePath)('ffmpeg-cwd'), 'remotion', 'lib');
+const dynamicLibraryPathOptions = () => {
+    const lib = node_path_1.default.join((0, get_executable_path_1.getExecutablePath)('ffmpeg-cwd'), 'remotion', 'lib');
     return {
-        env: process.platform === 'darwin'
-            ? {
-                DYLD_LIBRARY_PATH: lib,
-            }
-            : process.platform === 'win32'
+        env: {
+            RUST_BACKTRACE: 'full',
+            ...(process.platform === 'darwin'
                 ? {
-                    PATH: `${process.env.PATH};${lib}`,
+                    DYLD_LIBRARY_PATH: lib,
                 }
-                : {
-                    LD_LIBRARY_PATH: lib,
-                },
+                : process.platform === 'win32'
+                    ? {
+                        PATH: `${process.env.PATH};${lib}`,
+                    }
+                    : {
+                        LD_LIBRARY_PATH: lib,
+                    }),
+        },
     };
 };
-exports.callFfExtraOptions = callFfExtraOptions;
+exports.dynamicLibraryPathOptions = dynamicLibraryPathOptions;
 const callFf = (bin, args, options) => {
-    return (0, execa_1.default)((0, get_executable_path_1.getExecutablePath)(bin), args.filter(truthy_1.truthy), {
-        ...(0, exports.callFfExtraOptions)(),
+    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,
     });
 };

package/dist/chalk/index.d.ts

@@ -0,0 +1,54 @@
+declare type Style = {
+    codes: [number, number];
+    name: string;
+    wrap?: (input: string, newline: boolean) => string;
+};
+declare type Method = (str: string) => string;
+declare type Colors = {
+    enabled: boolean;
+    visible: boolean;
+    styles: Record<string, Style>;
+    keys: Record<string, string[]>;
+    alias?: (name: string, col: string) => void;
+};
+declare 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;
+    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,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chalk = void 0;
+const is_color_supported_1 = require("./is-color-supported");
+const hasColor = () => {
+    if (typeof process !== 'undefined' && process.env.FORCE_COLOR) {
+        return true;
+    }
+    return is_color_supported_1.isColorSupported;
+};
+exports.chalk = (() => {
+    const colors = {
+        enabled: hasColor(),
+        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('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,37 @@
+"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;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isColorSupported = void 0;
+const tty = __importStar(require("tty"));
+const argv = process.argv || [];
+const env = process.env || {};
+const isDisabled = 'NO_COLOR' in env || argv.includes('--no-color');
+const isForced = 'FORCE_COLOR' in env || argv.includes('--color');
+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);
+exports.isColorSupported = !isDisabled && (isForced || isWindows || isCompatibleTerminal || isCI);

package/dist/client.d.ts

@@ -200,4 +200,5 @@ export declare const BrowserSafeApis: {
         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

@@ -45,4 +45,5 @@ exports.BrowserSafeApis = {
         videoCodecOption: video_codec_1.videoCodecOption,
     },
     codecSupportsCrf: codec_supports_media_1.codecSupportsCrf,
+    codecSupportsVideoBitrate: codec_supports_media_1.codecSupportsVideoBitrate,
 };

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

@@ -5,4 +5,5 @@ declare type MediaSupport = {
 };
 export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
 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 = Boolean(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;