@remotion/renderer 4.0.0-oops.3 → 4.0.0-prefetch.7

package/dist/get-frame-padded-index.d.ts

@@ -0,0 +1,14 @@
+export declare type CountType = 'from-zero' | 'actual-frames';
+export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }: {
+    index: number;
+    frame: number;
+    imageFormat: 'png' | 'jpeg';
+    countType: CountType;
+    lastFrame: number;
+    totalFrames: number;
+}) => string;
+export declare const getFilePadLength: ({ lastFrame, totalFrames, countType, }: {
+    lastFrame: number;
+    totalFrames: number;
+    countType: CountType;
+}) => number;

package/dist/get-frame-padded-index.js

@@ -0,0 +1,33 @@
+"use strict";
+// Determines the filenames for frames that get rendered.
+// - If passed to FFMPEG, they should be consecutive: element-000.jpg, element-001.jpg, element-002.jpg
+// - If `--every-nth-frame` is passed, only frames 0, 2, 4 are rendered
+// - If an image sequence is created, the filenames should correspond to the frame numbers: element-099.jpg, element-100.jpg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePadLength = exports.getFrameOutputFileName = void 0;
+const padIndex = ({ num, filePadLength, }) => {
+    return String(num).padStart(filePadLength, '0');
+};
+const getFrameOutputFileName = ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }) => {
+    const filePadLength = (0, exports.getFilePadLength)({ lastFrame, countType, totalFrames });
+    if (countType === 'actual-frames') {
+        const paddedIndex = padIndex({ filePadLength, num: frame });
+        return `element-${paddedIndex}.${imageFormat}`;
+    }
+    if (countType === 'from-zero') {
+        const paddedIndex = padIndex({ filePadLength, num: index });
+        return `element-${paddedIndex}.${imageFormat}`;
+    }
+    throw new TypeError('Unknown count type');
+};
+exports.getFrameOutputFileName = getFrameOutputFileName;
+const getFilePadLength = ({ lastFrame, totalFrames, countType, }) => {
+    if (countType === 'actual-frames') {
+        return String(lastFrame).length;
+    }
+    if (countType === 'from-zero') {
+        return String(totalFrames - 1).length;
+    }
+    throw new Error('Unknown file type');
+};
+exports.getFilePadLength = getFilePadLength;

package/dist/get-frame-to-render.d.ts

@@ -1,2 +1,2 @@
-import { FrameRange } from 'remotion';
+import type { FrameRange } from './frame-range';
 export declare const getRealFrameRange: (durationInFrames: number, frameRange: FrameRange | null) => [number, number];

package/dist/get-local-browser-executable.d.ts

@@ -1,3 +1,4 @@
-import { Browser, BrowserExecutable } from 'remotion';
+import type { Browser } from './browser';
+import type { BrowserExecutable } from './browser-executable';
 export declare const ensureLocalBrowser: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => Promise<void>;
 export declare const getLocalBrowserExecutable: (browser: Browser, preferredBrowserExecutable: BrowserExecutable) => string;

