@remotion/renderer 3.1.5 → 3.1.8

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

@@ -1,8 +1,3 @@
-import type { FfmpegExecutable } from 'remotion';
-declare type Result = {
-    specialVcodec: SpecialVCodecForTransparency;
-    needsResize: [number, number] | null;
-};
-export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
-export declare const getVideoInfo: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
-export {};
+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

@@ -7,12 +7,11 @@ 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 isVp9VideoCache = {};
 const limit = (0, p_limit_1.pLimit)(1);
-async function getVideoInfoUnlimited(src, ffprobeExecutable) {
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable) {
     var _a;
-    if (typeof isVp9VideoCache[src] !== 'undefined') {
-        return isVp9VideoCache[src];
+    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');
@@ -41,10 +40,10 @@ async function getVideoInfoUnlimited(src, ffprobeExecutable) {
         specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
         needsResize,
     };
-    isVp9VideoCache[src] = result;
-    return isVp9VideoCache[src];
+    downloadMap.isVp9VideoCache[src] = result;
+    return downloadMap.isVp9VideoCache[src];
 }
-const getVideoInfo = (src, ffprobeExecutable) => {
-    return limit(() => getVideoInfoUnlimited(src, ffprobeExecutable));
+const getVideoInfo = (downloadMap, src, ffprobeExecutable) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable));
 };
 exports.getVideoInfo = getVideoInfo;

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

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

package/dist/image-format.d.ts

