@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/prespawn-ffmpeg.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prespawnFfmpeg = void 0;
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const codec_1 = require("./codec");
+const ffmpeg_args_1 = require("./ffmpeg-args");
+const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const logger_1 = require("./logger");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const pixel_format_1 = require("./pixel-format");
+const validate_1 = require("./validate");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const prespawnFfmpeg = (options) => {
+    var _a, _b, _c;
+    (0, validate_1.validateDimension)(options.height, 'height', 'passed to `stitchFramesToVideo()`');
+    (0, validate_1.validateDimension)(options.width, 'width', 'passed to `stitchFramesToVideo()`');
+    const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
+    (0, validate_1.validateFps)(options.fps, 'in `stitchFramesToVideo()`', codec === 'gif');
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        width: options.width,
+        height: options.height,
+        codec,
+        scale: 1,
+        wantsImageSequence: false,
+        indent: options.indent,
+        logLevel: options.logLevel,
+    });
+    const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
+    const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
+    (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
+    const ffmpegArgs = [
+        ['-r', options.fps],
+        ...[
+            ['-f', 'image2pipe'],
+            ['-s', `${options.width}x${options.height}`],
+            // If scale is very small (like 0.1), FFMPEG cannot figure out the image
+            // format on it's own and we need to hint the format
+            ['-vcodec', options.imageFormat === 'jpeg' ? 'mjpeg' : 'png'],
+            ['-i', '-'],
+        ],
+        ...(0, ffmpeg_args_1.generateFfmpegArgs)({
+            hasPreencoded: false,
+            proResProfileName,
+            pixelFormat,
+            x264Preset: options.x264Preset,
+            codec,
+            crf: options.crf,
+            videoBitrate: options.videoBitrate,
+            encodingMaxRate: options.encodingMaxRate,
+            encodingBufferSize: options.encodingBufferSize,
+            colorSpace: options.colorSpace,
+            hardwareAcceleration: options.hardwareAcceleration,
+            indent: options.indent,
+            logLevel: options.logLevel,
+        }),
+        '-y',
+        options.outputLocation,
+    ];
+    logger_1.Log.verbose({
+        indent: options.indent,
+        logLevel: options.logLevel,
+        tag: 'prespawnFfmpeg()',
+    }, 'Generated FFMPEG command:');
+    logger_1.Log.verbose({
+        indent: options.indent,
+        logLevel: options.logLevel,
+        tag: 'prespawnFfmpeg()',
+    }, ffmpegArgs.join(' '));
+    const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
+    const finalFfmpegString = options.ffmpegOverride
+        ? options.ffmpegOverride({ type: 'pre-stitcher', args: ffmpegString })
+        : ffmpegString;
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args: finalFfmpegString,
+        indent: options.indent,
+        logLevel: options.logLevel,
+        binariesDirectory: options.binariesDirectory,
+        cancelSignal: options.signal,
+    });
+    let ffmpegOutput = '';
+    (_c = task.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
+        const str = data.toString();
+        ffmpegOutput += str;
+        if (options.onProgress) {
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(str, options.fps);
+            if (parsed !== undefined) {
+                options.onProgress(parsed);
+            }
+        }
+    });
+    let exitCode = {
+        type: 'running',
+    };
+    task.on('exit', (code) => {
+        if (typeof code === 'number' && code > 0) {
+            exitCode = {
+                type: 'quit-with-error',
+                exitCode: code,
+                stderr: ffmpegOutput,
+            };
+        }
+        else {
+            exitCode = {
+                type: 'quit-successfully',
+                stderr: ffmpegOutput,
+            };
+        }
+    });
+    return { task, getLogs: () => ffmpegOutput, getExitStatus: () => exitCode };
+};
+exports.prespawnFfmpeg = prespawnFfmpeg;

package/package/dist/prestitcher-memory-usage.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from './log-level';
+export declare const shouldUseParallelEncoding: ({ width, height, logLevel, }: {
+    width: number;
+    height: number;
+    logLevel: LogLevel;
+}) => {
+    hasEnoughMemory: boolean;
+    freeMemory: number;
+    estimatedUsage: number;
+};

