@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/index.js

@@ -0,0 +1,227 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderInternals = exports.validateOutputFilename = exports.stitchFramesToVideo = exports.selectComposition = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getVideoMetadata = exports.getSilentParts = exports.getCompositions = exports.extractAudio = exports.ErrorWithStackFrame = exports.ensureBrowser = exports.combineChunks = void 0;
+const execa_1 = __importDefault(require("execa"));
+const download_file_1 = require("./assets/download-file");
+const browser_1 = require("./browser");
+const Browser_1 = require("./browser/Browser");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const chalk_1 = require("./chalk");
+const is_color_supported_1 = require("./chalk/is-color-supported");
+const check_version_requirements_1 = require("./check-version-requirements");
+const codec_1 = require("./codec");
+const get_executable_path_1 = require("./compositor/get-executable-path");
+const convert_to_positive_frame_index_1 = require("./convert-to-positive-frame-index");
+const delete_directory_1 = require("./delete-directory");
+const ensure_output_directory_1 = require("./ensure-output-directory");
+const symbolicate_error_1 = require("./error-handling/symbolicate-error");
+const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
+const file_extensions_1 = require("./file-extensions");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const frame_range_1 = require("./frame-range");
+const get_compositions_1 = require("./get-compositions");
+const get_concurrency_1 = require("./get-concurrency");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
+const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_extension_of_filename_1 = require("./get-extension-of-filename");
+const get_frame_to_render_1 = require("./get-frame-to-render");
+const get_port_1 = require("./get-port");
+const image_format_1 = require("./image-format");
+const is_serve_url_1 = require("./is-serve-url");
+const jpeg_quality_1 = require("./jpeg-quality");
+const log_level_1 = require("./log-level");
+const logger_1 = require("./logger");
+const mime_types_1 = require("./mime-types");
+const open_browser_1 = require("./open-browser");
+const gl_1 = require("./options/gl");
+const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+const perf = __importStar(require("./perf"));
+const pixel_format_1 = require("./pixel-format");
+const port_config_1 = require("./port-config");
+const prepare_server_1 = require("./prepare-server");
+const render_frames_1 = require("./render-frames");
+const render_media_1 = require("./render-media");
+const render_still_1 = require("./render-still");
+const select_composition_1 = require("./select-composition");
+const is_path_inside_1 = require("./serve-handler/is-path-inside");
+const serve_static_1 = require("./serve-static");
+const test_gpu_1 = require("./test-gpu");
+const tmp_dir_1 = require("./tmp-dir");
+const validate_concurrency_1 = require("./validate-concurrency");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+var combine_chunks_1 = require("./combine-chunks");
+Object.defineProperty(exports, "combineChunks", { enumerable: true, get: function () { return combine_chunks_1.combineChunks; } });
+var ensure_browser_1 = require("./ensure-browser");
+Object.defineProperty(exports, "ensureBrowser", { enumerable: true, get: function () { return ensure_browser_1.ensureBrowser; } });
+var handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+Object.defineProperty(exports, "ErrorWithStackFrame", { enumerable: true, get: function () { return handle_javascript_exception_1.ErrorWithStackFrame; } });
+var extract_audio_1 = require("./extract-audio");
+Object.defineProperty(exports, "extractAudio", { enumerable: true, get: function () { return extract_audio_1.extractAudio; } });
+var get_compositions_2 = require("./get-compositions");
+Object.defineProperty(exports, "getCompositions", { enumerable: true, get: function () { return get_compositions_2.getCompositions; } });
+var get_silent_parts_1 = require("./get-silent-parts");
+Object.defineProperty(exports, "getSilentParts", { enumerable: true, get: function () { return get_silent_parts_1.getSilentParts; } });
+var get_video_metadata_1 = require("./get-video-metadata");
+Object.defineProperty(exports, "getVideoMetadata", { enumerable: true, get: function () { return get_video_metadata_1.getVideoMetadata; } });
+var image_format_2 = require("./image-format");
+Object.defineProperty(exports, "validateSelectedPixelFormatAndImageFormatCombination", { enumerable: true, get: function () { return image_format_2.validateSelectedPixelFormatAndImageFormatCombination; } });
+var make_cancel_signal_1 = require("./make-cancel-signal");
+Object.defineProperty(exports, "makeCancelSignal", { enumerable: true, get: function () { return make_cancel_signal_1.makeCancelSignal; } });
+var open_browser_2 = require("./open-browser");
+Object.defineProperty(exports, "openBrowser", { enumerable: true, get: function () { return open_browser_2.openBrowser; } });
+var render_frames_2 = require("./render-frames");
+Object.defineProperty(exports, "renderFrames", { enumerable: true, get: function () { return render_frames_2.renderFrames; } });
+var render_media_2 = require("./render-media");
+Object.defineProperty(exports, "renderMedia", { enumerable: true, get: function () { return render_media_2.renderMedia; } });
+var render_still_2 = require("./render-still");
+Object.defineProperty(exports, "renderStill", { enumerable: true, get: function () { return render_still_2.renderStill; } });
+var select_composition_2 = require("./select-composition");
+Object.defineProperty(exports, "selectComposition", { enumerable: true, get: function () { return select_composition_2.selectComposition; } });
+var stitch_frames_to_video_1 = require("./stitch-frames-to-video");
+Object.defineProperty(exports, "stitchFramesToVideo", { enumerable: true, get: function () { return stitch_frames_to_video_1.stitchFramesToVideo; } });
+var validate_output_filename_1 = require("./validate-output-filename");
+Object.defineProperty(exports, "validateOutputFilename", { enumerable: true, get: function () { return validate_output_filename_1.validateOutputFilename; } });
+const download_map_1 = require("./assets/download-map");
+const can_concat_seamlessly_1 = require("./can-concat-seamlessly");
+const codec_supports_media_1 = require("./codec-supports-media");
+const combine_chunks_2 = require("./combine-chunks");
+const make_file_executable_1 = require("./compositor/make-file-executable");
+const default_on_log_1 = require("./default-on-log");
+const ensure_browser_2 = require("./ensure-browser");
+const audio_codec_1 = require("./options/audio-codec");
+const offthreadvideo_threads_1 = require("./options/offthreadvideo-threads");
+const print_useful_error_message_1 = require("./print-useful-error-message");
+const render_has_audio_1 = require("./render-has-audio");
+const to_megabytes_1 = require("./to-megabytes");
+const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
+const validate_videobitrate_1 = require("./validate-videobitrate");
+const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
+exports.RenderInternals = {
+    resolveConcurrency: get_concurrency_1.resolveConcurrency,
+    serveStatic: serve_static_1.serveStatic,
+    validateEvenDimensionsWithCodec: validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec,
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+    tmpDir: tmp_dir_1.tmpDir,
+    deleteDirectory: delete_directory_1.deleteDirectory,
+    isServeUrl: is_serve_url_1.isServeUrl,
+    ensureOutputDirectory: ensure_output_directory_1.ensureOutputDirectory,
+    getRealFrameRange: get_frame_to_render_1.getRealFrameRange,
+    validatePuppeteerTimeout: validate_puppeteer_timeout_1.validatePuppeteerTimeout,
+    downloadFile: download_file_1.downloadFile,
+    parseStack: parse_browser_error_stack_1.parseStack,
+    symbolicateError: symbolicate_error_1.symbolicateError,
+    SymbolicateableError: symbolicateable_error_1.SymbolicateableError,
+    getFramesToRender: get_duration_from_frame_range_1.getFramesToRender,
+    getExtensionOfFilename: get_extension_of_filename_1.getExtensionOfFilename,
+    getDesiredPort: get_port_1.getDesiredPort,
+    isPathInside: is_path_inside_1.isPathInside,
+    execa: execa_1.default,
+    registerErrorSymbolicationLock: wait_for_symbolication_error_to_be_done_1.registerErrorSymbolicationLock,
+    unlockErrorSymbolicationLock: wait_for_symbolication_error_to_be_done_1.unlockErrorSymbolicationLock,
+    canUseParallelEncoding: can_use_parallel_encoding_1.canUseParallelEncoding,
+    mimeContentType: mime_types_1.mimeContentType,
+    mimeLookup: mime_types_1.mimeLookup,
+    validateConcurrency: validate_concurrency_1.validateConcurrency,
+    validPixelFormats: pixel_format_1.validPixelFormats,
+    DEFAULT_BROWSER: browser_1.DEFAULT_BROWSER,
+    validateFrameRange: frame_range_1.validateFrameRange,
+    DEFAULT_OPENGL_RENDERER: gl_1.DEFAULT_OPENGL_RENDERER,
+    validateOpenGlRenderer: gl_1.validateOpenGlRenderer,
+    validCodecs: codec_1.validCodecs,
+    DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    validateJpegQuality: jpeg_quality_1.validateJpegQuality,
+    DEFAULT_TIMEOUT: TimeoutSettings_1.DEFAULT_TIMEOUT,
+    DEFAULT_CODEC: codec_1.DEFAULT_CODEC,
+    logLevels: log_level_1.logLevels,
+    isEqualOrBelowLogLevel: log_level_1.isEqualOrBelowLogLevel,
+    isValidLogLevel: log_level_1.isValidLogLevel,
+    perf,
+    convertToPositiveFrameIndex: convert_to_positive_frame_index_1.convertToPositiveFrameIndex,
+    findRemotionRoot: find_closest_package_json_1.findRemotionRoot,
+    validateBitrate: validate_videobitrate_1.validateBitrate,
+    getMinConcurrency: validate_concurrency_1.getMinConcurrency,
+    getMaxConcurrency: validate_concurrency_1.getMaxConcurrency,
+    getDefaultAudioCodec: audio_codec_1.getDefaultAudioCodec,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    supportedAudioCodecs: audio_codec_1.supportedAudioCodecs,
+    makeFileExtensionMap: get_extension_from_codec_1.makeFileExtensionMap,
+    defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
+    getExecutablePath: get_executable_path_1.getExecutablePath,
+    callFf: call_ffmpeg_1.callFf,
+    validStillImageFormats: image_format_1.validStillImageFormats,
+    validVideoImageFormats: image_format_1.validVideoImageFormats,
+    DEFAULT_STILL_IMAGE_FORMAT: image_format_1.DEFAULT_STILL_IMAGE_FORMAT,
+    DEFAULT_VIDEO_IMAGE_FORMAT: image_format_1.DEFAULT_VIDEO_IMAGE_FORMAT,
+    DEFAULT_JPEG_QUALITY: jpeg_quality_1.DEFAULT_JPEG_QUALITY,
+    chalk: chalk_1.chalk,
+    Log: logger_1.Log,
+    INDENT_TOKEN: logger_1.INDENT_TOKEN,
+    isColorSupported: is_color_supported_1.isColorSupported,
+    HeadlessBrowser: Browser_1.HeadlessBrowser,
+    prepareServer: prepare_server_1.prepareServer,
+    makeOrReuseServer: prepare_server_1.makeOrReuseServer,
+    internalRenderStill: render_still_1.internalRenderStill,
+    internalOpenBrowser: open_browser_1.internalOpenBrowser,
+    internalSelectComposition: select_composition_1.internalSelectComposition,
+    internalGetCompositions: get_compositions_1.internalGetCompositions,
+    internalRenderFrames: render_frames_1.internalRenderFrames,
+    internalRenderMedia: render_media_1.internalRenderMedia,
+    validOpenGlRenderers: gl_1.validOpenGlRenderers,
+    isIpV6Supported: port_config_1.isIpV6Supported,
+    getChromiumGpuInformation: test_gpu_1.getChromiumGpuInformation,
+    getPortConfig: port_config_1.getPortConfig,
+    makeDownloadMap: download_map_1.makeDownloadMap,
+    getExtensionFromAudioCodec: audio_codec_1.getExtensionFromAudioCodec,
+    makeFileExecutableIfItIsNot: make_file_executable_1.makeFileExecutableIfItIsNot,
+    resolveAudioCodec: audio_codec_1.resolveAudioCodec,
+    getShouldRenderAudio: render_has_audio_1.getShouldRenderAudio,
+    codecSupportsMedia: codec_supports_media_1.codecSupportsMedia,
+    toMegabytes: to_megabytes_1.toMegabytes,
+    internalEnsureBrowser: ensure_browser_2.internalEnsureBrowser,
+    printUsefulErrorMessage: print_useful_error_message_1.printUsefulErrorMessage,
+    DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS: offthreadvideo_threads_1.DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS,
+    canConcatVideoSeamlessly: can_concat_seamlessly_1.canConcatVideoSeamlessly,
+    canConcatAudioSeamlessly: can_concat_seamlessly_1.canConcatAudioSeamlessly,
+    internalCombineChunks: combine_chunks_2.internalCombineChunks,
+    defaultOnLog: default_on_log_1.defaultOnLog,
+};
+// Warn of potential performance issues with Apple Silicon (M1 chip under Rosetta)
+(0, check_version_requirements_1.checkRuntimeVersion)('info', false);

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

