remotion 4.0.199 → 4.0.201

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/VideoForPreview.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { RemotionVideoProps } from './props.js';
+type VideoForPreviewProps = RemotionVideoProps & {
+    onlyWarnForMediaSeekingError: boolean;
+    onDuration: (src: string, durationInSeconds: number) => void;
+    pauseWhenBuffering: boolean;
+    _remotionInternalNativeLoopPassed: boolean;
+    _remotionInternalStack: string | null;
+    showInTimeline: boolean;
+};
+export declare const VideoForPreview: React.ForwardRefExoticComponent<Omit<VideoForPreviewProps, "ref"> & React.RefAttributes<HTMLVideoElement>>;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/VideoForPreview.js

@@ -0,0 +1,148 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState, } from 'react';
+import { useFrameForVolumeProp } from '../audio/use-audio-frame.js';
+import { usePreload } from '../prefetch.js';
+import { SequenceContext } from '../SequenceContext.js';
+import { SequenceVisibilityToggleContext } from '../SequenceManager.js';
+import { useMediaBuffering } from '../use-media-buffering.js';
+import { useMediaInTimeline } from '../use-media-in-timeline.js';
+import { DEFAULT_ACCEPTABLE_TIMESHIFT, useMediaPlayback, } from '../use-media-playback.js';
+import { useMediaTagVolume } from '../use-media-tag-volume.js';
+import { useSyncVolumeWithMediaTag } from '../use-sync-volume-with-media-tag.js';
+import { useVideoConfig } from '../use-video-config.js';
+import { useMediaMutedState, useMediaVolumeState, } from '../volume-position-state.js';
+import { isIosSafari, useAppendVideoFragment } from './video-fragment.js';
+const VideoForDevelopmentRefForwardingFunction = (props, ref) => {
+    var _a, _b, _c;
+    const videoRef = useRef(null);
+    const volumePropFrame = useFrameForVolumeProp();
+    const { fps, durationInFrames } = useVideoConfig();
+    const parentSequence = useContext(SequenceContext);
+    const { hidden } = useContext(SequenceVisibilityToggleContext);
+    const [timelineId] = useState(() => String(Math.random()));
+    const isSequenceHidden = (_a = hidden[timelineId]) !== null && _a !== void 0 ? _a : false;
+    const { volume, muted, playbackRate, onlyWarnForMediaSeekingError, src, onDuration, 
+    // @ts-expect-error
+    acceptableTimeShift, acceptableTimeShiftInSeconds, toneFrequency, name, _remotionInternalNativeLoopPassed, _remotionInternalStack, style, pauseWhenBuffering, showInTimeline, ...nativeProps } = props;
+    if (typeof acceptableTimeShift !== 'undefined') {
+        throw new Error('acceptableTimeShift has been removed. Use acceptableTimeShiftInSeconds instead.');
+    }
+    const actualVolume = useMediaTagVolume(videoRef);
+    const [mediaVolume] = useMediaVolumeState();
+    const [mediaMuted] = useMediaMutedState();
+    useMediaInTimeline({
+        mediaRef: videoRef,
+        volume,
+        mediaVolume,
+        mediaType: 'video',
+        src,
+        playbackRate: (_b = props.playbackRate) !== null && _b !== void 0 ? _b : 1,
+        displayName: name !== null && name !== void 0 ? name : null,
+        id: timelineId,
+        stack: _remotionInternalStack,
+        showInTimeline,
+    });
+    useSyncVolumeWithMediaTag({
+        volumePropFrame,
+        actualVolume,
+        volume,
+        mediaVolume,
+        mediaRef: videoRef,
+    });
+    useMediaPlayback({
+        mediaRef: videoRef,
+        src,
+        mediaType: 'video',
+        playbackRate: (_c = props.playbackRate) !== null && _c !== void 0 ? _c : 1,
+        onlyWarnForMediaSeekingError,
+        acceptableTimeshift: acceptableTimeShiftInSeconds !== null && acceptableTimeShiftInSeconds !== void 0 ? acceptableTimeShiftInSeconds : DEFAULT_ACCEPTABLE_TIMESHIFT,
+    });
+    useMediaBuffering(videoRef, pauseWhenBuffering);
+    const actualFrom = parentSequence
+        ? parentSequence.relativeFrom + parentSequence.cumulatedFrom
+        : 0;
+    const duration = parentSequence
+        ? Math.min(parentSequence.durationInFrames, durationInFrames)
+        : durationInFrames;
+    const actualSrc = useAppendVideoFragment({
+        actualSrc: usePreload(src),
+        actualFrom,
+        duration,
+        fps,
+    });
+    useImperativeHandle(ref, () => {
+        return videoRef.current;
+    }, []);
+    useEffect(() => {
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        const errorHandler = () => {
+            var _a;
+            if (current === null || current === void 0 ? void 0 : current.error) {
+                // eslint-disable-next-line no-console
+                console.error('Error occurred in video', current === null || current === void 0 ? void 0 : current.error);
+                // If user is handling the error, we don't cause an unhandled exception
+                if (props.onError) {
+                    return;
+                }
+                throw new Error(`The browser threw an error while playing the video ${src}: Code ${current.error.code} - ${(_a = current === null || current === void 0 ? void 0 : current.error) === null || _a === void 0 ? void 0 : _a.message}. See https://remotion.dev/docs/media-playback-error for help. Pass an onError() prop to handle the error.`);
+            }
+            else {
+                throw new Error('The browser threw an error');
+            }
+        };
+        current.addEventListener('error', errorHandler, { once: true });
+        return () => {
+            current.removeEventListener('error', errorHandler);
+        };
+    }, [props.onError, src]);
+    const currentOnDurationCallback = useRef();
+    currentOnDurationCallback.current = onDuration;
+    useEffect(() => {
+        var _a;
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        if (current.duration) {
+            (_a = currentOnDurationCallback.current) === null || _a === void 0 ? void 0 : _a.call(currentOnDurationCallback, src, current.duration);
+            return;
+        }
+        const onLoadedMetadata = () => {
+            var _a;
+            (_a = currentOnDurationCallback.current) === null || _a === void 0 ? void 0 : _a.call(currentOnDurationCallback, src, current.duration);
+        };
+        current.addEventListener('loadedmetadata', onLoadedMetadata);
+        return () => {
+            current.removeEventListener('loadedmetadata', onLoadedMetadata);
+        };
+    }, [src]);
+    useEffect(() => {
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        // Without this, on iOS Safari, the video cannot be seeked.
+        // if a seek is triggered before `loadedmetadata` is fired,
+        // the video will not seek, even if `loadedmetadata` is fired afterwards.
+        // Also, this needs to happen in a useEffect, because otherwise
+        // the SSR props will be applied.
+        if (isIosSafari()) {
+            current.preload = 'metadata';
+        }
+        else {
+            current.preload = 'auto';
+        }
+    }, []);
+    const actualStyle = useMemo(() => {
+        var _a;
+        return {
+            ...style,
+            opacity: isSequenceHidden ? 0 : (_a = style === null || style === void 0 ? void 0 : style.opacity) !== null && _a !== void 0 ? _a : 1,
+        };
+    }, [isSequenceHidden, style]);
+    return (_jsx("video", { ref: videoRef, muted: muted || mediaMuted, playsInline: true, src: actualSrc, loop: _remotionInternalNativeLoopPassed, style: actualStyle, ...nativeProps }));
+};
+export const VideoForPreview = forwardRef(VideoForDevelopmentRefForwardingFunction);

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/VideoForRendering.d.ts

