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

package/dist/browser/should-log-message.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChromeLogLocation = exports.formatChromeMessage = exports.parseBrowserLogMessage = exports.shouldLogBrowserMessage = void 0;
+const shouldLogBrowserMessage = (message) => {
+    // Not relevant for the user
+    if (message.startsWith('DevTools listening on')) {
+        return false;
+    }
+    // Noisy but harmless warning
+    if (message.includes('Failed to send GpuControl.CreateCommandBuffer')) {
+        return false;
+    }
+    return true;
+};
+exports.shouldLogBrowserMessage = shouldLogBrowserMessage;
+const parseBrowserLogMessage = (input) => {
+    const format = /^\[([0-9]{4})\/([0-9]{6})\.([0-9]{6}):([A-Z]+):(.*)\(([0-9]+)\)\](.*)/;
+    const match = input.match(format);
+    if (!match) {
+        return null;
+    }
+    const date = match[1];
+    const day = parseInt(date.slice(0, 2), 10);
+    const month = parseInt(date.slice(2, 4), 10);
+    const time = match[2];
+    const hour = parseInt(time.slice(0, 2), 10);
+    const minute = parseInt(time.slice(2, 4), 10);
+    const seconds = parseInt(time.slice(4, 6), 10);
+    const microseconds = parseInt(match[3], 10);
+    const level = match[4];
+    const location = match[5];
+    const lineNumber = parseInt(match[6], 10);
+    const message = match[7].trim();
+    return {
+        day,
+        month,
+        hour,
+        minute,
+        seconds,
+        microseconds,
+        level,
+        location,
+        lineNumber,
+        message,
+    };
+};
+exports.parseBrowserLogMessage = parseBrowserLogMessage;
+const formatChromeMessage = (input) => {
+    const parsed = (0, exports.parseBrowserLogMessage)(input);
+    if (!parsed) {
+        return { output: input, tag: 'chrome' };
+    }
+    const { location, lineNumber, message } = parsed;
+    // Don't print console.log's, these are handled through the WebSocket
+    if (location === 'CONSOLE') {
+        return null;
+    }
+    return { output: `${location}:${lineNumber}: ${message}`, tag: 'chrome' };
+};
+exports.formatChromeMessage = formatChromeMessage;
+const parseChromeLogLocation = (message) => {
+    const regex = /(.*), source: (.*) \(([0-9]+)\)/;
+    const match = message.match(regex);
+    if (!match) {
+        return null;
+    }
+    return {
+        lineNumber: parseInt(match[3], 10),
+        location: match[2],
+    };
+};
+exports.parseChromeLogLocation = parseChromeLogLocation;

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

@@ -1 +1 @@
-export declare type BrowserExecutable = string | null;
+export type BrowserExecutable = string | null;

package/dist/browser-log.d.ts

@@ -1,5 +1,5 @@
 import type { ConsoleMessageLocation, ConsoleMessageType } from './browser/ConsoleMessage';
-export declare type BrowserLog = {
+export type BrowserLog = {
     text: string;
     stackTrace: ConsoleMessageLocation[];
     type: ConsoleMessageType;

package/dist/browser.d.ts

@@ -1,2 +1,2 @@
-export declare type Browser = 'chrome' | 'firefox';
+export type Browser = 'chrome' | 'firefox';
 export declare const DEFAULT_BROWSER: Browser;

package/dist/calculate-ffmpeg-filters.d.ts

@@ -1,8 +1,9 @@
 import type { MediaAsset } from './assets/types';
+import type { FilterWithoutPaddingApplied } from './stringify-ffmpeg-filter';
 export declare const calculateFfmpegFilter: ({ asset, fps, durationInFrames, channels, assetDuration, }: {
     asset: MediaAsset;
     fps: number;
     durationInFrames: number;
     channels: number;
     assetDuration: number | null;
-}) => string | null;
+}) => FilterWithoutPaddingApplied | null;

package/dist/calculate-ffmpeg-filters.js

@@ -19,6 +19,7 @@ const calculateFfmpegFilter = ({ asset, fps, durationInFrames, channels, assetDu
         playbackRate: asset.playbackRate,
         durationInFrames,
         assetDuration,
+        allowAmplificationDuringRender: asset.allowAmplificationDuringRender,
     });
 };
 exports.calculateFfmpegFilter = calculateFfmpegFilter;

package/dist/call-ffmpeg.d.ts

@@ -0,0 +1,14 @@
+import execa from 'execa';
+export declare const dynamicLibraryPathOptions: () => {
+    env: {
+        DYLD_LIBRARY_PATH: string;
+        RUST_BACKTRACE: string;
+    } | {
+        PATH: string;
+        RUST_BACKTRACE: string;
+    } | {
+        LD_LIBRARY_PATH: string;
+        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

@@ -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,54 @@
+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;
+    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/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;