@@ -0,0 +1,2 @@
+import type { Codec } from './codec';
+export declare const isAudioCodec: (codec: Codec | undefined | null) => codec is "mp3" | "aac" | "wav";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAudioCodec = void 0;
+const isAudioCodec = (codec) => {
+    return codec === 'mp3' || codec === 'aac' || codec === 'wav';
+};
+exports.isAudioCodec = isAudioCodec;

package/package/dist/is-delay-render-error-with-retry.d.ts

@@ -0,0 +1 @@
+export declare const getRetriesLeftFromError: (error: Error | undefined) => number;

package/package/dist/is-delay-render-error-with-retry.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRetriesLeftFromError = void 0;
+const no_react_1 = require("remotion/no-react");
+const getRetriesLeftFromError = (error) => {
+    if (!error) {
+        throw new Error('Expected stack');
+    }
+    const { stack } = error;
+    if (!stack) {
+        throw new Error('Expected stack: ' + JSON.stringify(error));
+    }
+    const beforeIndex = stack.indexOf(no_react_1.NoReactInternals.DELAY_RENDER_ATTEMPT_TOKEN);
+    if (beforeIndex === -1) {
+        throw new Error('Expected to find attempt token in stack');
+    }
+    const afterIndex = stack.indexOf(no_react_1.NoReactInternals.DELAY_RENDER_RETRY_TOKEN);
+    if (afterIndex === -1) {
+        throw new Error('Expected to find retry token in stack');
+    }
+    const inbetween = stack.substring(beforeIndex + no_react_1.NoReactInternals.DELAY_RENDER_ATTEMPT_TOKEN.length, afterIndex);
+    const parsed = Number(inbetween);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Expected to find a number in the stack ${stack}`);
+    }
+    return parsed;
+};
+exports.getRetriesLeftFromError = getRetriesLeftFromError;

package/package/dist/is-serve-url.d.ts

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

package/package/dist/is-serve-url.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isServeUrl = void 0;
+const isServeUrl = (potentialUrl) => {
+    if (typeof potentialUrl === 'undefined') {
+        throw new Error('serveUrl is undefined');
+    }
+    // Theoretically not a valid URL but handle the most basic cases of forgetting protocol in front
+    if (potentialUrl.startsWith('www.') ||
+        potentialUrl.includes('amazonaws.com')) {
+        return true;
+    }
+    return (potentialUrl.startsWith('https://') || potentialUrl.startsWith('http://'));
+};
+exports.isServeUrl = isServeUrl;

package/package/dist/jpeg-quality.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_JPEG_QUALITY = 80;
+export declare const validateJpegQuality: (q: unknown) => void;

package/package/dist/jpeg-quality.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJpegQuality = exports.DEFAULT_JPEG_QUALITY = void 0;
+exports.DEFAULT_JPEG_QUALITY = 80;
+const validateJpegQuality = (q) => {
+    if (typeof q !== 'undefined' && typeof q !== 'number') {
+        throw new Error(`JPEG Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
+    }
+    if (typeof q === 'undefined') {
+        return;
+    }
+    if (!Number.isFinite(q)) {
+        throw new RangeError(`JPEG Quality must be a finite number, but is ${q}`);
+    }
+    if (Number.isNaN(q)) {
+        throw new RangeError(`JPEG Quality is NaN, but must be a real number`);
+    }
+    if (q > 100 || q < 0) {
+        throw new RangeError('JPEG Quality option must be between 0 and 100.');
+    }
+};
+exports.validateJpegQuality = validateJpegQuality;