package/dist/get-local-browser-executable.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
 const fs_1 = __importDefault(require("fs"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
-const install_1 = require("puppeteer-core/lib/cjs/puppeteer/node/install");
-const revisions_1 = require("puppeteer-core/lib/cjs/puppeteer/revisions");
+const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
+const node_1 = require("./browser/node");
+const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
     if (product === 'chrome') {
@@ -44,8 +44,10 @@ const getLocalBrowser = (product) => {
     return null;
 };
 const getBrowserRevision = (product) => {
-    const browserFetcher = puppeteer_core_1.default.createBrowserFetcher({
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
         product,
+        path: null,
+        platform: null,
     });
     const revisionInfo = browserFetcher.revisionInfo(product === 'firefox'
         ? revisions_1.PUPPETEER_REVISIONS.firefox
@@ -73,7 +75,7 @@ const ensureLocalBrowser = async (browser, preferredBrowserExecutable) => {
     const status = getBrowserStatus(mapBrowserToProduct(browser), preferredBrowserExecutable);
     if (status.type === 'no-browser') {
         console.log('No local browser could be found. Downloading one from the internet...');
-        await (0, install_1.downloadBrowser)();
+        await (0, create_browser_fetcher_1.downloadBrowser)(browser);
     }
 };
 exports.ensureLocalBrowser = ensureLocalBrowser;

package/dist/get-port.js

@@ -5,47 +5,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const getAvailablePort = (portToTry) => new Promise((resolve, reject) => {
-    const server = net_1.default.createServer();
-    server.unref();
-    server.on('error', reject);
-    server.listen({ port: portToTry }, () => {
-        const { port } = server.address();
-        server.close(() => {
-            resolve(port);
-        });
+const p_limit_1 = require("./p-limit");
+const getAvailablePort = (portToTry) => new Promise((resolve) => {
+    let status = 'unavailable';
+    const host = '127.0.0.1';
+    const socket = new net_1.default.Socket();
+    socket.on('connect', () => {
+        status = 'unavailable';
+        socket.destroy();
     });
+    socket.setTimeout(3000);
+    socket.on('timeout', () => {
+        status = 'unavailable';
+        socket.destroy();
+        resolve(status);
+    });
+    socket.on('error', () => {
+        status = 'available';
+    });
+    socket.on('close', () => resolve(status));
+    socket.connect(portToTry, host);
 });
-const portCheckSequence = function* (ports) {
-    if (ports) {
-        yield* ports;
-    }
-    yield 0; // Fall back to 0 if anything else failed
-};
-const isPortAvailable = async (port) => {
-    try {
-        await getAvailablePort(port);
-        return true;
-    }
-    catch (error) {
-        if (!['EADDRINUSE', 'EACCES'].includes(error.code)) {
-            throw error;
-        }
-        return false;
-    }
-};
 const getPort = async (from, to) => {
     const ports = makeRange(from, to);
-    for (const port of portCheckSequence(ports)) {
-        if (await isPortAvailable(port)) {
+    for (const port of ports) {
+        if ((await getAvailablePort(port)) === 'available') {
             return port;
         }
     }
     throw new Error('No available ports found');
 };
-const getDesiredPort = async (desiredPort, from, to) => {
+const getDesiredPortUnlimited = async (desiredPort, from, to) => {
     if (typeof desiredPort !== 'undefined' &&
-        (await isPortAvailable(desiredPort))) {
+        (await getAvailablePort(desiredPort)) === 'available') {
         return desiredPort;
     }
     const actualPort = await getPort(from, to);
@@ -55,6 +47,10 @@ const getDesiredPort = async (desiredPort, from, to) => {
     }
     return actualPort;
 };
+const limit = (0, p_limit_1.pLimit)(1);
+const getDesiredPort = (desiredPort, from, to) => {
+    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+};
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {
     if (!Number.isInteger(from) || !Number.isInteger(to)) {
@@ -69,10 +65,7 @@ const makeRange = (from, to) => {
     if (to < from) {
         throw new RangeError('`to` must be greater than or equal to `from`');
     }
-    const generator = function* (f, t) {
-        for (let port = f; port <= t; port++) {
-            yield port;
-        }
-    };
-    return generator(from, to);
+    return new Array(to - from + 1).fill(true).map((_, i) => {
+        return i + from;
+    });
 };

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

@@ -1,2 +1,3 @@
-import { Codec, ProResProfile } from 'remotion';
+import type { Codec } from './codec';
+import type { ProResProfile } from './prores-profile';
 export declare const getProResProfileName: (codec: Codec, proResProfile: ProResProfile | undefined) => string | null;

package/dist/get-video-info.d.ts

@@ -0,0 +1,3 @@
+import type { DownloadMap, Vp9Result } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoInfo = void 0;
+const execa_1 = __importDefault(require("execa"));
+const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const p_limit_1 = require("./p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable) {
+    var _a;
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [src]);
+    const isVp9 = task.stderr.includes('Video: vp9');
+    const isVp8 = task.stderr.includes('Video: vp8');
+    const dimensions = (_a = task.stderr
+        .split('\n')
+        .find((n) => n.trim().startsWith('Stream #'))) === null || _a === void 0 ? void 0 : _a.match(/([0-9]{2,6})x([0-9]{2,6})/);
+    const dar = task.stderr.match(/DAR\s([0-9]+):([0-9]+)/);
+    let needsResize = null;
+    if (dimensions && dar) {
+        const width = parseInt(dimensions[1], 10);
+        const height = parseInt(dimensions[2], 10);
+        const darWidth = parseInt(dar[1], 10);
+        const darHeight = parseInt(dar[2], 10);
+        const { width: actualWidth, height: actualHeight } = (0, calculate_sar_dar_pixels_1.calculateDisplayVideoSize)({
+            darX: darWidth,
+            darY: darHeight,
+            x: width,
+            y: height,
+        });
+        if (actualWidth !== width || actualHeight !== height) {
+            needsResize = [actualWidth, actualHeight];
+        }
+    }
+    const result = {
+        specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        needsResize,
+    };
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
+}
+const getVideoInfo = (downloadMap, src, ffprobeExecutable) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable));
+};
+exports.getVideoInfo = getVideoInfo;

package/dist/get-video-threads-flag.d.ts

@@ -0,0 +1 @@
+export declare const getIdealVideoThreadsFlag: () => number;

package/dist/get-video-threads-flag.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdealVideoThreadsFlag = void 0;
+const os_1 = __importDefault(require("os"));
+const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
+const RESERVED_MEMORY = 2000000000;
+const getIdealVideoThreadsFlag = () => {
+    const freeMemory = os_1.default.freemem();
+    const cpus = os_1.default.cpus().length;
+    const maxRecommendedBasedOnCpus = (cpus * 2) / 3;
+    const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
+    const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);
+    return Math.max(1, Math.round(maxRecommended));
+};
+exports.getIdealVideoThreadsFlag = getIdealVideoThreadsFlag;

package/dist/guess-extension-for-media.d.ts

@@ -0,0 +1 @@
+export declare const guessExtensionForVideo: (src: string) => Promise<"mp3" | "wav" | "webm" | "mp4">;

package/dist/guess-extension-for-media.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessExtensionForVideo = void 0;
+const execa_1 = __importDefault(require("execa"));
+const guessExtensionForVideo = async (src) => {
+    const { stderr } = await (0, execa_1.default)('ffprobe', [src]);
+    if (stderr.includes('mp3,')) {
+        return 'mp3';
+    }
+    if (stderr.includes('Video: vp9')) {
+        return 'webm';
+    }
+    if (stderr.includes('Video: vp8')) {
+        return 'webm';
+    }
+    if (stderr.includes('wav, ')) {
+        return 'wav';
+    }
+    if (stderr.includes('Video: h264')) {
+        return 'mp4';
+    }
+    throw new Error(`The media file "${src}" has no file extension and the format could not be guessed. Tips: a) Ensure this is a valid video or audio file b) Add a file extension to the URL like ".mp4" c) Set a "Content-Type" or "Content-Disposition" header if possible.`);
+};
+exports.guessExtensionForVideo = guessExtensionForVideo;

package/dist/image-format.d.ts

@@ -1,2 +1,7 @@
-import { ImageFormat } from 'remotion';
+import type { PixelFormat } from './pixel-format';
+export declare const validImageFormats: readonly ["png", "jpeg", "none"];
+export declare type ImageFormat = typeof validImageFormats[number];
+export declare type StillImageFormat = 'png' | 'jpeg';
 export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat, imageFormat: ImageFormat) => 'none' | 'valid';
+export declare const validateNonNullImageFormat: (imageFormat: ImageFormat) => void;

package/dist/image-format.js

@@ -2,6 +2,30 @@
 // Keeping the default image format PNG if you don't pass a
 // value to the renderer for backwards compatibility.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_IMAGE_FORMAT = void 0;
+exports.validateNonNullImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_IMAGE_FORMAT = exports.validImageFormats = void 0;
+exports.validImageFormats = ['png', 'jpeg', 'none'];
 // However, the CLI will override it and use JPEG if suitable.
 exports.DEFAULT_IMAGE_FORMAT = 'png';
+// By returning a value, we improve testability as we can specifically test certain branches
+const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, imageFormat) => {
+    if (imageFormat === 'none') {
+        return 'none';
+    }
+    if (!exports.validImageFormats.includes(imageFormat)) {
+        throw new TypeError(`Value ${imageFormat} is not valid as an image format.`);
+    }
+    if (pixelFormat !== 'yuva420p' && pixelFormat !== 'yuva444p10le') {
+        return 'valid';
+    }
+    if (imageFormat !== 'png') {
+        throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
+    }
+    return 'valid';
+};
+exports.validateSelectedPixelFormatAndImageFormatCombination = validateSelectedPixelFormatAndImageFormatCombination;
+const validateNonNullImageFormat = (imageFormat) => {
+    if (imageFormat !== 'jpeg' && imageFormat !== 'png') {
+        throw new TypeError('Image format should be either "png" or "jpeg"');
+    }
+};
+exports.validateNonNullImageFormat = validateNonNullImageFormat;

package/dist/index.d.ts

@@ -1,20 +1,36 @@
+import execa from 'execa';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
+import { mimeContentType, mimeLookup } from './mime-types';
+import * as perf from './perf';
 export type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+export type { DownloadMap } from './assets/download-map';
+export { Browser } from './browser';
+export { BrowserExecutable } from './browser-executable';
 export { BrowserLog } from './browser-log';
+export { Codec, CodecOrUndefined } from './codec';
 export { combineVideos } from './combine-videos';
+export { Crf } from './crf';
 export { ErrorWithStackFrame } from './error-handling/handle-javascript-exception';
+export { FfmpegExecutable } from './ffmpeg-executable';
 export { FfmpegVersion } from './ffmpeg-flags';
+export { FrameRange } from './frame-range';
 export { getCompositions } from './get-compositions';
+export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, validImageFormats, } from './image-format';
+export type { LogLevel } from './log-level';
+export { CancelSignal, makeCancelSignal } from './make-cancel-signal';
 export { openBrowser } from './open-browser';
 export type { ChromiumOptions } from './open-browser';
+export { PixelFormat } from './pixel-format';
+export { ProResProfile } from './prores-profile';
 export { renderFrames } from './render-frames';
 export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, StitchingState, } from './render-media';
 export { renderStill } from './render-still';
 export { StitcherOptions, stitchFramesToVideo } from './stitch-frames-to-video';
 export { SymbolicatedStackFrame } from './symbolicate-stacktrace';
 export { OnStartData, RenderFramesOutput } from './types';
+export { OpenGlRenderer } from './validate-opengl-renderer';
 export declare const RenderInternals: {
-    ensureLocalBrowser: (browser: import("remotion").Browser, preferredBrowserExecutable: import("remotion").BrowserExecutable) => Promise<void>;
+    ensureLocalBrowser: (browser: import("./browser").Browser, preferredBrowserExecutable: import("./browser-executable").BrowserExecutable) => Promise<void>;
     ffmpegHasFeature: ({ ffmpegExecutable, feature, isLambda, }: {
         ffmpegExecutable: string | null;
         feature: "enable-gpl" | "enable-libx265" | "enable-libvpx";
@@ -29,9 +45,14 @@ export declare const RenderInternals: {
     getFfmpegBuildInfo: (options: {
         ffmpegExecutable: string | null;
     }) => Promise<string>;
-    serveStatic: (path: string, options?: {
-        port?: number | undefined;
-    } | undefined) => Promise<{
+    serveStatic: (path: string | null, options: {
+        port: number | null;
+        ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable;
+        ffprobeExecutable: import("./ffmpeg-executable").FfmpegExecutable;
+        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
+        onError: (err: Error) => void;
+        downloadMap: import("./assets/download-map").DownloadMap;
+    }) => Promise<{
         port: number;
         close: () => Promise<void>;
     }>;
@@ -39,37 +60,90 @@ export declare const RenderInternals: {
         width: number;
         height: number;
         scale: number;
-        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv";
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     }) => void;
     normalizeServeUrl: (unnormalized: string) => string;
     spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
-        task: Promise<unknown>;
+        task: Promise<Buffer | null>;
         getLogs: () => string;
     }>;
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";
-    makeAssetsDownloadTmpDir: () => string;
+    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => Promise<void>;
-    prepareServer: (webpackConfigOrServeUrl: string) => Promise<{
-        serveUrl: string;
-        closeServer: () => Promise<void>;
-    }>;
     isServeUrl: (potentialUrl: string) => boolean;
     ensureOutputDirectory: (outputLocation: string) => void;
-    getRealFrameRange: (durationInFrames: number, frameRange: import("remotion").FrameRange | null) => [number, number];
+    getRealFrameRange: (durationInFrames: number, frameRange: import("./frame-range").FrameRange | null) => [number, number];
     validatePuppeteerTimeout: (timeoutInMilliseconds: unknown) => void;
-    downloadFile: (url: string, to: string, onProgress: ((progress: {
-        progress: number;
-        downloaded: number;
-        totalSize: number;
-    }) => void) | undefined) => Promise<{
+    downloadFile: ({ onProgress, url, to: toFn, }: {
+        url: string;
+        to: (contentDisposition: string | null, contentType: string | null) => string;
+        onProgress: ((progress: {
+            percent: number | null;
+            downloaded: number;
+            totalSize: number | null;
+        }) => void) | undefined;
+    }) => Promise<{
         sizeInBytes: number;
+        to: string;
     }>;
     validateScale: (scale: unknown) => void;
     killAllBrowsers: () => Promise<void>;
     parseStack: (stack: string[]) => import("./parse-browser-error-stack").UnsymbolicatedStackFrame[];
     symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<import("./error-handling/handle-javascript-exception").ErrorWithStackFrame>;
     SymbolicateableError: typeof SymbolicateableError;
-    getDurationFromFrameRange: (frameRange: import("remotion").FrameRange | null, durationInFrames: number) => number;
-    getExtensionOfFilename: (filename: string) => string | null;
+    getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];
+    getExtensionOfFilename: (filename: string | null) => string | null;
+    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+    isPathInside: (thePath: string, potentialParent: string) => boolean;
+    execa: {
+        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        (file: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        (file: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        sync(file: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        sync(file: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        command(command: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        command(command: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        commandSync(command: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
+        commandSync(command: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
+        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.NodeOptions<string> | undefined): execa.ExecaChildProcess<string>;
+        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+        node(scriptPath: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
+        node(scriptPath: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
+    };
+    registerErrorSymbolicationLock: () => number;
+    unlockErrorSymbolicationLock: (id: number) => void;
+    canUseParallelEncoding: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    mimeContentType: typeof mimeContentType;
+    mimeLookup: typeof mimeLookup;
+    validateConcurrency: (value: unknown, setting: string) => void;
+    validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
+    DEFAULT_BROWSER: import("./browser").Browser;
+    validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
+    DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | null;
+    validateOpenGlRenderer: (option: "angle" | "swangle" | "egl" | "swiftshader" | null) => "angle" | "swangle" | "egl" | "swiftshader" | null;
+    getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
+    validateSelectedCrfAndCodecCombination: (crf: unknown, codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
+    validImageFormats: readonly ["png", "jpeg", "none"];
+    validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
+    DEFAULT_OVERWRITE: boolean;
+    DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    validateQuality: (q: number | undefined) => void;
+    validateFrame: (frame: number, durationInFrames: number) => void;
+    DEFAULT_TIMEOUT: number;
+    getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
+    validateSelectedPixelFormatAndCodecCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
+    validateSelectedCodecAndProResCombination: (actualCodec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", actualProResProfile: "proxy" | "4444-xq" | "4444" | "hq" | "standard" | "light" | undefined) => void;
+    validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", imageFormat: "jpeg" | "png" | "none") => "none" | "valid";
+    DEFAULT_CODEC: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    logLevels: readonly ["verbose", "info", "warn", "error"];
+    isEqualOrBelowLogLevel: (currentLevel: "error" | "verbose" | "info" | "warn", level: "error" | "verbose" | "info" | "warn") => boolean;
+    isValidLogLevel: (level: string) => boolean;
+    validateEveryNthFrame: (everyNthFrame: unknown) => void;
+    perf: typeof perf;
+    makeDownloadMap: () => import("./assets/download-map").DownloadMap;
+    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => Promise<void>;
 };