package/package/dist/prestitcher-memory-usage.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseParallelEncoding = void 0;
+const get_available_memory_1 = require("./memory/get-available-memory");
+const estimateMemoryUsageForPrestitcher = ({ width, height, }) => {
+    // Empirically we detected that per 1 million pixels, FFMPEG uses around 1GB of memory, relatively independent of
+    // the duration of the video.
+    const memoryUsageFor4K = 1000000000;
+    const memoryUsageOfPixel = memoryUsageFor4K / 1000000;
+    return memoryUsageOfPixel * width * height;
+};
+const shouldUseParallelEncoding = ({ width, height, logLevel, }) => {
+    const freeMemory = (0, get_available_memory_1.getAvailableMemory)(logLevel);
+    const estimatedUsage = estimateMemoryUsageForPrestitcher({
+        height,
+        width,
+    });
+    const hasEnoughMemory = freeMemory - estimatedUsage > 2000000000 &&
+        estimatedUsage / freeMemory < 0.5;
+    return {
+        hasEnoughMemory,
+        freeMemory,
+        estimatedUsage,
+    };
+};
+exports.shouldUseParallelEncoding = shouldUseParallelEncoding;

package/package/dist/print-useful-error-message.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel } from './log-level';
+export declare const printUsefulErrorMessage: (err: Error, logLevel: LogLevel, indent: boolean) => void;

package/package/dist/print-useful-error-message.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUsefulErrorMessage = void 0;
+const logger_1 = require("./logger");
+const truthy_1 = require("./truthy");
+let alreadyPrintedCache = [];
+const printUsefulErrorMessage = (err, logLevel, indent) => {
+    var _a, _b, _c;
+    const errorStack = err.stack;
+    if (errorStack && alreadyPrintedCache.includes(errorStack)) {
+        return;
+    }
+    if (errorStack) {
+        alreadyPrintedCache.push(errorStack);
+        alreadyPrintedCache = alreadyPrintedCache.slice(-10);
+    }
+    if (err.message.includes('Could not play video with')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/media-playback-error');
+    }
+    if (err.message.includes('A delayRender()') &&
+        err.message.includes('was called but not cleared after')) {
+        logger_1.Log.info({ indent, logLevel });
+        if (err.message.includes('/proxy')) {
+            logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/troubleshooting/delay-render-proxy');
+        }
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/timeout');
+    }
+    if (err.message.includes('Target closed')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/target-closed');
+    }
+    if (err.message.includes('Timed out evaluating')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/troubleshooting/timed-out-page-function');
+    }
+    if (err.message.includes('ENAMETOOLONG')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue at https://remotion.dev/docs/enametoolong');
+    }
+    if (err.message.includes('Member must have value less than or equal to 3008')) {
+        logger_1.Log.warn({ indent, logLevel });
+        logger_1.Log.warn({ indent, logLevel }, '💡 This error indicates that you have a AWS account on the free or basic tier or have been limited by your organization.');
+        logger_1.Log.warn({ indent, logLevel }, 'Often times this can be solved by adding a credit card, or if already done, by contacting AWS support.');
+        logger_1.Log.warn({
+            indent,
+            logLevel,
+        }, 'Alternatively, you can decrease the memory size of your Lambda function to a value below 3008 MB. See: https://www.remotion.dev/docs/lambda/runtime#core-count--vcpus');
+        logger_1.Log.warn({ indent, logLevel }, 'See also: https://repost.aws/questions/QUKruWYNDYTSmP17jCnIz6IQ/questions/QUKruWYNDYTSmP17jCnIz6IQ/unable-to-set-lambda-memory-over-3008mb');
+    }
+    if (((_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes('TooManyRequestsException: Rate Exceeded.')) ||
+        ((_b = err.message) === null || _b === void 0 ? void 0 : _b.includes('ConcurrentInvocationLimitExceeded'))) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 This error indicates that your Lambda concurrency limit is too low. See: https://www.remotion.dev/docs/lambda/troubleshooting/rate-limit');
+    }
+    if (err.message.includes('Error creating WebGL context')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.warn({
+            indent,
+            logLevel,
+        }, '💡 You might need to set the OpenGL renderer to "angle-egl", "angle" (or "swangle" if rendering on lambda). Learn why at https://www.remotion.dev/docs/three');
+        logger_1.Log.warn({
+            indent,
+            logLevel,
+        }, "💡 Check how it's done at https://www.remotion.dev/docs/chromium-flags#--gl");
+    }
+    if (err.message.includes('The bucket does not allow ACLs')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 Fix for this issue: https://remotion.dev/docs/lambda/troubleshooting/bucket-disallows-acl');
+    }
+    if (err.message.includes('Minified React error #306')) {
+        const componentName = (_c = err.message.match(/<\w+>/)) === null || _c === void 0 ? void 0 : _c[0];
+        logger_1.Log.info({ indent, logLevel }, [
+            '💡 This error indicates that the component',
+            componentName ? `(${componentName})` : null,
+            'you are trying to render is not imported correctly.',
+        ]
+            .filter(truthy_1.truthy)
+            .join(' '));
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '   Check the root file and ensure that the component is not undefined.');
+        logger_1.Log.info({ indent, logLevel }, '   Oftentimes, this happens if the component is missing the `export` keyword');
+        logger_1.Log.info({ indent, logLevel }, '   or if the component was renamed and the import statement not properly adjusted.');
+    }
+    if (err.message.includes('GLIBC_')) {
+        logger_1.Log.info({ indent, logLevel }, '💡 Remotion requires at least Libc 2.35.');
+        logger_1.Log.info({ indent, logLevel }, '💡 Get help for this issue: https://github.com/remotion-dev/remotion/issues/2439');
+    }
+    if (err.message.includes('EBADF')) {
+        logger_1.Log.info({ indent, logLevel }, '💡 This error might be fixed by changing your Node version:');
+        logger_1.Log.info({ indent, logLevel }, '   https://github.com/remotion-dev/remotion/issues/2452');
+    }
+    if (err.message.includes('routines::unsupported')) {
+        logger_1.Log.info({ indent, logLevel }, '💡 This error might happen if using Cloud Run with credentials that have a newline at the end or are otherwise badly encoded.');
+        logger_1.Log.info({ indent, logLevel }, '   https://github.com/remotion-dev/remotion/issues/3864');
+    }
+    if (err.message.includes('Failed to fetch')) {
+        logger_1.Log.info({ indent, logLevel }, '💡 On Lambda, one reason this could happen is that Chrome is rejecting an asset to be loaded when it is running low on disk space.');
+        logger_1.Log.info({ indent, logLevel }, 'Try increasing the disk size of your Lambda function.');
+    }
+    if (err.message.includes('Invalid value specified for cpu')) {
+        logger_1.Log.info({ indent, logLevel });
+        logger_1.Log.info({ indent, logLevel }, '💡 This error indicates that your GCP account does have a limit. Try setting `--maxInstances=5` / `maxInstances: 5` when deploying this service.');
+        logger_1.Log.info({
+            indent,
+            logLevel,
+        });
+    }
+};
+exports.printUsefulErrorMessage = printUsefulErrorMessage;