package/package/dist/locks.d.ts

@@ -0,0 +1,7 @@
+export declare const createLock: ({ timeout }: {
+    timeout: number | null;
+}) => {
+    lock: () => number;
+    unlock: (id: number) => void;
+    waitForAllToBeDone: () => Promise<unknown>;
+};

package/package/dist/locks.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLock = void 0;
+const createLock = ({ timeout }) => {
+    let locks = [];
+    const waiters = [];
+    const lock = () => {
+        const id = Math.random();
+        locks.push(id);
+        return id;
+    };
+    const unlock = (id) => {
+        locks = locks.filter((l) => l !== id);
+        resolveWaiters();
+    };
+    const resolveWaiters = () => {
+        if (locks.length === 0) {
+            waiters.forEach((w) => w());
+        }
+    };
+    const waitForAllToBeDone = () => {
+        const success = new Promise((resolve) => {
+            waiters.push(() => {
+                resolve();
+            });
+        });
+        resolveWaiters();
+        if (locks.length === 0) {
+            return Promise.resolve();
+        }
+        if (timeout === null) {
+            return success;
+        }
+        const timeoutFn = new Promise((resolve) => {
+            setTimeout(() => {
+                return resolve();
+            }, timeout);
+        });
+        return Promise.race([success, timeoutFn]);
+    };
+    return {
+        lock,
+        unlock,
+        waitForAllToBeDone,
+    };
+};
+exports.createLock = createLock;

