@remotion/renderer 4.0.16 → 4.0.18

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

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

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

@@ -0,0 +1,17 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export type LastFrameOptions = {
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    offset: number;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: [number, number] | null;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
+};
+export declare const setLastFrameInCache: (options: LastFrameOptions, data: Buffer) => void;
+export declare const getLastFrameFromCache: (options: LastFrameOptions) => Buffer | null;
+export declare const clearLastFileCache: (downloadMap: DownloadMap) => void;

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

@@ -0,0 +1,55 @@
+"use strict";
+// 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;
+const MAX_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
+let bufferSize = 0;
+const makeLastFrameCacheKey = (options) => {
+    return [
+        options.ffmpegExecutable,
+        options.offset,
+        options.src,
+        options.imageFormat,
+        options.downloadMap.id,
+    ].join('-');
+};
+const setLastFrameInCache = (options, data) => {
+    const key = makeLastFrameCacheKey(options);
+    if (options.downloadMap.lastFrameMap[key]) {
+        bufferSize -= options.downloadMap.lastFrameMap[key].data.byteLength;
+    }
+    options.downloadMap.lastFrameMap[key] = { data, lastAccessed: Date.now() };
+    bufferSize += data.byteLength;
+    ensureMaxSize(options.downloadMap);
+};
+exports.setLastFrameInCache = setLastFrameInCache;
+const getLastFrameFromCache = (options) => {
+    var _a;
+    const key = makeLastFrameCacheKey(options);
+    if (!options.downloadMap.lastFrameMap[key]) {
+        return 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, downloadMap) => {
+    if (!downloadMap.lastFrameMap[key]) {
+        return;
+    }
+    bufferSize -= downloadMap.lastFrameMap[key].data.byteLength;
+    delete downloadMap.lastFrameMap[key];
+};
+const ensureMaxSize = (downloadMap) => {
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (bufferSize > MAX_CACHE_SIZE) {
+        const earliest = Object.entries(downloadMap.lastFrameMap).sort((a, b) => {
+            return a[1].lastAccessed - b[1].lastAccessed;
+        })[0];
+        removedLastFrameFromCache(earliest[0], downloadMap);
+    }
+};
+const clearLastFileCache = (downloadMap) => {
+    downloadMap.lastFrameMap = {};
+};
+exports.clearLastFileCache = clearLastFileCache;

package/dist/legacy-webpack-config.d.ts

@@ -0,0 +1,9 @@
+export type ServeUrlOrWebpackBundle = {
+    serveUrl: string;
+} | {
+    /**
+     * @deprecated Renamed to `serveUrl`
+     */
+    webpackBundle: string;
+};
+export declare const getServeUrlWithFallback: (serve: ServeUrlOrWebpackBundle) => string;

package/dist/legacy-webpack-config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServeUrlWithFallback = void 0;
+const getServeUrlWithFallback = (serve) => {
+    if ('webpackBundle' in serve) {
+        return serve.webpackBundle;
+    }
+    if ('serveUrl' in serve) {
+        return serve.serveUrl;
+    }
+    throw new Error('You must pass the `serveUrl` parameter');
+};
+exports.getServeUrlWithFallback = getServeUrlWithFallback;

package/dist/open-browser.js

@@ -30,15 +30,15 @@ const killAllBrowsers = async () => {
 exports.killAllBrowsers = killAllBrowsers;
 const internalOpenBrowser = async ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, viewport, logLevel, }) => {
     var _a, _b;
+    // @ts-expect-error Firefox
     if (browser === 'firefox') {
         throw new TypeError('Firefox supported is not yet turned on. Stay tuned for the future.');
     }
-    await (0, get_local_browser_executable_1.ensureLocalBrowser)(browser, browserExecutable);
-    const executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)(browser, browserExecutable);
+    await (0, get_local_browser_executable_1.ensureLocalBrowser)(browserExecutable);
+    const executablePath = (0, get_local_browser_executable_1.getLocalBrowserExecutable)(browserExecutable);
     const customGlRenderer = getOpenGlRenderer((_a = chromiumOptions.gl) !== null && _a !== void 0 ? _a : null);
     const browserInstance = await node_1.puppeteer.launch({
         executablePath,
-        product: browser,
         dumpio: (0, log_level_1.isEqualOrBelowLogLevel)(logLevel, 'verbose'),
         logLevel,
         indent,

package/dist/quality.d.ts

@@ -0,0 +1 @@
+export declare const validateQuality: (q: number | undefined) => void;

package/dist/quality.js

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

package/dist/render-media.js

@@ -74,6 +74,7 @@ const internalRenderMedia = ({ proResProfile, crf, composition, serializedInputP
     let encodedFrames = 0;
     let muxedFrames = 0;
     let renderedFrames = 0;
+    let totalFramesToRender = 0;
     let renderedDoneIn = null;
     let encodedDoneIn = null;
     let cancelled = false;
@@ -133,6 +134,7 @@ const internalRenderMedia = ({ proResProfile, crf, composition, serializedInputP
         scale,
         width: composition.width,
     });
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange);
     const callUpdate = () => {
         onProgress === null || onProgress === void 0 ? void 0 : onProgress({
             encodedDoneIn,
@@ -141,10 +143,9 @@ const internalRenderMedia = ({ proResProfile, crf, composition, serializedInputP
             renderedFrames,
             stitchStage,
             progress: Math.round((70 * renderedFrames + 15 * encodedFrames + 15 * muxedFrames) /
-                composition.durationInFrames) / 100,
+                totalFramesToRender) / 100,
         });
     };
-    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(composition.durationInFrames, frameRange);
     const cancelRenderFrames = (0, make_cancel_signal_1.makeCancelSignal)();
     const cancelPrestitcher = (0, make_cancel_signal_1.makeCancelSignal)();
     const cancelStitcher = (0, make_cancel_signal_1.makeCancelSignal)();
@@ -247,6 +248,7 @@ const internalRenderMedia = ({ proResProfile, crf, composition, serializedInputP
                 outputDir: parallelEncoding ? null : workingDir,
                 onStart: (data) => {
                     renderedFrames = 0;
+                    totalFramesToRender = data.frameCount;
                     callUpdate();
                     onStart === null || onStart === void 0 ? void 0 : onStart(data);
                 },
@@ -328,6 +330,7 @@ const internalRenderMedia = ({ proResProfile, crf, composition, serializedInputP
                             muxedFrames = frame;
                         }
                         else {
+                            muxedFrames = frame;
                             encodedFrames = frame;
                         }
                         callUpdate();

package/dist/set-props-and-env.js

@@ -114,9 +114,12 @@ const innerSetPropsAndEnv = async ({ serializedInputPropsWithCustomSchema, envVa
     if (siteVersion !== requiredVersion) {
         throw new Error([
             `Incompatible site: When visiting ${urlToVisit}, a bundle was found, but one that is not compatible with this version of Remotion. Found version: ${siteVersion} - Required version: ${requiredVersion}. To resolve this error:`,
-            '▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.',
-            '  ℹ Use --site-name with the same name as before to overwrite your site.',
-            '▸ Use `deploySite()` if you are using the Node.JS APIs.',
+            'When using server-side rendering:',
+            ` ▸ Use 'bundle()' with '@remotion/bundler' of version ${version_1.VERSION} to create a compatible bundle.`,
+            'When using the Remotion Lambda:',
+            ' ▸ Use `npx remotion lambda sites create` to redeploy the site with the latest version.',
+            ' ℹ Use --site-name with the same name as before to overwrite your site.',
+            ' ▸ Use `deploySite()` if you are using the Node.JS APIs.',
         ].join('\n'));
     }
     if (remotionVersion !== version_1.VERSION && process.env.NODE_ENV !== 'test') {

package/dist/stitch-frames-to-video.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { RenderAssetInfo } from './assets/download-map';
 import type { AudioCodec } from './audio-codec';

package/dist/try-to-extract-frame-of-video-fast.d.ts

@@ -0,0 +1,12 @@
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { NeedsResize, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const tryToExtractFrameOfVideoFast: ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: NeedsResize;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    actualOffset: string;
+}) => Promise<readonly [string, Buffer]>;

package/dist/try-to-extract-frame-of-video-fast.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToExtractFrameOfVideoFast = void 0;
+const execa_1 = __importDefault(require("execa"));
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const truthy_1 = require("./truthy");
+const tryToExtractFrameOfVideoFast = async ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }) => {
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-ss',
+        actualOffset,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
+        '-i',
+        src,
+        '-frames:v',
+        '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        '-f',
+        'image2pipe',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
+        '-',
+    ].filter(truthy_1.truthy));
+    if (!stderr) {
+        throw new Error('unexpectedly did not get stderr');
+    }
+    if (!stdout) {
+        throw new Error('unexpectedly did not get stdout');
+    }
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    const stdErrString = new Promise((resolve, reject) => {
+        stderr.on('data', (d) => stderrChunks.push(d));
+        stderr.on('error', (err) => reject(err));
+        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
+    });
+    const stdoutChunk = new Promise((resolve, reject) => {
+        stdout.on('data', (d) => {
+            stdoutChunks.push(d);
+        });
+        stdout.on('error', (err) => {
+            reject(err);
+        });
+        stdout.on('end', () => {
+            resolve(Buffer.concat(stdoutChunks));
+        });
+    });
+    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
+    return [stdErr, stdoutBuffer];
+};
+exports.tryToExtractFrameOfVideoFast = tryToExtractFrameOfVideoFast;

package/dist/validate-ffmpeg.d.ts

@@ -0,0 +1,7 @@
+export declare const customExecutableExists: (localExecutable: string) => boolean;
+export declare const binaryExists: (name: 'ffmpeg' | 'ffprobe') => boolean;
+export declare const checkAndValidateFfmpegVersion: (options: {
+    ffmpegExecutable: string | null;
+    remotionRoot: string;
+}) => Promise<void>;
+export declare const validateFfmpeg: (customFfmpegBinary: string | null, remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => Promise<void>;

package/dist/validate-ffmpeg.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFfmpeg = exports.checkAndValidateFfmpegVersion = exports.binaryExists = exports.customExecutableExists = void 0;
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const warn_about_ffmpeg_version_1 = require("./warn-about-ffmpeg-version");
+const existsMap = {};
+const customExecutableExists = (localExecutable) => {
+    try {
+        (0, fs_1.statSync)(localExecutable);
+        existsMap[localExecutable] = true;
+    }
+    catch (err) {
+        existsMap[localExecutable] = false;
+    }
+    return existsMap[localExecutable];
+};
+exports.customExecutableExists = customExecutableExists;
+const binaryExists = (name) => {
+    if (typeof existsMap[name] !== 'undefined') {
+        return existsMap[name];
+    }
+    const isWin = os_1.default.platform() === 'win32';
+    const where = isWin ? 'where' : 'which';
+    try {
+        execa_1.default.sync(where, [name]);
+        existsMap[name] = true;
+        return true;
+    }
+    catch (err) {
+        existsMap[name] = false;
+        return false;
+    }
+};
+exports.binaryExists = binaryExists;
+const checkAndValidateFfmpegVersion = async (options) => {
+    const ffmpegVersion = await (0, ffmpeg_flags_1.getFfmpegVersion)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    const buildConf = await (0, ffmpeg_flags_1.getFfmpegBuildInfo)({
+        ffmpegExecutable: options.ffmpegExecutable,
+        remotionRoot: options.remotionRoot,
+    });
+    (0, warn_about_ffmpeg_version_1.warnAboutFfmpegVersion)({ ffmpegVersion, buildConf });
+};
+exports.checkAndValidateFfmpegVersion = checkAndValidateFfmpegVersion;
+const validateFfmpeg = async (customFfmpegBinary, remotionRoot, binary) => {
+    const ffmpegExists = (0, exports.binaryExists)(binary);
+    if (ffmpegExists) {
+        return;
+    }
+    if (customFfmpegBinary) {
+        if (!(0, exports.customExecutableExists)(customFfmpegBinary)) {
+            throw new Error('Custom FFmpeg executable not found: ' + customFfmpegBinary);
+        }
+        return;
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return;
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return;
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return (0, exports.validateFfmpeg)(customFfmpegBinary, remotionRoot, binary);
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+exports.validateFfmpeg = validateFfmpeg;

package/dist/validate-opengl-renderer.d.ts

@@ -1,5 +1,4 @@
-declare const validRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
-export type OpenGlRenderer = typeof validRenderers[number];
+export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
+export type OpenGlRenderer = typeof validOpenGlRenderers[number];
 export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
 export declare const validateOpenGlRenderer: (option: OpenGlRenderer | null) => OpenGlRenderer | null;
-export {};

package/dist/validate-opengl-renderer.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOpenGlRenderer = exports.DEFAULT_OPENGL_RENDERER = void 0;
-const validRenderers = ['swangle', 'angle', 'egl', 'swiftshader'];
+exports.validateOpenGlRenderer = exports.DEFAULT_OPENGL_RENDERER = exports.validOpenGlRenderers = void 0;
+exports.validOpenGlRenderers = [
+    'swangle',
+    'angle',
+    'egl',
+    'swiftshader',
+];
 exports.DEFAULT_OPENGL_RENDERER = null;
 const validateOpenGlRenderer = (option) => {
     if (option === null) {
         return null;
     }
-    if (!validRenderers.includes(option)) {
-        throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${validRenderers.join(', ')}`);
+    if (!exports.validOpenGlRenderers.includes(option)) {
+        throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${exports.validOpenGlRenderers.join(', ')}`);
     }
     return option;
 };

package/dist/validate-output-filename.d.ts

@@ -1,5 +1,5 @@
 import type { AudioCodec } from './audio-codec';
-export declare const validateOutputFilename: <T extends "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+export declare const validateOutputFilename: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
     codec: T;
     audioCodec: AudioCodec | null;
     extension: string;

package/dist/warn-about-ffmpeg-version.d.ts

@@ -0,0 +1,5 @@
+import type { FfmpegVersion } from './ffmpeg-flags';
+export declare const warnAboutFfmpegVersion: ({ ffmpegVersion, buildConf, }: {
+    ffmpegVersion: FfmpegVersion;
+    buildConf: string | null;
+}) => null | undefined;

package/dist/warn-about-ffmpeg-version.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnAboutFfmpegVersion = void 0;
+const printMessage = (ffmpegVersion) => {
+    console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
+    console.warn('   For audio support, you need at least version 4.1.0.');
+    console.warn('   Upgrade FFMPEG to get rid of this warning.');
+};
+const printBuildConfMessage = () => {
+    console.error('⚠️  Unsupported FFMPEG version detected.');
+    console.error("   Your version doesn't support the -buildconf flag");
+    console.error('   Audio will not be supported and you may experience other issues.');
+    console.error('   Upgrade FFMPEG to at least v4.1.0 to get rid of this warning.');
+};
+const warnAboutFfmpegVersion = ({ ffmpegVersion, buildConf, }) => {
+    if (buildConf === null) {
+        printBuildConfMessage();
+        return;
+    }
+    if (ffmpegVersion === null) {
+        return null;
+    }
+    const [major, minor] = ffmpegVersion;
+    // 3.x and below definitely is too old
+    if (major < 4) {
+        printMessage(ffmpegVersion);
+        return;
+    }
+    // 5.x will be all good
+    if (major > 4) {
+        return;
+    }
+    if (minor < 1) {
+        printMessage(ffmpegVersion);
+    }
+};
+exports.warnAboutFfmpegVersion = warnAboutFfmpegVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/renderer",
-  "version": "4.0.16",
+  "version": "4.0.18",
   "description": "Renderer for Remotion",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "extract-zip": "2.0.1",
     "source-map": "^0.8.0-beta.0",
     "ws": "8.7.0",
-    "remotion": "4.0.16"
+    "remotion": "4.0.18"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
@@ -37,18 +37,17 @@
     "prettier-plugin-organize-imports": "^3.2.2",
     "react": "18.0.0",
     "react-dom": "18.0.0",
-    "typescript": "4.9.5",
     "vitest": "0.31.1",
     "zod": "^3.21.4"
   },
   "optionalDependencies": {
-    "@remotion/compositor-darwin-x64": "4.0.16",
-    "@remotion/compositor-darwin-arm64": "4.0.16",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.16",
-    "@remotion/compositor-linux-arm64-musl": "4.0.16",
-    "@remotion/compositor-linux-x64-gnu": "4.0.16",
-    "@remotion/compositor-linux-x64-musl": "4.0.16",
-    "@remotion/compositor-win32-x64-msvc": "4.0.16"
+    "@remotion/compositor-darwin-arm64": "4.0.18",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.18",
+    "@remotion/compositor-darwin-x64": "4.0.18",
+    "@remotion/compositor-linux-arm64-musl": "4.0.18",
+    "@remotion/compositor-linux-x64-gnu": "4.0.18",
+    "@remotion/compositor-linux-x64-musl": "4.0.18",
+    "@remotion/compositor-win32-x64-msvc": "4.0.18"
   },
   "keywords": [
     "remotion",