@remotion/renderer 3.0.19 → 3.0.22

package/dist/browser/mitt/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+function mitt(all) {
+    all = all || new Map();
+    return {
+        /**
+         * A Map of event names to registered handler functions.
+         */
+        all,
+        /**
+         * Register an event handler for the given type.
+         * @param {string|symbol} type Type of event to listen for, or `"*"` for all events
+         * @param {Function} handler Function to call in response to given event
+         * @memberOf mitt
+         */
+        on(type, handler) {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            const added = handlers === null || handlers === void 0 ? void 0 : handlers.push(handler);
+            if (!added) {
+                all === null || all === void 0 ? void 0 : all.set(type, [handler]);
+            }
+        },
+        off(type, handler) {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            if (handlers) {
+                // eslint-disable-next-line no-bitwise
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(type, evt) {
+            ((all === null || all === void 0 ? void 0 : all.get(type)) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(evt);
+            });
+            ((all === null || all === void 0 ? void 0 : all.get('*')) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(type, evt);
+            });
+        },
+    };
+}
+exports.default = mitt;

package/dist/browser/node.d.ts

@@ -0,0 +1,2 @@
+import { PuppeteerNode } from './PuppeteerNode';
+export declare const puppeteer: PuppeteerNode;

package/dist/browser/node.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteer = void 0;
+const PuppeteerNode_1 = require("./PuppeteerNode");
+const revisions_1 = require("./revisions");
+exports.puppeteer = new PuppeteerNode_1.PuppeteerNode({
+    preferredRevision: revisions_1.PUPPETEER_REVISIONS.chromium,
+    productName: undefined,
+});

package/dist/browser/revisions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+declare type Revisions = Readonly<{
+    readonly chromium: string;
+    readonly firefox: string;
+}>;
+export declare const PUPPETEER_REVISIONS: Revisions;
+export {};

package/dist/browser/revisions.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUPPETEER_REVISIONS = void 0;
+exports.PUPPETEER_REVISIONS = {
+    chromium: '1002410',
+    firefox: 'latest',
+};

package/dist/browser/util.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/// <reference types="node" />
+import type { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+import { CommonEventEmitter } from './EventEmitter';
+export declare function getExceptionMessage(exceptionDetails: Protocol.Runtime.ExceptionDetails): string;
+export declare function valueFromRemoteObject(remoteObject: Protocol.Runtime.RemoteObject): any;
+export declare function releaseObject(client: CDPSession, remoteObject: Protocol.Runtime.RemoteObject): Promise<void>;
+export interface PuppeteerEventListener {
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}
+export declare function addEventListener(emitter: CommonEventEmitter, eventName: string | symbol, handler: (...args: any[]) => void): PuppeteerEventListener;
+export declare function removeEventListeners(listeners: Array<{
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}>): void;
+export declare const isString: (obj: unknown) => obj is string;
+export declare function evaluationString(fun: Function | string, ...args: unknown[]): string;
+export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
+export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
+export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number): Promise<T>;
+interface ErrorLike extends Error {
+    name: string;
+    message: string;
+}
+export declare function isErrorLike(obj: unknown): obj is ErrorLike;
+export declare function isErrnoException(obj: unknown): obj is NodeJS.ErrnoException;
+export {};

