@remotion/renderer 3.0.20 → 3.0.23

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 { 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/browser-log.d.ts

@@ -1,4 +1,4 @@
-import { ConsoleMessageLocation, ConsoleMessageType } from 'puppeteer-core';
+import type { ConsoleMessageLocation, ConsoleMessageType } from 'puppeteer-core';
 export declare type BrowserLog = {
     text: string;
     stackTrace: ConsoleMessageLocation[];

package/dist/calculate-ffmpeg-filters.d.ts

@@ -1,4 +1,4 @@
-import { MediaAsset } from './assets/types';
+import type { MediaAsset } from './assets/types';
 export declare const calculateFfmpegFilter: ({ asset, fps, durationInFrames, channels, assetDuration, }: {
     asset: MediaAsset;
     fps: number;

package/dist/can-use-parallel-encoding.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const canUseParallelEncoding: (codec: Codec) => boolean;

package/dist/combine-videos.d.ts

@@ -1,4 +1,4 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const combineVideos: ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, }: {
     files: string[];
     filelistDir: string;

package/dist/convert-to-pcm.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from 'remotion';
 export declare const convertToPcm: ({ ffmpegExecutable, input, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     input: string;

package/dist/create-silent-audio.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from 'remotion';
 export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;

package/dist/cycle-browser-tabs.d.ts

@@ -1,4 +1,4 @@
-import { openBrowser } from './open-browser';
+import type { openBrowser } from './open-browser';
 declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
 declare type Browser = Await<ReturnType<typeof openBrowser>>;
 export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {

package/dist/delay-render-embedded-stack.d.ts

@@ -1,2 +1,2 @@
-import { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
 export declare const parseDelayRenderEmbeddedStack: (message: string) => UnsymbolicatedStackFrame[] | null;

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

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

package/dist/ensure-presentation-timestamp.js

@@ -14,7 +14,7 @@ const ensurePresentationTimestamps = async (src) => {
         return new Promise((resolve) => {
             callbacks.push({
                 src,
-                fn: () => resolve,
+                fn: () => resolve(),
             });
         });
     }

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer-core';
-import { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
+import type { Page } from 'puppeteer-core';
+import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
 export declare class ErrorWithStackFrame extends Error {
     symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
     frame: number | null;

package/dist/error-handling/symbolicate-error.d.ts

@@ -1,3 +1,3 @@
 import { ErrorWithStackFrame } from './handle-javascript-exception';
-import { SymbolicateableError } from './symbolicateable-error';
+import type { SymbolicateableError } from './symbolicateable-error';
 export declare const symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<ErrorWithStackFrame>;

package/dist/error-handling/symbolicateable-error.d.ts

@@ -1,7 +1,7 @@
 /**
  * A symbolicateable error is an error that can be symolicated by fetching the original sources. By throwing a symbolicateable error, Remotion CLI will attempt to symplicate it
  */
-import { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
 export declare class SymbolicateableError extends Error {
     stackFrame: UnsymbolicatedStackFrame[] | null;
     delayRenderCall: UnsymbolicatedStackFrame[] | null;

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

@@ -1,15 +1,14 @@
-/// <reference types="node" />
-import { FfmpegExecutable } from 'remotion';
-import { Readable } from 'stream';
-import { LastFrameOptions } from './last-frame-from-video-cache';
-export declare function streamToString(stream: Readable): Promise<string>;
+import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
+import type { SpecialVCodecForTransparency } from './is-vp9-video';
+import type { LastFrameOptions } from './last-frame-from-video-cache';
+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,42 +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 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');
@@ -75,11 +79,13 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
     if (duration === null) {
         throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
     }
-    if (offset > 40) {
-        const last = await getLastFrameOfVideoSlow({
-            duration,
+    if (options.specialVCodecForTransparency === 'vp8' || offset > 40) {
+        const last = await getFrameOfVideoSlow({
+            timestamp: duration,
             ffmpegExecutable,
             src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
         });
         return last;
     }
@@ -87,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');
     }
@@ -127,6 +136,8 @@ const getLastFrameOfVideoFastUnlimited = async (options) => {
             offset: offset + 10,
             src,
             ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
         });
         return unlimited;
     }
@@ -138,14 +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;
     }
@@ -153,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) {
@@ -192,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/get-audio-codec-name.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const getAudioCodecName: (codec: Codec) => string | null;

package/dist/get-browser-instance.d.ts

@@ -1,6 +1,6 @@
-import { Browser, Page } from 'puppeteer-core';
-import { BrowserExecutable } from 'remotion';
-import { ChromiumOptions } from './open-browser';
+import type { Browser, Page } from 'puppeteer-core';
+import type { BrowserExecutable } from 'remotion';
+import type { ChromiumOptions } from './open-browser';
 export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, }: {
     passedInInstance: Browser | undefined;
     browserExecutable: BrowserExecutable | null;

package/dist/get-codec-name.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const getCodecName: (codec: Codec) => string | null;

package/dist/get-compositions.d.ts

@@ -1,7 +1,7 @@
-import { Browser } from 'puppeteer-core';
-import { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
-import { BrowserLog } from './browser-log';
-import { ChromiumOptions } from './open-browser';
+import type { Browser } from 'puppeteer-core';
+import type { BrowserExecutable, FfmpegExecutable, TCompMetadata } from 'remotion';
+import type { BrowserLog } from './browser-log';
+import type { ChromiumOptions } from './open-browser';
 declare type GetCompositionsConfig = {
     inputProps?: object | null;
     envVariables?: Record<string, string>;

package/dist/get-duration-from-frame-range.d.ts

@@ -1,2 +1,2 @@
-import { FrameRange } from 'remotion';
+import type { FrameRange } from 'remotion';
 export declare const getDurationFromFrameRange: (frameRange: FrameRange | null, durationInFrames: number) => number;

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "mp4" | "mkv" | "mov" | "webm";

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

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

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

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

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

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

package/dist/image-format.d.ts

@@ -1,2 +1,2 @@
-import { ImageFormat } from 'remotion';
+import type { ImageFormat } from 'remotion';
 export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;

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

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

package/dist/is-vp9-video.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecialVCodecForTransparency = void 0;
+const execa_1 = __importDefault(require("execa"));
+const p_limit_1 = require("./p-limit");
+const isVp9VideoCache = {};
+const limit = (0, p_limit_1.pLimit)(1);
+async function getSpecialVCodecForTransparencyUnlimited(src, ffprobeExecutable) {
+    if (typeof isVp9VideoCache[src] !== 'undefined') {
+        return 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');
+    isVp9VideoCache[src] = isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none';
+    return isVp9VideoCache[src];
+}
+const getSpecialVCodecForTransparency = (src, ffprobeExecutable) => {
+    return limit(() => getSpecialVCodecForTransparencyUnlimited(src, ffprobeExecutable));
+};
+exports.getSpecialVCodecForTransparency = getSpecialVCodecForTransparency;