package/package/dist/log-level.d.ts

@@ -0,0 +1,4 @@
+export declare const logLevels: readonly ["trace", "verbose", "info", "warn", "error"];
+export type LogLevel = (typeof logLevels)[number];
+export declare const isValidLogLevel: (level: string) => boolean;
+export declare const isEqualOrBelowLogLevel: (currentLevel: LogLevel, level: LogLevel) => boolean;

package/package/dist/log-level.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqualOrBelowLogLevel = exports.isValidLogLevel = exports.logLevels = void 0;
+exports.logLevels = ['trace', 'verbose', 'info', 'warn', 'error'];
+const getNumberForLogLevel = (level) => {
+    return exports.logLevels.indexOf(level);
+};
+const isValidLogLevel = (level) => {
+    return getNumberForLogLevel(level) > -1;
+};
+exports.isValidLogLevel = isValidLogLevel;
+const isEqualOrBelowLogLevel = (currentLevel, level) => {
+    return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+exports.isEqualOrBelowLogLevel = isEqualOrBelowLogLevel;

package/package/dist/logger.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from './log-level';
+export declare const INDENT_TOKEN: string;
+export type LogOptions = {
+    indent: boolean;
+    logLevel: LogLevel;
+};
+type VerboseLogOptions = LogOptions & {
+    tag?: string;
+};
+export declare const verboseTag: (str: string) => string;
+export declare const secondverboseTag: (str: string) => string;
+export declare const Log: {
+    formatLogs: (logLevel: LogLevel, options: VerboseLogOptions, args: Parameters<typeof console.log>) => string[];
+    trace: (options: VerboseLogOptions, message?: any, ...optionalParams: any[]) => boolean | void;
+    verbose: (options: VerboseLogOptions, message?: any, ...optionalParams: any[]) => boolean | void;
+    info: (options: LogOptions, message?: any, ...optionalParams: any[]) => boolean | void;
+    warn: (options: LogOptions, message?: any, ...optionalParams: any[]) => boolean | void;
+    error: (options: VerboseLogOptions, message?: any, ...optionalParams: any[]) => boolean | void;
+};
+export {};

package/package/dist/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.secondverboseTag = exports.verboseTag = exports.INDENT_TOKEN = void 0;
+/* eslint-disable no-console */
+const chalk_1 = require("./chalk");
+const is_color_supported_1 = require("./chalk/is-color-supported");
+const log_level_1 = require("./log-level");
+const repro_1 = require("./repro");
+const truthy_1 = require("./truthy");
+exports.INDENT_TOKEN = chalk_1.chalk.gray('│');
+const verboseTag = (str) => {
+    return (0, is_color_supported_1.isColorSupported)() ? chalk_1.chalk.bgBlack(` ${str} `) : `[${str}]`;
+};
+exports.verboseTag = verboseTag;
+const secondverboseTag = (str) => {
+    return (0, is_color_supported_1.isColorSupported)() ? chalk_1.chalk.bgWhite(` ${str} `) : `[${str}]`;
+};
+exports.secondverboseTag = secondverboseTag;
+exports.Log = {
+    formatLogs: (logLevel, options, args) => {
+        return [
+            options.indent ? exports.INDENT_TOKEN : null,
+            options.tag ? (0, exports.verboseTag)(options.tag) : null,
+        ]
+            .filter(truthy_1.truthy)
+            .concat(args.map((a) => {
+            if (logLevel === 'warn') {
+                return chalk_1.chalk.yellow(a);
+            }
+            if (logLevel === 'error') {
+                return chalk_1.chalk.red(a);
+            }
+            if (logLevel === 'verbose' || logLevel === 'trace') {
+                return chalk_1.chalk.gray(a);
+            }
+            return a;
+        }));
+    },
+    trace: (options, ...args) => {
+        (0, repro_1.writeInRepro)('trace', ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'trace')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.log(...exports.Log.formatLogs('trace', options, args));
+        }
+    },
+    verbose: (options, ...args) => {
+        (0, repro_1.writeInRepro)('verbose', ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'verbose')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.log(...exports.Log.formatLogs('verbose', options, args));
+        }
+    },
+    info: (options, ...args) => {
+        (0, repro_1.writeInRepro)('info', ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'info')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.log(...exports.Log.formatLogs('info', options, args));
+        }
+    },
+    warn: (options, ...args) => {
+        (0, repro_1.writeInRepro)('warn', ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'warn')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.warn(...exports.Log.formatLogs('warn', options, args));
+        }
+    },
+    error: (options, ...args) => {
+        (0, repro_1.writeInRepro)('error', ...args);
+        if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'error')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.error(...exports.Log.formatLogs('error', options, args));
+        }
+    },
+};