@@ -0,0 +1,14 @@
+import type { ForwardRefExoticComponent, RefAttributes } from 'react';
+import React from 'react';
+export declare const VideoForRendering: ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "nonce" | "onEnded" | "autoPlay" | "controls"> & {
+    name?: string | undefined;
+    volume?: import("../volume-prop.js").VolumeProp | undefined;
+    playbackRate?: number | undefined;
+    acceptableTimeShiftInSeconds?: number | undefined;
+    allowAmplificationDuringRender?: boolean | undefined;
+    toneFrequency?: number | undefined;
+    pauseWhenBuffering?: boolean | undefined;
+    showInTimeline?: boolean | undefined;
+} & {
+    onDuration: (src: string, durationInSeconds: number) => void;
+} & RefAttributes<HTMLVideoElement>>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/VideoForRendering.js

@@ -0,0 +1,192 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, } from 'react';
+import { getAbsoluteSrc } from '../absolute-src.js';
+import { useFrameForVolumeProp, useMediaStartsAt, } from '../audio/use-audio-frame.js';
+import { continueRender, delayRender } from '../delay-render.js';
+import { getRemotionEnvironment } from '../get-remotion-environment.js';
+import { isApproximatelyTheSame } from '../is-approximately-the-same.js';
+import { random } from '../random.js';
+import { RenderAssetManager } from '../RenderAssetManager.js';
+import { SequenceContext } from '../SequenceContext.js';
+import { useTimelinePosition } from '../timeline-position-state.js';
+import { useCurrentFrame } from '../use-current-frame.js';
+import { useUnsafeVideoConfig } from '../use-unsafe-video-config.js';
+import { evaluateVolume } from '../volume-prop.js';
+import { getMediaTime } from './get-current-time.js';
+import { seekToTimeMultipleUntilRight } from './seek-until-right.js';
+const VideoForRenderingForwardFunction = ({ onError, volume: volumeProp, allowAmplificationDuringRender, playbackRate, onDuration, toneFrequency, name, acceptableTimeShiftInSeconds, ...props }, ref) => {
+    const absoluteFrame = useTimelinePosition();
+    const frame = useCurrentFrame();
+    const volumePropsFrame = useFrameForVolumeProp();
+    const videoConfig = useUnsafeVideoConfig();
+    const videoRef = useRef(null);
+    const sequenceContext = useContext(SequenceContext);
+    const mediaStartsAt = useMediaStartsAt();
+    const environment = getRemotionEnvironment();
+    const { registerRenderAsset, unregisterRenderAsset } = useContext(RenderAssetManager);
+    // 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(() => {
+        var _a;
+        return `video-${random((_a = props.src) !== null && _a !== void 0 ? _a : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}`;
+    }, [
+        props.src,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames,
+    ]);
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    const volume = evaluateVolume({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+        allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+    });
+    useEffect(() => {
+        if (!props.src) {
+            throw new Error('No src passed');
+        }
+        if (props.muted) {
+            return;
+        }
+        if (volume <= 0) {
+            return;
+        }
+        if (!window.remotion_audioEnabled) {
+            return;
+        }
+        registerRenderAsset({
+            type: 'video',
+            src: getAbsoluteSrc(props.src),
+            id,
+            frame: absoluteFrame,
+            volume,
+            mediaFrame: frame,
+            playbackRate: playbackRate !== null && playbackRate !== void 0 ? playbackRate : 1,
+            allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+            toneFrequency: toneFrequency !== null && toneFrequency !== void 0 ? toneFrequency : null,
+        });
+        return () => unregisterRenderAsset(id);
+    }, [
+        props.muted,
+        props.src,
+        registerRenderAsset,
+        id,
+        unregisterRenderAsset,
+        volume,
+        frame,
+        absoluteFrame,
+        playbackRate,
+        allowAmplificationDuringRender,
+        toneFrequency,
+    ]);
+    useImperativeHandle(ref, () => {
+        return videoRef.current;
+    }, []);
+    useEffect(() => {
+        if (!window.remotion_videoEnabled) {
+            return;
+        }
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        const currentTime = getMediaTime({
+            frame,
+            playbackRate: playbackRate || 1,
+            startFrom: -mediaStartsAt,
+            fps: videoConfig.fps,
+        });
+        const handle = delayRender(`Rendering <Video /> with src="${props.src}"`);
+        if (process.env.NODE_ENV === 'test') {
+            continueRender(handle);
+            return;
+        }
+        if (isApproximatelyTheSame(current.currentTime, currentTime)) {
+            if (current.readyState >= 2) {
+                continueRender(handle);
+                return;
+            }
+            const loadedDataHandler = () => {
+                continueRender(handle);
+            };
+            current.addEventListener('loadeddata', loadedDataHandler, { once: true });
+            return () => {
+                current.removeEventListener('loadeddata', loadedDataHandler);
+            };
+        }
+        const endedHandler = () => {
+            continueRender(handle);
+        };
+        const seek = seekToTimeMultipleUntilRight(current, currentTime, videoConfig.fps);
+        seek.prom.then(() => {
+            continueRender(handle);
+        });
+        current.addEventListener('ended', endedHandler, { once: true });
+        const errorHandler = () => {
+            var _a;
+            if (current === null || current === void 0 ? void 0 : current.error) {
+                // eslint-disable-next-line no-console
+                console.error('Error occurred in video', current === null || current === void 0 ? void 0 : current.error);
+                // If user is handling the error, we don't cause an unhandled exception
+                if (onError) {
+                    return;
+                }
+                throw new Error(`The browser threw an error while playing the video ${props.src}: Code ${current.error.code} - ${(_a = current === null || current === void 0 ? void 0 : current.error) === null || _a === void 0 ? void 0 : _a.message}. See https://remotion.dev/docs/media-playback-error for help. Pass an onError() prop to handle the error.`);
+            }
+            else {
+                throw new Error('The browser threw an error');
+            }
+        };
+        current.addEventListener('error', errorHandler, { once: true });
+        // If video skips to another frame or unmounts, we clear the created handle
+        return () => {
+            seek.cancel();
+            current.removeEventListener('ended', endedHandler);
+            current.removeEventListener('error', errorHandler);
+            continueRender(handle);
+        };
+    }, [
+        volumePropsFrame,
+        props.src,
+        playbackRate,
+        videoConfig.fps,
+        frame,
+        mediaStartsAt,
+        onError,
+    ]);
+    const { src } = props;
+    // If video source switches, make new handle
+    if (environment.isRendering) {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useLayoutEffect(() => {
+            if (process.env.NODE_ENV === 'test') {
+                return;
+            }
+            const newHandle = delayRender('Loading <Video> duration with src=' + src);
+            const { current } = videoRef;
+            const didLoad = () => {
+                if (current === null || current === void 0 ? void 0 : current.duration) {
+                    onDuration(src, current.duration);
+                }
+                continueRender(newHandle);
+            };
+            if (current === null || current === void 0 ? void 0 : current.duration) {
+                onDuration(src, current.duration);
+                continueRender(newHandle);
+            }
+            else {
+                current === null || current === void 0 ? void 0 : current.addEventListener('loadedmetadata', didLoad, { once: true });
+            }
+            // If tag gets unmounted, clear pending handles because video metadata is not going to load
+            return () => {
+                current === null || current === void 0 ? void 0 : current.removeEventListener('loadedmetadata', didLoad);
+                continueRender(newHandle);
+            };
+        }, [src, onDuration]);
+    }
+    return _jsx("video", { ref: videoRef, ...props, onError: onError });
+};
+export const VideoForRendering = forwardRef(VideoForRenderingForwardFunction);

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/duration-state.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+type DurationState = Record<string, number>;
+type DurationAction = {
+    type: 'got-duration';
+    src: string;
+    durationInSeconds: number;
+};
+export declare const durationReducer: (state: DurationState, action: DurationAction) => DurationState;
+type TDurationsContext = {
+    durations: DurationState;
+    setDurations: React.Dispatch<DurationAction>;
+};
+export declare const DurationsContext: React.Context<TDurationsContext>;
+export declare const DurationsContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/duration-state.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useMemo, useReducer } from 'react';
+import { getAbsoluteSrc } from '../absolute-src.js';
+export const durationReducer = (state, action) => {
+    switch (action.type) {
+        case 'got-duration':
+            return {
+                ...state,
+                [getAbsoluteSrc(action.src)]: action.durationInSeconds,
+            };
+        default:
+            return state;
+    }
+};
+export const DurationsContext = createContext({
+    durations: {},
+    setDurations: () => {
+        throw new Error('context missing');
+    },
+});
+export const DurationsContextProvider = ({ children }) => {
+    const [durations, setDurations] = useReducer(durationReducer, {});
+    const value = useMemo(() => {
+        return {
+            durations,
+            setDurations,
+        };
+    }, [durations]);
+    return (_jsx(DurationsContext.Provider, { value: value, children: children }));
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/get-current-time.d.ts

@@ -0,0 +1,11 @@
+export declare const getExpectedMediaFrameUncorrected: ({ frame, playbackRate, startFrom, }: {
+    frame: number;
+    playbackRate: number;
+    startFrom: number;
+}) => number;
+export declare const getMediaTime: ({ fps, frame, playbackRate, startFrom, }: {
+    fps: number;
+    frame: number;
+    playbackRate: number;
+    startFrom: number;
+}) => number;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/get-current-time.js

@@ -0,0 +1,14 @@
+// Calculate the `.currentTime` of a video or audio element
+import { interpolate } from '../interpolate.js';
+export const getExpectedMediaFrameUncorrected = ({ frame, playbackRate, startFrom, }) => {
+    return interpolate(frame, [-1, startFrom, startFrom + 1], [-1, startFrom, startFrom + playbackRate]);
+};
+export const getMediaTime = ({ fps, frame, playbackRate, startFrom, }) => {
+    const expectedFrame = getExpectedMediaFrameUncorrected({
+        frame,
+        playbackRate,
+        startFrom,
+    });
+    const msPerFrame = 1000 / fps;
+    return (expectedFrame * msPerFrame) / 1000;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/index.d.ts

@@ -0,0 +1,3 @@
+export { OffthreadVideo } from './OffthreadVideo.js';
+export { OffthreadVideoProps as RemotionOffthreadVideoProps, RemotionMainVideoProps, RemotionVideoProps, } from './props.js';
+export { Video } from './Video.js';

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/index.js

@@ -0,0 +1,2 @@
+export { OffthreadVideo } from './OffthreadVideo.js';
+export { Video } from './Video.js';

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/offthread-video-source.d.ts

@@ -0,0 +1,6 @@
+export declare const getOffthreadVideoSource: ({ src, transparent, currentTime, toneMapped, }: {
+    src: string;
+    transparent: boolean;
+    currentTime: number;
+    toneMapped: boolean;
+}) => string;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/offthread-video-source.js

@@ -0,0 +1,4 @@
+import { getAbsoluteSrc } from '../absolute-src';
+export const getOffthreadVideoSource = ({ src, transparent, currentTime, toneMapped, }) => {
+    return `http://localhost:${window.remotion_proxyPort}/proxy?src=${encodeURIComponent(getAbsoluteSrc(src))}&time=${encodeURIComponent(currentTime)}&transparent=${String(transparent)}&toneMapped=${String(toneMapped)}`;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/props.d.ts

@@ -0,0 +1,49 @@
+import type React from 'react';
+import type { VolumeProp } from '../volume-prop.js';
+export type RemotionMainVideoProps = {
+    startFrom?: number;
+    endAt?: number;
+    /**
+     * @deprecated Only for internal `transparent` use
+     */
+    _remotionInternalNativeLoopPassed?: boolean;
+};
+export type RemotionVideoProps = Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, 'autoPlay' | 'controls' | 'onEnded' | 'nonce'> & {
+    name?: string;
+    volume?: VolumeProp;
+    playbackRate?: number;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+    toneFrequency?: number;
+    pauseWhenBuffering?: boolean;
+    showInTimeline?: boolean;
+};
+type DeprecatedOffthreadVideoProps = {
+    /**
+     * @deprecated Use the `transparent` prop instead
+     */
+    imageFormat?: never;
+};
+export type OffthreadVideoProps = {
+    src: string;
+    className?: string;
+    name?: string;
+    id?: string;
+    style?: React.CSSProperties;
+    volume?: VolumeProp;
+    playbackRate?: number;
+    muted?: boolean;
+    onError?: React.ReactEventHandler<HTMLVideoElement | HTMLImageElement>;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+    toneFrequency?: number;
+    transparent?: boolean;
+    toneMapped?: boolean;
+    pauseWhenBuffering?: boolean;
+    /**
+     * @deprecated For internal use only
+     */
+    stack?: string;
+    showInTimeline?: boolean;
+} & RemotionMainVideoProps & DeprecatedOffthreadVideoProps;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/props.js

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/seek-until-right.d.ts

@@ -0,0 +1,8 @@
+export declare const seekToTime: (element: HTMLVideoElement, desiredTime: number) => {
+    wait: Promise<number>;
+    cancel: () => void;
+};
+export declare const seekToTimeMultipleUntilRight: (element: HTMLVideoElement, desiredTime: number, fps: number) => {
+    prom: Promise<void>;
+    cancel: () => void;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/seek-until-right.js

@@ -0,0 +1,88 @@
+const roundTo6Commas = (num) => {
+    return Math.round(num * 100000) / 100000;
+};
+export const seekToTime = (element, desiredTime) => {
+    element.currentTime = desiredTime;
+    let cancel;
+    let cancelSeeked = null;
+    const prom = new Promise((resolve) => {
+        cancel = element.requestVideoFrameCallback((now, metadata) => {
+            const displayIn = metadata.expectedDisplayTime - now;
+            if (displayIn <= 0) {
+                resolve(metadata.mediaTime);
+                return;
+            }
+            setTimeout(() => {
+                resolve(metadata.mediaTime);
+            }, displayIn + 150);
+        });
+    });
+    const waitForSeekedEvent = new Promise((resolve) => {
+        const onDone = () => {
+            resolve();
+        };
+        element.addEventListener('seeked', onDone, {
+            once: true,
+        });
+        cancelSeeked = () => {
+            element.removeEventListener('seeked', onDone);
+        };
+    });
+    return {
+        wait: Promise.all([prom, waitForSeekedEvent]).then(([time]) => time),
+        cancel: () => {
+            cancelSeeked === null || cancelSeeked === void 0 ? void 0 : cancelSeeked();
+            element.cancelVideoFrameCallback(cancel);
+        },
+    };
+};
+export const seekToTimeMultipleUntilRight = (element, desiredTime, fps) => {
+    const threshold = 1 / fps / 2;
+    let currentCancel = () => undefined;
+    if (Number.isFinite(element.duration) &&
+        element.currentTime >= element.duration &&
+        desiredTime >= element.duration) {
+        return {
+            prom: Promise.resolve(),
+            cancel: () => { },
+        };
+    }
+    const prom = new Promise((resolve, reject) => {
+        const firstSeek = seekToTime(element, desiredTime + threshold);
+        firstSeek.wait.then((seekedTo) => {
+            const difference = Math.abs(desiredTime - seekedTo);
+            if (difference <= threshold) {
+                return resolve();
+            }
+            const sign = desiredTime > seekedTo ? 1 : -1;
+            const newSeek = seekToTime(element, seekedTo + threshold * sign);
+            currentCancel = newSeek.cancel;
+            newSeek.wait
+                .then((newTime) => {
+                const newDifference = Math.abs(desiredTime - newTime);
+                if (roundTo6Commas(newDifference) <= roundTo6Commas(threshold)) {
+                    return resolve();
+                }
+                const thirdSeek = seekToTime(element, desiredTime + threshold);
+                currentCancel = thirdSeek.cancel;
+                return thirdSeek.wait
+                    .then(() => {
+                    resolve();
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+        currentCancel = firstSeek.cancel;
+    });
+    return {
+        prom,
+        cancel: () => {
+            currentCancel();
+        },
+    };
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/video/video-fragment.d.ts

@@ -0,0 +1,13 @@
+export declare const isIosSafari: () => boolean;
+export declare const appendVideoFragment: ({ actualSrc, actualFrom, duration, fps, }: {
+    actualSrc: string;
+    actualFrom: number;
+    duration: number;
+    fps: number;
+}) => string;
+export declare const useAppendVideoFragment: ({ actualSrc: initialActualSrc, actualFrom: initialActualFrom, duration: initialDuration, fps, }: {
+    actualSrc: string;
+    actualFrom: number;
+    duration: number;
+    fps: number;
+}) => string;