package/dist/browser/util.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErrnoException = exports.isErrorLike = exports.waitWithTimeout = exports.pageBindingDeliverErrorValueString = exports.pageBindingDeliverErrorString = exports.pageBindingDeliverResultString = exports.evaluationString = exports.isString = exports.removeEventListeners = exports.addEventListener = exports.releaseObject = exports.valueFromRemoteObject = exports.getExceptionMessage = void 0;
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+function getExceptionMessage(exceptionDetails) {
+    if (exceptionDetails.exception) {
+        return (exceptionDetails.exception.description || exceptionDetails.exception.value);
+    }
+    let message = exceptionDetails.text;
+    if (exceptionDetails.stackTrace) {
+        for (const callframe of exceptionDetails.stackTrace.callFrames) {
+            const location = callframe.url +
+                ':' +
+                callframe.lineNumber +
+                ':' +
+                callframe.columnNumber;
+            const functionName = callframe.functionName || '<anonymous>';
+            message += `\n    at ${functionName} (${location})`;
+        }
+    }
+    return message;
+}
+exports.getExceptionMessage = getExceptionMessage;
+function valueFromRemoteObject(remoteObject) {
+    (0, assert_1.assert)(!remoteObject.objectId, 'Cannot extract value when objectId is given');
+    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;
+}
+exports.valueFromRemoteObject = valueFromRemoteObject;
+async function releaseObject(client, remoteObject) {
+    if (!remoteObject.objectId) {
+        return;
+    }
+    await client
+        .send('Runtime.releaseObject', { objectId: remoteObject.objectId })
+        .catch(() => {
+        // Exceptions might happen in case of a page been navigated or closed.
+        // Swallow these since they are harmless and we don't leak anything in this case.
+    });
+}
+exports.releaseObject = releaseObject;
+function addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return { emitter, eventName, handler };
+}
+exports.addEventListener = addEventListener;
+function removeEventListeners(listeners) {
+    for (const listener of listeners) {
+        listener.emitter.removeListener(listener.eventName, listener.handler);
+    }
+    listeners.length = 0;
+}
+exports.removeEventListeners = removeEventListeners;
+const isString = (obj) => {
+    return typeof obj === 'string' || obj instanceof String;
+};
+exports.isString = isString;
+function evaluationString(fun, ...args) {
+    if ((0, exports.isString)(fun)) {
+        (0, assert_1.assert)(args.length === 0, 'Cannot evaluate a string with arguments');
+        return fun;
+    }
+    function serializeArgument(arg) {
+        if (Object.is(arg, undefined)) {
+            return 'undefined';
+        }
+        return JSON.stringify(arg);
+    }
+    return `(${fun})(${args.map(serializeArgument).join(',')})`;
+}
+exports.evaluationString = evaluationString;
+function pageBindingDeliverResultString(name, seq, result) {
+    function deliverResult(_name, _seq, _result) {
+        window[_name].callbacks.get(_seq).resolve(_result);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverResult, name, seq, result);
+}
+exports.pageBindingDeliverResultString = pageBindingDeliverResultString;
+function pageBindingDeliverErrorString(name, seq, message, stack) {
+    function deliverError(_name, _seq, _message, _stack) {
+        const error = new Error(_message);
+        error.stack = _stack;
+        window[_name].callbacks.get(_seq).reject(error);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverError, name, seq, message, stack);
+}
+exports.pageBindingDeliverErrorString = pageBindingDeliverErrorString;
+function pageBindingDeliverErrorValueString(name, seq, value) {
+    function deliverErrorValue(_name, _seq, _value) {
+        window[_name].callbacks.get(_seq).reject(_value);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverErrorValue, name, seq, value);
+}
+exports.pageBindingDeliverErrorValueString = pageBindingDeliverErrorValueString;
+async function waitWithTimeout(promise, taskName, timeout) {
+    let reject;
+    const timeoutError = new Errors_1.TimeoutError(`waiting for ${taskName} failed: timeout ${timeout}ms exceeded`);
+    const timeoutPromise = new Promise((_res, rej) => {
+        reject = rej;
+    });
+    let timeoutTimer = null;
+    if (timeout) {
+        timeoutTimer = setTimeout(() => {
+            return reject(timeoutError);
+        }, timeout);
+    }
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+        }
+    }
+}
+exports.waitWithTimeout = waitWithTimeout;
+function isErrorLike(obj) {
+    return (typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj);
+}
+exports.isErrorLike = isErrorLike;
+function isErrnoException(obj) {
+    return (isErrorLike(obj) &&
+        ('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj));
+}
+exports.isErrnoException = isErrnoException;

package/dist/ensure-presentation-timestamp.d.ts

@@ -0,0 +1 @@
+export declare const ensurePresentationTimestamps: (src: string) => Promise<unknown>;

package/dist/ensure-presentation-timestamp.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePresentationTimestamps = void 0;
+const execa_1 = __importDefault(require("execa"));
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const ensureFileHasPresentationTimestamp = {};
+let callbacks = [];
+const ensurePresentationTimestamps = async (src) => {
+    if (ensureFileHasPresentationTimestamp[src] === 'encoding') {
+        return new Promise((resolve) => {
+            callbacks.push({
+                src,
+                fn: () => resolve,
+            });
+        });
+    }
+    if (ensureFileHasPresentationTimestamp[src] === 'done') {
+        return;
+    }
+    ensureFileHasPresentationTimestamp[src] = 'encoding';
+    const parts = src.split(path_1.default.sep);
+    const output = parts
+        .map((p, i) => {
+        if (i === parts.length - 1) {
+            return `pts-${p}`;
+        }
+        return p;
+    })
+        .join(path_1.default.sep);
+    await (0, execa_1.default)('ffmpeg', [
+        '-i',
+        src,
+        '-fflags',
+        '+genpts+igndts',
+        '-vcodec',
+        'copy',
+        '-acodec',
+        'copy',
+        output,
+        '-y',
+    ]);
+    await (0, promises_1.unlink)(src);
+    await (0, promises_1.rename)(output, src);
+    callbacks = callbacks.filter((c) => {
+        if (c.src === src) {
+            c.fn();
+            return false;
+        }
+        return true;
+    });
+    ensureFileHasPresentationTimestamp[src] = 'done';
+};
+exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

package/dist/extract-frame-from-video.d.ts

@@ -1,16 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import { FfmpegExecutable } from 'remotion';
-import { Readable } from 'stream';
+import { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
+import { SpecialVCodecForTransparency } from './is-vp9-video';
 import { LastFrameOptions } from './last-frame-from-video-cache';
-export declare function streamToString(stream: Readable): Promise<string>;
+export declare const determineVcodecFfmepgFlags: (vcodecFlag: SpecialVCodecForTransparency) => string[];
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
 declare type Options = {
     time: number;
     src: string;
     ffmpegExecutable: FfmpegExecutable;
     ffprobeExecutable: FfmpegExecutable;
+    imageFormat: OffthreadVideoImageFormat;
 };
-export declare const extractFrameFromVideoFn: ({ time, src, ffmpegExecutable, ffprobeExecutable, }: Options) => Promise<Buffer>;
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

package/dist/extract-frame-from-video.js

@@ -3,41 +3,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFrameFromVideo = exports.extractFrameFromVideoFn = exports.getLastFrameOfVideo = exports.streamToString = void 0;
+exports.extractFrameFromVideo = exports.getLastFrameOfVideo = exports.determineVcodecFfmepgFlags = void 0;
 const execa_1 = __importDefault(require("execa"));
 const remotion_1 = require("remotion");
+const get_audio_channels_1 = require("./assets/get-audio-channels");
+const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
-const get_duration_of_asset_1 = require("./get-duration-of-asset");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
+const is_vp9_video_1 = require("./is-vp9-video");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
-function streamToString(stream) {
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-        stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-        stream.on('error', (err) => reject(err));
-        stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-    });
-}
-exports.streamToString = streamToString;
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
+const determineVcodecFfmepgFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(remotion_1.Internals.truthy);
+};
+exports.determineVcodecFfmepgFlags = determineVcodecFfmepgFlags;
 // Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
 // if the video is corrupted