package/package/dist/make-cancel-signal.d.ts

@@ -0,0 +1,14 @@
+type Callback = () => void;
+export type CancelSignal = (callback: Callback) => void;
+export declare const makeCancelSignal: () => {
+    cancelSignal: CancelSignal;
+    cancel: () => void;
+};
+export declare const cancelErrorMessages: {
+    renderMedia: string;
+    renderFrames: string;
+    renderStill: string;
+    stitchFramesToVideo: string;
+};
+export declare const isUserCancelledRender: (err: unknown) => boolean;
+export {};

package/package/dist/make-cancel-signal.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserCancelledRender = exports.cancelErrorMessages = exports.makeCancelSignal = void 0;
+/*
+ * @description Returns a signal and a cancel function that allows to you cancel a render triggered using renderMedia(), renderStill(), renderFrames() or stitchFramesToVideo().
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/make-cancel-signal)
+ */
+const makeCancelSignal = () => {
+    const callbacks = [];
+    let cancelled = false;
+    return {
+        cancelSignal: (callback) => {
+            callbacks.push(callback);
+            if (cancelled) {
+                callback();
+            }
+        },
+        cancel: () => {
+            if (cancelled) {
+                return;
+            }
+            callbacks.forEach((cb) => {
+                cb();
+            });
+            cancelled = true;
+        },
+    };
+};
+exports.makeCancelSignal = makeCancelSignal;
+exports.cancelErrorMessages = {
+    renderMedia: 'renderMedia() got cancelled',
+    renderFrames: 'renderFrames() got cancelled',
+    renderStill: 'renderStill() got cancelled',
+    stitchFramesToVideo: 'stitchFramesToVideo() got cancelled',
+};
+const isUserCancelledRender = (err) => {
+    if (typeof err === 'object' &&
+        err !== null &&
+        'message' in err &&
+        typeof err.message === 'string') {
+        return (err.message.includes(exports.cancelErrorMessages.renderMedia) ||
+            err.message.includes(exports.cancelErrorMessages.renderFrames) ||
+            err.message.includes(exports.cancelErrorMessages.renderStill) ||
+            err.message.includes(exports.cancelErrorMessages.stitchFramesToVideo));
+    }
+    return false;
+};
+exports.isUserCancelledRender = isUserCancelledRender;

