@remotion/media 4.0.402 → 4.0.404

package/dist/video/video-for-rendering.js

@@ -1,263 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useLayoutEffect, useMemo, useRef, useState, } from 'react';
-import { Internals, Loop, random, useCurrentFrame, useDelayRender, useRemotionEnvironment, useVideoConfig, } from 'remotion';
-import { useMaxMediaCacheSize } from '../caches';
-import { applyVolume } from '../convert-audiodata/apply-volume';
-import { TARGET_SAMPLE_RATE } from '../convert-audiodata/resample-audiodata';
-import { frameForVolumeProp } from '../looped-frame';
-import { extractFrameViaBroadcastChannel } from '../video-extraction/extract-frame-via-broadcast-channel';
-export const VideoForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, onVideoFrame, logLevel, loop, style, className, fallbackOffthreadVideoProps, audioStreamIndex, name, disallowFallbackToOffthreadVideo, stack, toneFrequency, trimAfterValue, trimBeforeValue, headless, }) => {
-    if (!src) {
-        throw new TypeError('No `src` was passed to <Video>.');
-    }
-    const frame = useCurrentFrame();
-    const absoluteFrame = Internals.useTimelinePosition();
-    const { fps } = useVideoConfig();
-    const { registerRenderAsset, unregisterRenderAsset } = useContext(Internals.RenderAssetManager);
-    const startsAt = Internals.useMediaStartsAt();
-    const sequenceContext = useContext(Internals.SequenceContext);
-    // Generate a string that's as unique as possible for this asset
-    // but at the same time the same on all threads
-    const id = useMemo(() => `media-video-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
-        src,
-        sequenceContext?.cumulatedFrom,
-        sequenceContext?.relativeFrom,
-        sequenceContext?.durationInFrames,
-    ]);
-    const environment = useRemotionEnvironment();
-    const { delayRender, continueRender, cancelRender } = useDelayRender();
-    const canvasRef = useRef(null);
-    const [replaceWithOffthreadVideo, setReplaceWithOffthreadVideo] = useState(false);
-    const audioEnabled = Internals.useAudioEnabled();
-    const videoEnabled = Internals.useVideoEnabled();
-    const maxCacheSize = useMaxMediaCacheSize(logLevel);
-    const [error, setError] = useState(null);
-    if (error) {
-        throw error;
-    }
-    useLayoutEffect(() => {
-        if (!canvasRef.current && !headless) {
-            return;
-        }
-        if (replaceWithOffthreadVideo) {
-            return;
-        }
-        if (!canvasRef.current?.getContext && !headless) {
-            return setError(new Error('Canvas does not have .getContext() method available. This could be because <Video> was mounted inside an <svg> tag.'));
-        }
-        const timestamp = frame / fps;
-        const durationInSeconds = 1 / fps;
-        const newHandle = delayRender(`Extracting frame at time ${timestamp}`, {
-            retries: delayRenderRetries ?? undefined,
-            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined,
-        });
-        const shouldRenderAudio = (() => {
-            if (!audioEnabled) {
-                return false;
-            }
-            if (muted) {
-                return false;
-            }
-            return true;
-        })();
-        extractFrameViaBroadcastChannel({
-            src,
-            timeInSeconds: timestamp,
-            durationInSeconds,
-            playbackRate,
-            logLevel,
-            includeAudio: shouldRenderAudio,
-            includeVideo: videoEnabled,
-            isClientSideRendering: environment.isClientSideRendering,
-            loop,
-            audioStreamIndex,
-            trimAfter: trimAfterValue,
-            trimBefore: trimBeforeValue,
-            fps,
-            maxCacheSize,
-        })
-            .then((result) => {
-            if (result.type === 'unknown-container-format') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render video "${src}": Unknown container format. See supported formats: https://www.remotion.dev/docs/mediabunny/formats`));
-                    return;
-                }
-                if (disallowFallbackToOffthreadVideo) {
-                    cancelRender(new Error(`Unknown container format ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
-                }
-                if (window.remotion_isMainTab) {
-                    Internals.Log.info({ logLevel, tag: '@remotion/media' }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <OffthreadVideo>`);
-                }
-                setReplaceWithOffthreadVideo({ durationInSeconds: null });
-                return;
-            }
-            if (result.type === 'cannot-decode') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render video "${src}": The video could not be decoded by the browser.`));
-                    return;
-                }
-                if (disallowFallbackToOffthreadVideo) {
-                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
-                }
-                if (window.remotion_isMainTab) {
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Cannot decode ${src}, falling back to <OffthreadVideo>`);
-                }
-                setReplaceWithOffthreadVideo({
-                    durationInSeconds: result.durationInSeconds,
-                });
-                return;
-            }
-            if (result.type === 'cannot-decode-alpha') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render video "${src}": The alpha channel could not be decoded by the browser.`));
-                    return;
-                }
-                if (disallowFallbackToOffthreadVideo) {
-                    cancelRender(new Error(`Cannot decode alpha component for ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
-                }
-                if (window.remotion_isMainTab) {
-                    Internals.Log.info({ logLevel, tag: '@remotion/media' }, `Cannot decode alpha component for ${src}, falling back to <OffthreadVideo>`);
-                }
-                setReplaceWithOffthreadVideo({
-                    durationInSeconds: result.durationInSeconds,
-                });
-                return;
-            }
-            if (result.type === 'network-error') {
-                if (environment.isClientSideRendering) {
-                    cancelRender(new Error(`Cannot render video "${src}": Network error while fetching the video (possibly CORS).`));
-                    return;
-                }
-                if (disallowFallbackToOffthreadVideo) {
-                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToOffthreadVideo' was set. Failing the render.`));
-                }
-                if (window.remotion_isMainTab) {
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Network error fetching ${src} (no CORS?), falling back to <OffthreadVideo>`);
-                }
-                setReplaceWithOffthreadVideo({ durationInSeconds: null });
-                return;
-            }
-            const { frame: imageBitmap, audio, durationInSeconds: assetDurationInSeconds, } = result;
-            if (imageBitmap) {
-                onVideoFrame?.(imageBitmap);
-                const context = canvasRef.current?.getContext('2d', {
-                    alpha: true,
-                });
-                // Could be in headless mode
-                if (context) {
-                    context.canvas.width = imageBitmap.width;
-                    context.canvas.height = imageBitmap.height;
-                    context.canvas.style.aspectRatio = `${context.canvas.width} / ${context.canvas.height}`;
-                    context.drawImage(imageBitmap, 0, 0);
-                }
-                imageBitmap.close();
-            }
-            else if (videoEnabled) {
-                // A video that only starts at time 0.033sec
-                // we shall not crash here but clear the canvas
-                const context = canvasRef.current?.getContext('2d', {
-                    alpha: true,
-                });
-                if (context) {
-                    context.clearRect(0, 0, context.canvas.width, context.canvas.height);
-                }
-            }
-            const volumePropsFrame = frameForVolumeProp({
-                behavior: loopVolumeCurveBehavior,
-                loop,
-                assetDurationInSeconds: assetDurationInSeconds ?? 0,
-                fps,
-                frame,
-                startsAt,
-            });
-            const volume = Internals.evaluateVolume({
-                volume: volumeProp,
-                frame: volumePropsFrame,
-                mediaVolume: 1,
-            });
-            Internals.warnAboutTooHighVolume(volume);
-            if (audio && volume > 0) {
-                applyVolume(audio.data, volume);
-                registerRenderAsset({
-                    type: 'inline-audio',
-                    id,
-                    audio: environment.isClientSideRendering
-                        ? audio.data
-                        : Array.from(audio.data),
-                    frame: absoluteFrame,
-                    timestamp: audio.timestamp,
-                    duration: (audio.numberOfFrames / TARGET_SAMPLE_RATE) * 1000000,
-                    toneFrequency,
-                });
-            }
-            continueRender(newHandle);
-        })
-            .catch((err) => {
-            cancelRender(err);
-        });
-        return () => {
-            continueRender(newHandle);
-            unregisterRenderAsset(id);
-        };
-    }, [
-        absoluteFrame,
-        continueRender,
-        delayRender,
-        delayRenderRetries,
-        delayRenderTimeoutInMilliseconds,
-        environment.isClientSideRendering,
-        fps,
-        frame,
-        id,
-        logLevel,
-        loop,
-        loopVolumeCurveBehavior,
-        muted,
-        onVideoFrame,
-        playbackRate,
-        registerRenderAsset,
-        src,
-        startsAt,
-        unregisterRenderAsset,
-        volumeProp,
-        replaceWithOffthreadVideo,
-        audioStreamIndex,
-        disallowFallbackToOffthreadVideo,
-        toneFrequency,
-        trimAfterValue,
-        trimBeforeValue,
-        audioEnabled,
-        videoEnabled,
-        maxCacheSize,
-        cancelRender,
-        headless,
-    ]);
-    const classNameValue = useMemo(() => {
-        return [Internals.OBJECTFIT_CONTAIN_CLASS_NAME, className]
-            .filter(Internals.truthy)
-            .join(' ');
-    }, [className]);
-    if (replaceWithOffthreadVideo) {
-        const fallback = (_jsx(Internals.InnerOffthreadVideo, { src: src, playbackRate: playbackRate ?? 1, muted: muted ?? false, acceptableTimeShiftInSeconds: fallbackOffthreadVideoProps?.acceptableTimeShiftInSeconds, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', delayRenderRetries: delayRenderRetries ?? undefined, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined, style: style, allowAmplificationDuringRender: true, transparent: fallbackOffthreadVideoProps?.transparent ?? true, toneMapped: fallbackOffthreadVideoProps?.toneMapped ?? true, audioStreamIndex: audioStreamIndex ?? 0, name: name, className: className, onVideoFrame: onVideoFrame, volume: volumeProp, id: id, onError: fallbackOffthreadVideoProps?.onError, toneFrequency: toneFrequency, 
-            // these shouldn't matter during rendering / should not appear at all
-            showInTimeline: false, crossOrigin: undefined, onAutoPlayError: () => undefined, pauseWhenBuffering: false, trimAfter: trimAfterValue, trimBefore: trimBeforeValue, useWebAudioApi: false, startFrom: undefined, endAt: undefined, stack: stack, _remotionInternalNativeLoopPassed: false }));
-        if (loop) {
-            if (!replaceWithOffthreadVideo.durationInSeconds) {
-                const err = new Error(`Cannot render video ${src}: @remotion/media was unable to render, and fell back to <OffthreadVideo>. Also, "loop" was set, but <OffthreadVideo> does not support looping and @remotion/media could also not determine the duration of the video.`);
-                cancelRender(err);
-                throw err;
-            }
-            return (_jsx(Loop, { layout: "none", durationInFrames: Internals.calculateMediaDuration({
-                    trimAfter: trimAfterValue,
-                    mediaDurationInFrames: replaceWithOffthreadVideo.durationInSeconds * fps,
-                    playbackRate,
-                    trimBefore: trimBeforeValue,
-                }), children: fallback }));
-        }
-        return fallback;
-    }
-    if (headless) {
-        return null;
-    }
-    return _jsx("canvas", { ref: canvasRef, style: style, className: classNameValue });
-};

package/dist/video/video-preview-iterator.js

@@ -1,122 +0,0 @@
-import { roundTo4Digits } from '../helpers/round-to-4-digits';
-export const createVideoIterator = (timeToSeek, cache) => {
-    let destroyed = false;
-    const iterator = cache.makeIteratorOrUsePrewarmed(timeToSeek);
-    let lastReturnedFrame = null;
-    let iteratorEnded = false;
-    const getNextOrNullIfNotAvailable = async () => {
-        const next = iterator.next();
-        const result = await Promise.race([
-            next,
-            new Promise((resolve) => {
-                Promise.resolve().then(() => resolve());
-            }),
-        ]);
-        if (!result) {
-            return {
-                type: 'need-to-wait-for-it',
-                waitPromise: async () => {
-                    const res = await next;
-                    if (res.value) {
-                        lastReturnedFrame = res.value;
-                    }
-                    else {
-                        iteratorEnded = true;
-                    }
-                    return res.value;
-                },
-            };
-        }
-        if (result.value) {
-            lastReturnedFrame = result.value;
-        }
-        else {
-            iteratorEnded = true;
-        }
-        return {
-            type: 'got-frame-or-end',
-            frame: result.value ?? null,
-        };
-    };
-    const destroy = () => {
-        destroyed = true;
-        lastReturnedFrame = null;
-        iterator.return().catch(() => undefined);
-    };
-    const tryToSatisfySeek = async (time) => {
-        if (lastReturnedFrame) {
-            const frameTimestamp = roundTo4Digits(lastReturnedFrame.timestamp);
-            if (roundTo4Digits(time) < frameTimestamp) {
-                return {
-                    type: 'not-satisfied',
-                    reason: `iterator is too far, most recently returned ${frameTimestamp}`,
-                };
-            }
-            const frameEndTimestamp = roundTo4Digits(lastReturnedFrame.timestamp + lastReturnedFrame.duration);
-            const timestamp = roundTo4Digits(time);
-            if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
-                return {
-                    type: 'satisfied',
-                    frame: lastReturnedFrame,
-                };
-            }
-        }
-        if (iteratorEnded) {
-            if (lastReturnedFrame) {
-                return {
-                    type: 'satisfied',
-                    frame: lastReturnedFrame,
-                };
-            }
-            return {
-                type: 'not-satisfied',
-                reason: 'iterator ended',
-            };
-        }
-        while (true) {
-            const frame = await getNextOrNullIfNotAvailable();
-            if (frame.type === 'need-to-wait-for-it') {
-                return {
-                    type: 'not-satisfied',
-                    reason: 'iterator did not have frame ready',
-                };
-            }
-            if (frame.type === 'got-frame-or-end') {
-                if (frame.frame === null) {
-                    iteratorEnded = true;
-                    if (lastReturnedFrame) {
-                        return {
-                            type: 'satisfied',
-                            frame: lastReturnedFrame,
-                        };
-                    }
-                    return {
-                        type: 'not-satisfied',
-                        reason: 'iterator ended and did not have frame ready',
-                    };
-                }
-                const frameTimestamp = roundTo4Digits(frame.frame.timestamp);
-                const frameEndTimestamp = roundTo4Digits(frame.frame.timestamp + frame.frame.duration);
-                const timestamp = roundTo4Digits(time);
-                if (frameTimestamp <= timestamp && frameEndTimestamp > timestamp) {
-                    return {
-                        type: 'satisfied',
-                        frame: frame.frame,
-                    };
-                }
-                continue;
-            }
-            throw new Error('Unreachable');
-        }
-    };
-    return {
-        destroy,
-        getNext: () => {
-            return iterator.next();
-        },
-        isDestroyed: () => {
-            return destroyed;
-        },
-        tryToSatisfySeek,
-    };
-};

package/dist/video/video.js

@@ -1,35 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Internals, useRemotionEnvironment } from 'remotion';
-import { VideoForPreview } from './video-for-preview';
-import { VideoForRendering } from './video-for-rendering';
-const { validateMediaTrimProps, resolveTrimProps, validateMediaProps } = Internals;
-const InnerVideo = ({ src, audioStreamIndex, className, delayRenderRetries, delayRenderTimeoutInMilliseconds, disallowFallbackToOffthreadVideo, fallbackOffthreadVideoProps, logLevel, loop, loopVolumeCurveBehavior, muted, name, onVideoFrame, playbackRate, style, trimAfter, trimBefore, volume, stack, toneFrequency, showInTimeline, debugOverlay, headless, }) => {
-    const environment = useRemotionEnvironment();
-    if (typeof src !== 'string') {
-        throw new TypeError(`The \`<Video>\` tag requires a string for \`src\`, but got ${JSON.stringify(src)} instead.`);
-    }
-    validateMediaTrimProps({
-        startFrom: undefined,
-        endAt: undefined,
-        trimBefore,
-        trimAfter,
-    });
-    const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
-        startFrom: undefined,
-        endAt: undefined,
-        trimBefore,
-        trimAfter,
-    });
-    validateMediaProps({ playbackRate, volume }, 'Video');
-    if (environment.isRendering) {
-        return (_jsx(VideoForRendering, { audioStreamIndex: audioStreamIndex ?? 0, className: className, delayRenderRetries: delayRenderRetries ?? null, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? null, disallowFallbackToOffthreadVideo: disallowFallbackToOffthreadVideo ?? false, name: name, fallbackOffthreadVideoProps: fallbackOffthreadVideoProps, logLevel: logLevel, loop: loop, loopVolumeCurveBehavior: loopVolumeCurveBehavior, muted: muted, onVideoFrame: onVideoFrame, playbackRate: playbackRate, src: src, stack: stack, style: style, volume: volume, toneFrequency: toneFrequency, trimAfterValue: trimAfterValue, trimBeforeValue: trimBeforeValue, headless: headless }));
-    }
-    return (_jsx(VideoForPreview, { audioStreamIndex: audioStreamIndex ?? 0, className: className, name: name, logLevel: logLevel, loop: loop, loopVolumeCurveBehavior: loopVolumeCurveBehavior, muted: muted, onVideoFrame: onVideoFrame, playbackRate: playbackRate, src: src, style: style, volume: volume, showInTimeline: showInTimeline, trimAfter: trimAfterValue, trimBefore: trimBeforeValue, stack: stack ?? null, disallowFallbackToOffthreadVideo: disallowFallbackToOffthreadVideo, fallbackOffthreadVideoProps: fallbackOffthreadVideoProps, debugOverlay: debugOverlay ?? false, headless: headless ?? false }));
-};
-export const Video = ({ src, audioStreamIndex, className, delayRenderRetries, delayRenderTimeoutInMilliseconds, disallowFallbackToOffthreadVideo, fallbackOffthreadVideoProps, logLevel, loop, loopVolumeCurveBehavior, muted, name, onVideoFrame, playbackRate, showInTimeline, style, trimAfter, trimBefore, volume, stack, toneFrequency, debugOverlay, headless, }) => {
-    return (_jsx(InnerVideo, { audioStreamIndex: audioStreamIndex ?? 0, className: className, delayRenderRetries: delayRenderRetries ?? null, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? null, disallowFallbackToOffthreadVideo: disallowFallbackToOffthreadVideo ?? false, fallbackOffthreadVideoProps: fallbackOffthreadVideoProps ?? {}, logLevel: logLevel ??
-            (typeof window !== 'undefined'
-                ? (window.remotion_logLevel ?? 'info')
-                : 'info'), loop: loop ?? false, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', muted: muted ?? false, name: name, onVideoFrame: onVideoFrame, playbackRate: playbackRate ?? 1, showInTimeline: showInTimeline ?? true, src: src, style: style ?? {}, trimAfter: trimAfter, trimBefore: trimBefore, volume: volume ?? 1, toneFrequency: toneFrequency ?? 1, stack: stack, debugOverlay: debugOverlay ?? false, headless: headless ?? false }));
-};
-Internals.addSequenceStackTraces(Video);

package/dist/video-extraction/add-broadcast-channel-listener.js

@@ -1,125 +0,0 @@
-import { extractFrameAndAudio } from '../extract-frame-and-audio';
-// Send to other channels a message to let them know that the
-// tab was loaded and is ready to receive requests.
-// Emit "readiness" messages for approximately 10 seconds.
-const emitReadiness = (channel) => {
-    channel.postMessage({
-        type: 'main-tab-ready',
-    });
-    let times = 0;
-    const interval = setInterval(() => {
-        channel.postMessage({
-            type: 'main-tab-ready',
-        });
-        times++;
-        if (times > 30) {
-            clearInterval(interval);
-        }
-    }, 300);
-};
-export const addBroadcastChannelListener = () => {
-    // Doesn't exist in studio
-    if (!(typeof window !== 'undefined' &&
-        window.remotion_broadcastChannel &&
-        window.remotion_isMainTab)) {
-        return;
-    }
-    window.remotion_broadcastChannel.addEventListener('message', async (event) => {
-        const data = event.data;
-        if (data.type === 'request') {
-            try {
-                const result = await extractFrameAndAudio({
-                    src: data.src,
-                    timeInSeconds: data.timeInSeconds,
-                    logLevel: data.logLevel,
-                    durationInSeconds: data.durationInSeconds,
-                    playbackRate: data.playbackRate,
-                    includeAudio: data.includeAudio,
-                    includeVideo: data.includeVideo,
-                    loop: data.loop,
-                    audioStreamIndex: data.audioStreamIndex,
-                    trimAfter: data.trimAfter,
-                    trimBefore: data.trimBefore,
-                    fps: data.fps,
-                    maxCacheSize: data.maxCacheSize,
-                });
-                if (result.type === 'cannot-decode') {
-                    const cannotDecodeResponse = {
-                        type: 'response-cannot-decode',
-                        id: data.id,
-                        durationInSeconds: result.durationInSeconds,
-                    };
-                    window.remotion_broadcastChannel.postMessage(cannotDecodeResponse);
-                    return;
-                }
-                if (result.type === 'cannot-decode-alpha') {
-                    const cannotDecodeAlphaResponse = {
-                        type: 'response-cannot-decode-alpha',
-                        id: data.id,
-                        durationInSeconds: result.durationInSeconds,
-                    };
-                    window.remotion_broadcastChannel.postMessage(cannotDecodeAlphaResponse);
-                    return;
-                }
-                if (result.type === 'network-error') {
-                    const networkErrorResponse = {
-                        type: 'response-network-error',
-                        id: data.id,
-                    };
-                    window.remotion_broadcastChannel.postMessage(networkErrorResponse);
-                    return;
-                }
-                if (result.type === 'unknown-container-format') {
-                    const unknownContainerFormatResponse = {
-                        type: 'response-unknown-container-format',
-                        id: data.id,
-                    };
-                    window.remotion_broadcastChannel.postMessage(unknownContainerFormatResponse);
-                    return;
-                }
-                const { frame, audio, durationInSeconds } = result;
-                const imageBitmap = frame ? await createImageBitmap(frame) : null;
-                if (frame) {
-                    frame.close();
-                }
-                const response = {
-                    type: 'response-success',
-                    id: data.id,
-                    frame: imageBitmap,
-                    audio,
-                    durationInSeconds: durationInSeconds ?? null,
-                };
-                window.remotion_broadcastChannel.postMessage(response);
-            }
-            catch (error) {
-                const response = {
-                    type: 'response-error',
-                    id: data.id,
-                    errorStack: error.stack ?? 'No stack trace',
-                };
-                window.remotion_broadcastChannel.postMessage(response);
-            }
-        }
-        else {
-            throw new Error('Invalid message: ' + JSON.stringify(data));
-        }
-    });
-    emitReadiness(window.remotion_broadcastChannel);
-};
-let mainTabIsReadyProm = null;
-export const waitForMainTabToBeReady = (channel) => {
-    if (mainTabIsReadyProm) {
-        return mainTabIsReadyProm;
-    }
-    mainTabIsReadyProm = new Promise((resolve) => {
-        const onMessage = (event) => {
-            const data = event.data;
-            if (data.type === 'main-tab-ready') {
-                resolve();
-                channel.removeEventListener('message', onMessage);
-            }
-        };
-        channel.addEventListener('message', onMessage);
-    });
-    return mainTabIsReadyProm;
-};

package/dist/video-extraction/extract-frame-via-broadcast-channel.js

@@ -1,113 +0,0 @@
-import { extractFrameAndAudio } from '../extract-frame-and-audio';
-import { addBroadcastChannelListener, waitForMainTabToBeReady, } from './add-broadcast-channel-listener';
-addBroadcastChannelListener();
-export const extractFrameViaBroadcastChannel = async ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, isClientSideRendering, loop, audioStreamIndex, trimAfter, trimBefore, fps, maxCacheSize, }) => {
-    if (isClientSideRendering || window.remotion_isMainTab) {
-        return extractFrameAndAudio({
-            logLevel,
-            src,
-            timeInSeconds,
-            durationInSeconds,
-            playbackRate,
-            includeAudio,
-            includeVideo,
-            loop,
-            audioStreamIndex,
-            trimAfter,
-            trimBefore,
-            fps,
-            maxCacheSize,
-        });
-    }
-    await waitForMainTabToBeReady(window.remotion_broadcastChannel);
-    const requestId = crypto.randomUUID();
-    const resolvePromise = new Promise((resolve, reject) => {
-        const onMessage = (event) => {
-            const data = event.data;
-            if (!data) {
-                return;
-            }
-            if (data.type === 'main-tab-ready') {
-                return;
-            }
-            if (data.id !== requestId) {
-                return;
-            }
-            if (data.type === 'response-success') {
-                resolve({
-                    type: 'success',
-                    frame: data.frame ? data.frame : null,
-                    audio: data.audio ? data.audio : null,
-                    durationInSeconds: data.durationInSeconds
-                        ? data.durationInSeconds
-                        : null,
-                });
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            if (data.type === 'response-error') {
-                reject(data.errorStack);
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            if (data.type === 'response-cannot-decode') {
-                resolve({
-                    type: 'cannot-decode',
-                    durationInSeconds: data.durationInSeconds,
-                });
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            if (data.type === 'response-network-error') {
-                resolve({ type: 'network-error' });
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            if (data.type === 'response-unknown-container-format') {
-                resolve({ type: 'unknown-container-format' });
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            if (data.type === 'response-cannot-decode-alpha') {
-                resolve({
-                    type: 'cannot-decode-alpha',
-                    durationInSeconds: data.durationInSeconds,
-                });
-                window.remotion_broadcastChannel.removeEventListener('message', onMessage);
-                return;
-            }
-            throw new Error(`Invalid message: ${JSON.stringify(data)}`);
-        };
-        window.remotion_broadcastChannel.addEventListener('message', onMessage);
-    });
-    const request = {
-        type: 'request',
-        src,
-        timeInSeconds,
-        id: requestId,
-        logLevel,
-        durationInSeconds,
-        playbackRate,
-        includeAudio,
-        includeVideo,
-        loop,
-        audioStreamIndex,
-        trimAfter,
-        trimBefore,
-        fps,
-        maxCacheSize,
-    };
-    window.remotion_broadcastChannel.postMessage(request);
-    let timeoutId;
-    return Promise.race([
-        resolvePromise.then((res) => {
-            clearTimeout(timeoutId);
-            return res;
-        }),
-        new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-                reject(new Error(`Timeout while extracting frame at time ${timeInSeconds}sec from ${src}`));
-            }, Math.max(3000, window.remotion_puppeteerTimeout - 5000));
-        }),
-    ]);
-};