package/package/dist/prores-profile.d.ts

@@ -0,0 +1,7 @@
+import type { Codec } from './codec';
+export declare const proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
+export type ProResProfile = (typeof proResProfileOptions)[number];
+export declare const validateSelectedCodecAndProResCombination: ({ codec, proResProfile, }: {
+    codec: Codec;
+    proResProfile: ProResProfile | undefined;
+}) => void;

package/package/dist/prores-profile.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedCodecAndProResCombination = exports.proResProfileOptions = void 0;
+exports.proResProfileOptions = [
+    '4444-xq',
+    '4444',
+    'hq',
+    'standard',
+    'light',
+    'proxy',
+];
+const validateSelectedCodecAndProResCombination = ({ codec, proResProfile, }) => {
+    if (typeof proResProfile !== 'undefined' && codec !== 'prores') {
+        throw new TypeError(`You have set a ProRes profile but the codec is "${codec}". Set the codec to "prores" or remove the ProRes profile.`);
+    }
+    if (proResProfile !== undefined &&
+        !exports.proResProfileOptions.includes(proResProfile)) {
+        throw new TypeError(`The ProRes profile "${proResProfile}" is not valid. Valid options are ${exports.proResProfileOptions
+            .map((p) => `"${p}"`)
+            .join(', ')}`);
+    }
+};
+exports.validateSelectedCodecAndProResCombination = validateSelectedCodecAndProResCombination;

package/package/dist/puppeteer-evaluate.d.ts