package/package/dist/make-metadata-args.d.ts

@@ -0,0 +1,2 @@
+import type { Metadata } from './options/metadata';
+export declare const makeMetadataArgs: (metadata: Metadata) => string[];

package/package/dist/make-metadata-args.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMetadataArgs = void 0;
+const version_1 = require("remotion/version");
+const makeMetadataArgs = (metadata) => {
+    const defaultComment = `Made with Remotion ${version_1.VERSION}`;
+    const newMetadata = {
+        comment: defaultComment,
+    };
+    Object.keys(metadata).forEach((key) => {
+        const lowercaseKey = key.toLowerCase();
+        if (lowercaseKey === 'comment') {
+            newMetadata[lowercaseKey] = `${defaultComment}; ${metadata[key]}`;
+        }
+        else {
+            newMetadata[lowercaseKey] = metadata[key];
+        }
+    });
+    const metadataArgs = Object.entries(newMetadata).map(([key, value]) => ['-metadata', `${key}=${value}`]);
+    return metadataArgs.flat(1);
+};
+exports.makeMetadataArgs = makeMetadataArgs;

package/package/dist/make-page.d.ts

@@ -0,0 +1,30 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { BrowserLog } from './browser-log';
+import type { OnLog, Page } from './browser/BrowserPage';
+import type { SourceMapGetter } from './browser/source-map-getter';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { BrowserReplacer } from './replace-browser';
+export declare const makePage: ({ context, initialFrame, browserReplacer, logLevel, indent, pagesArray, onBrowserLog, scale, timeoutInMilliseconds, composition, proxyPort, serveUrl, muted, envVariables, serializedInputPropsWithCustomSchema, imageFormat, serializedResolvedPropsWithCustomSchema, pageIndex, isMainTab, mediaCacheSizeInBytes, onLog, }: {
+    context: SourceMapGetter;
+    initialFrame: number;
+    browserReplacer: BrowserReplacer;
+    logLevel: LogLevel;
+    indent: boolean;
+    pagesArray: Page[];
+    onBrowserLog: ((log: BrowserLog) => void) | null;
+    scale: number;
+    timeoutInMilliseconds: number;
+    composition: Omit<VideoConfig, "defaultProps" | "props">;
+    proxyPort: number;
+    serveUrl: string;
+    muted: boolean;
+    envVariables: Record<string, string>;
+    serializedInputPropsWithCustomSchema: string;
+    serializedResolvedPropsWithCustomSchema: string;
+    imageFormat: VideoImageFormat;
+    pageIndex: number;
+    isMainTab: boolean;
+    mediaCacheSizeInBytes: number | null;
+    onLog: OnLog;
+}) => Promise<Page>;