-const getLastFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, }) => {
-    console.warn(`\nUsing a slow method to determine the last frame of ${src}. The render can be sped up by re-encoding the video properly.`);
-    const actualOffset = `-${duration * 1000}ms`;
+const getFrameOfVideoSlow = async ({ src, timestamp, ffmpegExecutable, imageFormat, specialVCodecForTransparency, }) => {
+    console.warn(`\nUsing a slow method to extract the frame at ${timestamp}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
+    const actualOffset = `-${timestamp * 1000}ms`;
     const command = [
         '-itsoffset',
         actualOffset,
+        ...(0, exports.determineVcodecFfmepgFlags)(specialVCodecForTransparency),
         '-i',
         src,
         '-frames:v',
         '1',
+        '-c:v',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         '-f',
         'image2pipe',
         '-',
-    ];
+    ].filter(remotion_1.Internals.truthy);
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
@@ -70,15 +75,17 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     if (fromCache) {
         return fromCache;
     }
-    const duration = await (0, get_duration_of_asset_1.getDurationOfAsset)({
-        src,
-        ffprobeExecutable,
-    });
-    if (offset > 40) {
-        const last = await getLastFrameOfVideoSlow({
-            duration,
+    const { duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(src, ffprobeExecutable);
+    if (duration === null) {
+        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
+    }
+    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
+        const last = await getFrameOfVideoSlow({
+            timestamp: duration,
             ffmpegExecutable,
             src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
         });
         return last;
     }
@@ -86,14 +93,17 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
         actualOffset,
+        ...(0, exports.determineVcodecFfmepgFlags)(options.specialVCodecForTransparency),
         '-i',
         src,
         '-frames:v',
         '1',
+        '-c:v',
+        options.imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         '-f',
         'image2pipe',
         '-',
-    ]);
+    ].filter(remotion_1.Internals.truthy));
     if (!stderr) {
         throw new Error('unexpectedly did not get stderr');
     }
@@ -126,6 +136,8 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
             offset: offset + 10,
             src,
             ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
         });
         return unlimited;
     }
@@ -137,13 +149,28 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, }) => {
+const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, imageFormat, }) => {
+    await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(src);
+    const specialVCodecForTransparency = imageFormat === 'jpeg'
+        ? 'none'
+        : await (0, is_vp9_video_1.getSpecialVCodecForTransparency)(src, ffprobeExecutable);
+    if (specialVCodecForTransparency === 'vp8') {
+        return getFrameOfVideoSlow({
+            ffmpegExecutable,
+            imageFormat,
+            specialVCodecForTransparency,
+            src,
+            timestamp: time,
+        });
+    }
     if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
         const lastFrame = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency,
         });
         return lastFrame;
     }
@@ -151,14 +178,17 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
     const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
         '-ss',
         ffmpegTimestamp,
+        ...(0, exports.determineVcodecFfmepgFlags)(specialVCodecForTransparency),
         '-i',
         src,
         '-frames:v',
         '1',
         '-f',
         'image2pipe',
+        '-vcodec',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
         '-',
-    ], {
+    ].filter(remotion_1.Internals.truthy), {
         buffer: false,
     });
     if (!stderr) {
@@ -190,15 +220,16 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency,
         });
         return last;
     }
     return stdOut;
 };
-exports.extractFrameFromVideoFn = extractFrameFromVideoFn;
 const extractFrameFromVideo = async (options) => {
     const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
-    const res = await mainLimit(exports.extractFrameFromVideoFn, options);
+    const res = await mainLimit(extractFrameFromVideoFn, options);
     remotion_1.Internals.perf.stopPerfMeasure(perf);
     return res;
 };

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import execa from 'execa';
+import mime from 'mime-types';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
 export type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 export { BrowserLog } from './browser-log';
@@ -73,4 +76,25 @@ export declare const RenderInternals: {
     SymbolicateableError: typeof SymbolicateableError;
     getDurationFromFrameRange: (frameRange: import("remotion").FrameRange | null, durationInFrames: number) => number;
     getExtensionOfFilename: (filename: string) => string | null;
+    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+    mime: typeof mime;
+    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>;
+    };
 };

package/dist/index.js

@@ -1,6 +1,11 @@
 "use strict";
+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;
+const execa_1 = __importDefault(require("execa"));
+const mime_types_1 = __importDefault(require("mime-types"));
 const download_file_1 = require("./assets/download-file");
 const delete_directory_1 = require("./delete-directory");
 const ensure_output_directory_1 = require("./ensure-output-directory");
@@ -13,10 +18,12 @@ const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const get_extension_of_filename_1 = require("./get-extension-of-filename");
 const get_frame_to_render_1 = require("./get-frame-to-render");
 const get_local_browser_executable_1 = require("./get-local-browser-executable");
+const get_port_1 = require("./get-port");
 const is_serve_url_1 = require("./is-serve-url");
 const normalize_serve_url_1 = require("./normalize-serve-url");
 const open_browser_1 = require("./open-browser");
 const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+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");
@@ -69,4 +76,8 @@ exports.RenderInternals = {
     SymbolicateableError: symbolicateable_error_1.SymbolicateableError,
     getDurationFromFrameRange: get_duration_from_frame_range_1.getDurationFromFrameRange,
     getExtensionOfFilename: get_extension_of_filename_1.getExtensionOfFilename,
+    getDesiredPort: get_port_1.getDesiredPort,
+    mime: mime_types_1.default,
+    isPathInside: is_path_inside_1.isPathInside,
+    execa: execa_1.default,
 };

package/dist/is-vp9-video.d.ts

@@ -0,0 +1,3 @@
+import { FfmpegExecutable } from 'remotion';
+export declare type SpecialVCodecForTransparency = 'vp9' | 'vp8' | 'none';
+export declare const getSpecialVCodecForTransparency: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<SpecialVCodecForTransparency>;