@@ -0,0 +1,17 @@
+import type { Page } from './browser/BrowserPage';
+type PuppeteerCatchOptions = {
+    page: Page;
+    pageFunction: Function;
+    frame: number | null;
+    args: unknown[];
+    timeoutInMilliseconds: number;
+};
+export declare function puppeteerEvaluateWithCatchAndTimeout<ReturnType>({ args, frame, page, pageFunction, timeoutInMilliseconds, }: PuppeteerCatchOptions): Promise<{
+    value: ReturnType;
+    size: number;
+}>;
+export declare function puppeteerEvaluateWithCatch<ReturnType>({ page, pageFunction, frame, args, }: PuppeteerCatchOptions): Promise<{
+    value: ReturnType;
+    size: number;
+}>;
+export {};

package/package/dist/puppeteer-evaluate.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteerEvaluateWithCatchAndTimeout = puppeteerEvaluateWithCatchAndTimeout;
+exports.puppeteerEvaluateWithCatch = puppeteerEvaluateWithCatch;
+const JSHandle_1 = require("./browser/JSHandle");
+const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
+const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+const EVALUATION_SCRIPT_URL = '__puppeteer_evaluation_script__';
+function valueFromRemoteObject(remoteObject) {
+    if (remoteObject.unserializableValue) {
+        if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined')
+            return BigInt(remoteObject.unserializableValue.replace('n', ''));
+        switch (remoteObject.unserializableValue) {
+            case '-0':
+                return -0;
+            case 'NaN':
+                return NaN;
+            case 'Infinity':
+                return Infinity;
+            case '-Infinity':
+                return -Infinity;
+            default:
+                throw new Error('Unsupported unserializable value: ' +
+                    remoteObject.unserializableValue);
+        }
+    }
+    return remoteObject.value;
+}
+function puppeteerEvaluateWithCatchAndTimeout({ args, frame, page, pageFunction, timeoutInMilliseconds, }) {
+    let timeout = null;
+    return Promise.race([
+        new Promise((_, reject) => {
+            timeout = setTimeout(() => {
+                reject(new Error(
+                // This means the page is not responding anymore
+                // This error message is retryable - sync it with packages/lambda/src/shared/is-flaky-error.ts
+                `Timed out evaluating page function "${pageFunction.toString()}"`));
+            }, timeoutInMilliseconds);
+        }),
+        puppeteerEvaluateWithCatch({
+            args,
+            frame,
+            page,
+            pageFunction,
+            timeoutInMilliseconds,
+        }),
+    ]).then((data) => {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        return data;
+    });
+}
+async function puppeteerEvaluateWithCatch({ page, pageFunction, frame, args, }) {
+    var _a, _b, _c, _d, _e, _f;
+    const contextId = (await page.mainFrame().executionContext())._contextId;
+    const client = page._client();
+    const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;
+    if (typeof pageFunction !== 'function')
+        throw new Error(`Expected to get |string| or |function| as the first argument, but got "${pageFunction}" instead.`);
+    let functionText = pageFunction.toString();
+    try {
+        // eslint-disable-next-line no-new-func
+        new Function('(' + functionText + ')');
+    }
+    catch (_g) {
+        // This means we might have a function shorthand. Try another
+        // time prefixing 'function '.
+        if (functionText.startsWith('async '))
+            functionText =
+                'async function ' + functionText.substring('async '.length);
+        else
+            functionText = 'function ' + functionText;
+        try {
+            // eslint-disable-next-line no-new-func
+            new Function('(' + functionText + ')');
+        }
+        catch (_h) {
+            // We tried hard to serialize, but there's a weird beast here.
+            throw new Error('Passed function is not well-serializable!');
+        }
+    }
+    let callFunctionOnPromise;
+    try {
+        callFunctionOnPromise = client.send('Runtime.callFunctionOn', {
+            functionDeclaration: functionText + '\n' + suffix + '\n',
+            executionContextId: contextId,
+            arguments: args.map((a) => convertArgument(a)),
+            returnByValue: true,
+            awaitPromise: true,
+            userGesture: true,
+        });
+    }
+    catch (error) {
+        if (error instanceof TypeError &&
+            error.message.startsWith('Converting circular structure to JSON')) {
+            error.message += ' Are you passing a nested JSHandle?';
+        }
+        throw error;
+    }
+    try {
+        const { value: { exceptionDetails, result: remoteObject }, size, } = await callFunctionOnPromise;
+        if (exceptionDetails) {
+            const err = new symbolicateable_error_1.SymbolicateableError({
+                stack: (_a = exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description,
+                name: (_b = exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className,
+                message: (_d = (_c = exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description) === null || _d === void 0 ? void 0 : _d.split('\n')[0],
+                frame,
+                stackFrame: (0, parse_browser_error_stack_1.parseStack)(((_e = exceptionDetails.exception) === null || _e === void 0 ? void 0 : _e.description).split('\n')),
+                chunk: null,
+            });
+            page.close();
+            throw err;
+        }
+        return { size, value: valueFromRemoteObject(remoteObject) };
+    }
+    catch (error) {
+        if ((_f = error === null || error === void 0 ? void 0 : error.originalMessage) === null || _f === void 0 ? void 0 : _f.startsWith("Object couldn't be returned by value")) {
+            throw new Error('Could not serialize the return value of the function. Did you pass non-serializable values to defaultProps?');
+        }
+        throw error;
+    }
+}
+/**
+ * @param {*} arg
+ * @returns {*}
+ * @this {ExecutionContext}
+ */
+function convertArgument(arg) {
+    if (typeof arg === 'number') {
+        return { value: arg };
+    }
+    if (typeof arg === 'string') {
+        return { value: arg };
+    }
+    if (typeof arg === 'boolean') {
+        return { value: arg };
+    }
+    if (typeof arg === 'bigint')
+        return { unserializableValue: `${arg.toString()}n` };
+    if (Object.is(arg, -0))
+        return { unserializableValue: '-0' };
+    if (Object.is(arg, Infinity))
+        return { unserializableValue: 'Infinity' };
+    if (Object.is(arg, -Infinity))
+        return { unserializableValue: '-Infinity' };
+    if (Object.is(arg, NaN))
+        return { unserializableValue: 'NaN' };
+    const objectHandle = arg && arg instanceof JSHandle_1.JSHandle ? arg : null;
+    if (objectHandle) {
+        if (objectHandle._disposed)
+            throw new Error('JSHandle is disposed!');
+        if (objectHandle._remoteObject.unserializableValue)
+            return {
+                unserializableValue: objectHandle._remoteObject.unserializableValue,
+            };
+        if (!objectHandle._remoteObject.objectId)
+            return { value: objectHandle._remoteObject.value };
+        return { objectId: objectHandle._remoteObject.objectId };
+    }
+    return { value: arg };
+}

package/package/dist/puppeteer-screenshot.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from './browser/BrowserPage';
+import type { StillImageFormat } from './image-format';
+export declare const screenshot: (options: {
+    page: Page;
+    type: StillImageFormat;
+    path?: string;
+    jpegQuality?: number;
+    omitBackground: boolean;
+    width: number;
+    height: number;
+    scale: number;
+}) => Promise<Buffer>;

package/package/dist/puppeteer-screenshot.js

@@ -0,0 +1,58 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenshot = void 0;
+const assert = __importStar(require("node:assert"));
+const screenshot_task_1 = require("./screenshot-task");
+const screenshot = (options) => {
+    if (options.jpegQuality) {
+        assert.ok(typeof options.jpegQuality === 'number', 'Expected options.quality to be a number but found ' +
+            typeof options.jpegQuality);
+        assert.ok(Number.isInteger(options.jpegQuality), 'Expected options.quality to be an integer');
+        assert.ok(options.jpegQuality >= 0 && options.jpegQuality <= 100, 'Expected options.quality to be between 0 and 100 (inclusive), got ' +
+            options.jpegQuality);
+    }
+    return options.page.screenshotTaskQueue.postTask(() => (0, screenshot_task_1.screenshotTask)({
+        page: options.page,
+        format: options.type,
+        height: options.height,
+        width: options.width,
+        omitBackground: options.omitBackground,
+        path: options.path,
+        jpegQuality: options.type === 'jpeg' ? options.jpegQuality : undefined,
+        scale: options.scale,
+    }));
+};
+exports.screenshot = screenshot;

package/package/dist/pure.d.ts

@@ -0,0 +1,17 @@
+export declare const NoReactAPIs: {
+    getExtensionOfFilename: (filename: string | null) => string | null;
+    getFileExtensionFromCodec: <T extends import("./codec").Codec>(codec: T, audioCodec: import(".").AudioCodec | null) => import("./file-extensions").FileExtension;
+    validateOutputFilename: <T extends import("./codec").Codec>({ codec, audioCodecSetting, extension, preferLossless, separateAudioTo, }: {
+        codec: T;
+        audioCodecSetting: import(".").AudioCodec | null;
+        extension: string;
+        preferLossless: boolean;
+        separateAudioTo: string | null;
+    }) => void;
+    getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];
+    codecSupportsMedia: (codec: import("./codec").Codec) => {
+        video: boolean;
+        audio: boolean;
+    };
+    isAudioCodec: (codec: import("./codec").Codec | undefined | null) => codec is "mp3" | "aac" | "wav";
+};

package/package/dist/pure.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoReactAPIs = void 0;
+const codec_supports_media_1 = require("./codec-supports-media");
+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 is_audio_codec_1 = require("./is-audio-codec");
+const validate_output_filename_1 = require("./validate-output-filename");
+exports.NoReactAPIs = {
+    getExtensionOfFilename: get_extension_of_filename_1.getExtensionOfFilename,
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+    validateOutputFilename: validate_output_filename_1.validateOutputFilename,
+    getFramesToRender: get_duration_from_frame_range_1.getFramesToRender,
+    codecSupportsMedia: codec_supports_media_1.codecSupportsMedia,
+    isAudioCodec: is_audio_codec_1.isAudioCodec,
+};

package/package/dist/redirect-status-codes.d.ts

@@ -0,0 +1 @@
+export declare const redirectStatusCodes: number[];

package/package/dist/redirect-status-codes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectStatusCodes = void 0;
+// Don't handle 304 status code (Not Modified) as a redirect,
+// since the browser will display the right page.
+exports.redirectStatusCodes = [301, 302, 303, 307, 308];

package/package/dist/render-frame-and-retry-target-close.d.ts

@@ -0,0 +1,54 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { Page } from './browser/BrowserPage';
+import type { CountType } from './get-frame-padded-index';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { NextFrameToRender } from './next-frame-to-render';
+import type { Pool } from './pool';
+import type { FrameAndAssets, OnArtifact } from './render-frames';
+import type { BrowserReplacer } from './replace-browser';
+export declare const renderFrameAndRetryTargetClose: ({ retriesLeft, attempt, assets, imageFormat, binariesDirectory, cancelSignal, composition, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, onError, outputDir, poolPromise, scale, stoppedSignal, timeoutInMilliseconds, indent, logLevel, makeBrowser, makeNewPage, browserReplacer, concurrencyOrFramesToRender, framesRenderedObj, lastFrame, onFrameBuffer, onFrameUpdate, nextFrameToRender, imageSequencePattern, trimLeftOffset, trimRightOffset, allFramesAndExtraFrames, }: {
+    retriesLeft: number;
+    attempt: number;
+    imageFormat: VideoImageFormat;
+    cancelSignal: CancelSignal | undefined;
+    binariesDirectory: string | null;
+    poolPromise: Promise<Pool>;
+    jpegQuality: number;
+    frameDir: string;
+    scale: number;
+    countType: CountType;
+    assets: FrameAndAssets[];
+    framesToRender: number[];
+    onArtifact: OnArtifact | null;
+    onDownload: RenderMediaOnDownload | null;
+    downloadMap: DownloadMap;
+    composition: Omit<VideoConfig, "defaultProps" | "props">;
+    onError: (err: Error) => void;
+    stoppedSignal: {
+        stopped: boolean;
+    };
+    timeoutInMilliseconds: number;
+    outputDir: string | null;
+    indent: boolean;
+    logLevel: LogLevel;
+    makeBrowser: () => Promise<HeadlessBrowser>;
+    makeNewPage: (frame: number, pageIndex: number) => Promise<Page>;
+    browserReplacer: BrowserReplacer;
+    concurrencyOrFramesToRender: number;
+    lastFrame: number;
+    framesRenderedObj: {
+        count: number;
+    };
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void) | undefined;
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    nextFrameToRender: NextFrameToRender;
+    imageSequencePattern: string | null;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    allFramesAndExtraFrames: number[];
+}) => Promise<void>;