@@ -1,2 +1,7 @@
-import type { 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,24 +1,36 @@
-/// <reference types="node" />
 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";
@@ -35,11 +47,11 @@ export declare const RenderInternals: {
     }) => Promise<string>;
     serveStatic: (path: string | null, options: {
         port: number | null;
-        ffmpegExecutable: import("remotion").FfmpegExecutable;
-        ffprobeExecutable: import("remotion").FfmpegExecutable;
-        downloadDir: string;
+        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>;
@@ -48,19 +60,19 @@ export declare const RenderInternals: {
         width: number;
         height: number;
         scale: number;
-        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     }) => void;
     normalizeServeUrl: (unnormalized: string) => string;
     spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
         task: Promise<Buffer | null>;
         getLogs: () => 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";
+    getFileExtensionFromCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => 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: ({ onProgress, url, to: toFn, }: {
         url: string;
@@ -80,7 +92,7 @@ export declare const RenderInternals: {
     symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<import("./error-handling/handle-javascript-exception").ErrorWithStackFrame>;
     SymbolicateableError: typeof SymbolicateableError;
     getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];
-    getExtensionOfFilename: (filename: string) => string | null;
+    getExtensionOfFilename: (filename: string | null) => string | null;
     getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
     isPathInside: (thePath: string, potentialParent: string) => boolean;
     execa: {
@@ -103,8 +115,35 @@ export declare const RenderInternals: {
     };
     registerErrorSymbolicationLock: () => number;
     unlockErrorSymbolicationLock: (id: number) => void;
-    canUseParallelEncoding: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    canUseParallelEncoding: (codec: "vp9" | "vp8" | "h264" | "h265" | "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: "swangle" | "angle" | "egl" | "swiftshader" | null;
+    validateOpenGlRenderer: (option: "swangle" | "angle" | "egl" | "swiftshader" | null) => "swangle" | "angle" | "egl" | "swiftshader" | null;
+    getDefaultCrfForCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
+    validateSelectedCrfAndCodecCombination: (crf: unknown, codec: "vp9" | "vp8" | "h264" | "h265" | "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: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
+    validateSelectedPixelFormatAndCodecCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
+    validateSelectedCodecAndProResCombination: (actualCodec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", actualProResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined) => void;
+    validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", imageFormat: "none" | "png" | "jpeg") => "none" | "valid";
+    DEFAULT_CODEC: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    isAudioCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    logLevels: readonly ["verbose", "info", "warn", "error"];
+    isEqualOrBelowLogLevel: (currentLevel: "verbose" | "info" | "warn" | "error", level: "verbose" | "info" | "warn" | "error") => 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>;
 };

package/dist/index.js

@@ -1,17 +1,46 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderInternals = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.getCompositions = exports.ErrorWithStackFrame = exports.combineVideos = void 0;
+exports.RenderInternals = exports.stitchFramesToVideo = exports.renderStill = exports.renderMedia = exports.renderFrames = exports.openBrowser = exports.makeCancelSignal = exports.validImageFormats = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.getCompositions = exports.ErrorWithStackFrame = exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const download_file_1 = require("./assets/download-file");
+const download_map_1 = require("./assets/download-map");
+const browser_1 = require("./browser");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
+const codec_1 = require("./codec");
+const crf_1 = require("./crf");
 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 ffmpeg_flags_1 = require("./ffmpeg-flags");
+const frame_range_1 = require("./frame-range");
 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");
@@ -19,18 +48,29 @@ const get_extension_of_filename_1 = require("./get-extension-of-filename");
 const get_frame_to_render_1 = require("./get-frame-to-render");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
 const get_port_1 = require("./get-port");
+const image_format_1 = require("./image-format");
+const is_audio_codec_1 = require("./is-audio-codec");
 const is_serve_url_1 = require("./is-serve-url");
+const log_level_1 = require("./log-level");
 const mime_types_1 = require("./mime-types");
 const normalize_serve_url_1 = require("./normalize-serve-url");
 const open_browser_1 = require("./open-browser");
+const overwrite_1 = require("./overwrite");
 const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+const perf = __importStar(require("./perf"));
+const pixel_format_1 = require("./pixel-format");
+const prores_profile_1 = require("./prores-profile");
+const quality_1 = require("./quality");
 const is_path_inside_1 = require("./serve-handler/is-path-inside");
 const serve_static_1 = require("./serve-static");
 const stitch_frames_to_video_1 = require("./stitch-frames-to-video");
 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");
+const validate_every_nth_frame_1 = require("./validate-every-nth-frame");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const validate_frame_1 = require("./validate-frame");
+const validate_opengl_renderer_1 = require("./validate-opengl-renderer");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const validate_scale_1 = require("./validate-scale");
 const wait_for_symbolication_error_to_be_done_1 = require("./wait-for-symbolication-error-to-be-done");
@@ -40,6 +80,9 @@ var handle_javascript_exception_1 = require("./error-handling/handle-javascript-
 Object.defineProperty(exports, "ErrorWithStackFrame", { enumerable: true, get: function () { return handle_javascript_exception_1.ErrorWithStackFrame; } });
 var get_compositions_1 = require("./get-compositions");
 Object.defineProperty(exports, "getCompositions", { enumerable: true, get: function () { return get_compositions_1.getCompositions; } });
+var image_format_2 = require("./image-format");
+Object.defineProperty(exports, "validateSelectedPixelFormatAndImageFormatCombination", { enumerable: true, get: function () { return image_format_2.validateSelectedPixelFormatAndImageFormatCombination; } });
+Object.defineProperty(exports, "validImageFormats", { enumerable: true, get: function () { return image_format_2.validImageFormats; } });
 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");
@@ -88,4 +131,31 @@ exports.RenderInternals = {
     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: validate_opengl_renderer_1.DEFAULT_OPENGL_RENDERER,
+    validateOpenGlRenderer: validate_opengl_renderer_1.validateOpenGlRenderer,
+    getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
+    validateSelectedCrfAndCodecCombination: crf_1.validateSelectedCrfAndCodecCombination,
+    validImageFormats: image_format_1.validImageFormats,
+    validCodecs: codec_1.validCodecs,
+    DEFAULT_OVERWRITE: overwrite_1.DEFAULT_OVERWRITE,
+    DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    validateQuality: quality_1.validateQuality,
+    validateFrame: validate_frame_1.validateFrame,
+    DEFAULT_TIMEOUT: TimeoutSettings_1.DEFAULT_TIMEOUT,
+    getValidCrfRanges: crf_1.getValidCrfRanges,
+    validateSelectedPixelFormatAndCodecCombination: pixel_format_1.validateSelectedPixelFormatAndCodecCombination,
+    validateSelectedCodecAndProResCombination: prores_profile_1.validateSelectedCodecAndProResCombination,
+    validateSelectedPixelFormatAndImageFormatCombination: image_format_1.validateSelectedPixelFormatAndImageFormatCombination,
+    DEFAULT_CODEC: codec_1.DEFAULT_CODEC,
+    isAudioCodec: is_audio_codec_1.isAudioCodec,
+    logLevels: log_level_1.logLevels,
+    isEqualOrBelowLogLevel: log_level_1.isEqualOrBelowLogLevel,
+    isValidLogLevel: log_level_1.isValidLogLevel,
+    validateEveryNthFrame: validate_every_nth_frame_1.validateEveryNthFrame,
+    perf,
+    makeDownloadMap: download_map_1.makeDownloadMap,
+    cleanDownloadMap: download_map_1.cleanDownloadMap,
 };

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

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

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/dist/is-beyond-last-frame.d.ts

@@ -1,2 +1,3 @@
-export declare const isBeyondLastFrame: (src: string, time: number) => boolean | 0;
-export declare const markAsBeyondLastFrame: (src: string, time: number) => void;
+import type { DownloadMap } from './assets/download-map';
+export declare const isBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => boolean | 0;
+export declare const markAsBeyondLastFrame: (downloadMap: DownloadMap, src: string, time: number) => void;

package/dist/is-beyond-last-frame.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.markAsBeyondLastFrame = exports.isBeyondLastFrame = void 0;
-const map = {};
-const isBeyondLastFrame = (src, time) => {
-    return map[src] && time >= map[src];
+const isBeyondLastFrame = (downloadMap, src, time) => {
+    return (downloadMap.isBeyondLastFrameMap[src] &&
+        time >= downloadMap.isBeyondLastFrameMap[src]);
 };
 exports.isBeyondLastFrame = isBeyondLastFrame;
-const markAsBeyondLastFrame = (src, time) => {
-    map[src] = time;
+const markAsBeyondLastFrame = (downloadMap, src, time) => {
+    downloadMap.isBeyondLastFrameMap[src] = time;
 };
 exports.markAsBeyondLastFrame = markAsBeyondLastFrame;

package/dist/last-frame-from-video-cache.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
-import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
-import type { SpecialVCodecForTransparency } from './get-video-info';
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare type LastFrameOptions = {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
@@ -9,7 +9,8 @@ export declare type LastFrameOptions = {
     specialVCodecForTransparency: SpecialVCodecForTransparency;
     imageFormat: OffthreadVideoImageFormat;
     needsResize: [number, number] | null;
+    downloadMap: DownloadMap;
 };
 export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
 export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;
-export declare const clearLastFileCache: () => void;
+export declare const clearLastFileCache: (downloadMap: DownloadMap) => void;

package/dist/last-frame-from-video-cache.js

@@ -2,7 +2,6 @@
 // OffthreadVideo requires sometimes that the last frame of a video gets extracted, however, this can be slow. We allocate a cache for it but that can be garbage collected
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearLastFileCache = exports.getLastFrameFromCache = exports.setLastFrameInCache = void 0;
-let map = {};
 const MAX_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
 let bufferSize = 0;
 const makeLastFrameCacheKey = (options) => {
@@ -11,45 +10,46 @@ const makeLastFrameCacheKey = (options) => {
         options.offset,
         options.src,
         options.imageFormat,
+        options.downloadMap.id,
     ].join('-');
 };
 const setLastFrameInCache = (options, data) => {
     const key = makeLastFrameCacheKey(options);
-    if (map[key]) {
-        bufferSize -= map[key].data.byteLength;
+    if (options.downloadMap.lastFrameMap[key]) {
+        bufferSize -= options.downloadMap.lastFrameMap[key].data.byteLength;
     }
-    map[key] = { data, lastAccessed: Date.now() };
+    options.downloadMap.lastFrameMap[key] = { data, lastAccessed: Date.now() };
     bufferSize += data.byteLength;
-    ensureMaxSize();
+    ensureMaxSize(options.downloadMap);
 };
 exports.setLastFrameInCache = setLastFrameInCache;
 const getLastFrameFromCache = (options) => {
     var _a;
     const key = makeLastFrameCacheKey(options);
-    if (!map[key]) {
+    if (!options.downloadMap.lastFrameMap[key]) {
         return null;
     }
-    map[key].lastAccessed = Date.now();
-    return (_a = map[key].data) !== null && _a !== void 0 ? _a : null;
+    options.downloadMap.lastFrameMap[key].lastAccessed = Date.now();
+    return (_a = options.downloadMap.lastFrameMap[key].data) !== null && _a !== void 0 ? _a : null;
 };
 exports.getLastFrameFromCache = getLastFrameFromCache;
-const removedLastFrameFromCache = (key) => {
-    if (!map[key]) {
+const removedLastFrameFromCache = (key, downloadMap) => {
+    if (!downloadMap.lastFrameMap[key]) {
         return;
     }
-    bufferSize -= map[key].data.byteLength;
-    delete map[key];
+    bufferSize -= downloadMap.lastFrameMap[key].data.byteLength;
+    delete downloadMap.lastFrameMap[key];
 };
-const ensureMaxSize = () => {
+const ensureMaxSize = (downloadMap) => {
     // eslint-disable-next-line no-unmodified-loop-condition
     while (bufferSize > MAX_CACHE_SIZE) {
-        const earliest = Object.entries(map).sort((a, b) => {
+        const earliest = Object.entries(downloadMap.lastFrameMap).sort((a, b) => {
             return a[1].lastAccessed - b[1].lastAccessed;
         })[0];
-        removedLastFrameFromCache(earliest[0]);
+        removedLastFrameFromCache(earliest[0], downloadMap);
     }
 };
-const clearLastFileCache = () => {
-    map = {};
+const clearLastFileCache = (downloadMap) => {
+    downloadMap.lastFrameMap = {};
 };
 exports.clearLastFileCache = clearLastFileCache;

package/dist/log-level.d.ts

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

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 = ['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/dist/merge-audio-track.d.ts

@@ -1,9 +1,11 @@
-import type { FfmpegExecutable } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 declare type Options = {
     ffmpegExecutable: FfmpegExecutable;
     files: string[];
     outName: string;
     numberOfSeconds: number;
+    downloadMap: DownloadMap;
 };
 export declare const mergeAudioTrack: (options: Options) => Promise<void>;
 export {};

package/dist/merge-audio-track.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeAudioTrack = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
-const remotion_1 = require("remotion");
 const chunk_1 = require("./chunk");
 const convert_to_pcm_1 = require("./convert-to-pcm");
 const create_ffmpeg_complex_filter_1 = require("./create-ffmpeg-complex-filter");
@@ -14,7 +13,8 @@ const create_silent_audio_1 = require("./create-silent-audio");
 const delete_directory_1 = require("./delete-directory");
 const p_limit_1 = require("./p-limit");
 const tmp_dir_1 = require("./tmp-dir");
-const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numberOfSeconds, }) => {
+const truthy_1 = require("./truthy");
+const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numberOfSeconds, downloadMap, }) => {
     if (files.length === 0) {
         await (0, create_silent_audio_1.createSilentAudio)({
             outName,
@@ -42,6 +42,7 @@ const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numb
                 files: chunkFiles,
                 numberOfSeconds,
                 outName: chunkOutname,
+                downloadMap,
             });
             return chunkOutname;
         }));
@@ -50,11 +51,12 @@ const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numb
             files: chunkNames,
             numberOfSeconds,
             outName,
+            downloadMap,
         });
         await (0, delete_directory_1.deleteDirectory)(tempPath);
         return;
     }
-    const { complexFilterFlag: mergeFilter, cleanup } = await (0, create_ffmpeg_complex_filter_1.createFfmpegComplexFilter)(files.length);
+    const { complexFilterFlag: mergeFilter, cleanup } = await (0, create_ffmpeg_complex_filter_1.createFfmpegComplexFilter)(files.length, downloadMap);
     const args = [
         ...files.map((f) => ['-i', f]),
         mergeFilter,
@@ -62,7 +64,7 @@ const mergeAudioTrackUnlimited = async ({ ffmpegExecutable, outName, files, numb
         ['-map', '[a]'],
         ['-y', outName],
     ]
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .flat(2);
     const task = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', args);
     await task;

package/dist/offthread-video-server.d.ts

@@ -1,15 +1,17 @@
 import type { RequestListener } from 'http';
-import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
+import type { OffthreadVideoImageFormat } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const extractUrlAndSourceFromUrl: (url: string) => {
     src: string;
     time: number;
     imageFormat: OffthreadVideoImageFormat;
 };
-export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }: {
+export declare const startOffthreadVideoServer: ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, }: {
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
-    downloadDir: string;
     onDownload: RenderMediaOnDownload;
     onError: (err: Error) => void;
+    downloadMap: DownloadMap;
 }) => RequestListener;

package/dist/offthread-video-server.js

@@ -32,7 +32,7 @@ const extractUrlAndSourceFromUrl = (url) => {
     };
 };
 exports.extractUrlAndSourceFromUrl = extractUrlAndSourceFromUrl;
-const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downloadDir, onDownload, onError, }) => {
+const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, onDownload, onError, downloadMap, }) => {
     return (req, res) => {
         if (!req.url) {
             throw new Error('Request came in without URL');
@@ -45,7 +45,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downlo
         const { src, time, imageFormat } = (0, exports.extractUrlAndSourceFromUrl)(req.url);
         res.setHeader('access-control-allow-origin', '*');
         res.setHeader('content-type', `image/${imageFormat === 'jpeg' ? 'jpg' : 'png'}`);
-        (0, download_and_map_assets_to_file_1.downloadAsset)({ src, downloadDir, onDownload })
+        (0, download_and_map_assets_to_file_1.downloadAsset)({ src, onDownload, downloadMap })
             .then((to) => {
             return (0, extract_frame_from_video_1.extractFrameFromVideo)({
                 time,
@@ -53,6 +53,7 @@ const startOffthreadVideoServer = ({ ffmpegExecutable, ffprobeExecutable, downlo
                 ffmpegExecutable,
                 ffprobeExecutable,
                 imageFormat,
+                downloadMap,
             });
         })
             .then((readable) => {

package/dist/open-browser.d.ts

@@ -1,4 +1,4 @@
-import type { Browser } from 'remotion';
+import type { Browser } from './browser';
 import type { Browser as PuppeteerBrowser } from './browser/Browser';
 import type { Viewport } from './browser/PuppeteerViewport';
 declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];