remotion 4.0.166 → 4.0.167

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/timeline-position-state.js

@@ -1,66 +0,0 @@
-import { createContext, useContext, useMemo } from 'react';
-import { useVideo } from './use-video.js';
-export const TimelineContext = createContext({
-    frame: {},
-    playing: false,
-    playbackRate: 1,
-    rootId: '',
-    imperativePlaying: {
-        current: false,
-    },
-    setPlaybackRate: () => {
-        throw new Error('default');
-    },
-    audioAndVideoTags: { current: [] },
-});
-export const SetTimelineContext = createContext({
-    setFrame: () => {
-        throw new Error('default');
-    },
-    setPlaying: () => {
-        throw new Error('default');
-    },
-});
-const makeKey = () => {
-    return `remotion.time-all`;
-};
-export const persistCurrentFrame = (time) => {
-    localStorage.setItem(makeKey(), JSON.stringify(time));
-};
-export const getInitialFrameState = () => {
-    var _a;
-    const item = (_a = localStorage.getItem(makeKey())) !== null && _a !== void 0 ? _a : '{}';
-    const obj = JSON.parse(item);
-    return obj;
-};
-export const getFrameForComposition = (composition) => {
-    var _a, _b, _c;
-    const item = (_a = localStorage.getItem(makeKey())) !== null && _a !== void 0 ? _a : '{}';
-    const obj = JSON.parse(item);
-    return obj[composition]
-        ? Number(obj[composition])
-        : (_c = (typeof window === 'undefined' ? 0 : (_b = window.remotion_initialFrame) !== null && _b !== void 0 ? _b : 0)) !== null && _c !== void 0 ? _c : 0;
-};
-export const useTimelinePosition = () => {
-    var _a, _b;
-    const videoConfig = useVideo();
-    const state = useContext(TimelineContext);
-    if (!videoConfig) {
-        return typeof window === 'undefined'
-            ? 0
-            : (_a = window.remotion_initialFrame) !== null && _a !== void 0 ? _a : 0;
-    }
-    const unclamped = (_b = state.frame[videoConfig.id]) !== null && _b !== void 0 ? _b : (typeof window !== 'undefined' && window.remotion_isPlayer
-        ? 0
-        : getFrameForComposition(videoConfig.id));
-    return Math.min(videoConfig.durationInFrames - 1, unclamped);
-};
-export const useTimelineSetFrame = () => {
-    const { setFrame } = useContext(SetTimelineContext);
-    return setFrame;
-};
-export const usePlayingState = () => {
-    const { playing, imperativePlaying } = useContext(TimelineContext);
-    const { setPlaying } = useContext(SetTimelineContext);
-    return useMemo(() => [playing, setPlaying, imperativePlaying], [imperativePlaying, playing, setPlaying]);
-};

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

@@ -1,3 +0,0 @@
-type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
-export declare function truthy<T>(value: T): value is Truthy<T>;
-export {};

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

@@ -1,3 +0,0 @@
-export function truthy(value) {
-    return Boolean(value);
-}

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

@@ -1,5 +0,0 @@
-export declare const useBufferState: () => {
-    delayPlayback: () => {
-        unblock: () => void;
-    };
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-buffer-state.js

@@ -1,16 +0,0 @@
-import { useContext, useMemo } from 'react';
-import { BufferingContextReact } from './buffering';
-export const useBufferState = () => {
-    const buffer = useContext(BufferingContextReact);
-    return useMemo(() => ({
-        delayPlayback: () => {
-            if (!buffer) {
-                throw new Error('Tried to enable the buffering state, but a Remotion context was not found. This API can only be called in a component that was passed to the Remotion Player or a <Composition>. Or you might have experienced a version mismatch - run `npx remotion versions` and ensure all packages have the same version. This error is thrown by the buffer state https://remotion.dev/docs/player/buffer-state');
-            }
-            const { unblock } = buffer.addBlock({
-                id: String(Math.random()),
-            });
-            return { unblock };
-        },
-    }), [buffer]);
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-current-frame.d.ts

@@ -1,5 +0,0 @@
-/**
- * @description Get the current frame of the video. Frames are 0-indexed, meaning the first frame is 0, the last frame is the duration of the composition in frames minus one.
- * @see [Documentation](https://remotion.dev/docs/use-current-frame)
- */
-export declare const useCurrentFrame: () => number;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-current-frame.js

@@ -1,23 +0,0 @@
-import { useContext } from 'react';
-import { CanUseRemotionHooks } from './CanUseRemotionHooks.js';
-import { SequenceContext } from './SequenceContext.js';
-import { useTimelinePosition } from './timeline-position-state.js';
-/**
- * @description Get the current frame of the video. Frames are 0-indexed, meaning the first frame is 0, the last frame is the duration of the composition in frames minus one.
- * @see [Documentation](https://remotion.dev/docs/use-current-frame)
- */
-export const useCurrentFrame = () => {
-    const canUseRemotionHooks = useContext(CanUseRemotionHooks);
-    if (!canUseRemotionHooks) {
-        if (typeof window !== 'undefined' && window.remotion_isPlayer) {
-            throw new Error(`useCurrentFrame can only be called inside a component that was passed to <Player>. See: https://www.remotion.dev/docs/player/examples`);
-        }
-        throw new Error(`useCurrentFrame() can only be called inside a component that was registered as a composition. See https://www.remotion.dev/docs/the-fundamentals#defining-compositions`);
-    }
-    const frame = useTimelinePosition();
-    const context = useContext(SequenceContext);
-    const contextOffset = context
-        ? context.cumulatedFrom + context.relativeFrom
-        : 0;
-    return frame - contextOffset;
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-current-scale.d.ts

@@ -1,43 +0,0 @@
-import React from 'react';
-export type CurrentScaleContextType = {
-    type: 'scale';
-    scale: number;
-} | {
-    type: 'canvas-size';
-    canvasSize: {
-        width: number;
-        height: number;
-    };
-};
-export declare const CurrentScaleContext: React.Context<CurrentScaleContextType | null>;
-type Options = {
-    dontThrowIfOutsideOfRemotion: boolean;
-};
-export type Translation = {
-    x: number;
-    y: number;
-};
-export type PreviewSize = {
-    size: number | 'auto';
-    translation: Translation;
-};
-export type PreviewSizeCtx = {
-    size: PreviewSize;
-    setSize: (cb: (oldSize: PreviewSize) => PreviewSize) => void;
-};
-export declare const PreviewSizeContext: React.Context<PreviewSizeCtx>;
-export declare const calculateScale: ({ canvasSize, compositionHeight, compositionWidth, previewSize, }: {
-    previewSize: PreviewSize['size'];
-    compositionWidth: number;
-    compositionHeight: number;
-    canvasSize: {
-        width: number;
-        height: number;
-    };
-}) => number;
-/**
- * Gets the current scale of the container in which the component is being rendered.
- * Only works in the Remotion Studio and in the Remotion Player.
- */
-export declare const useCurrentScale: (options?: Options) => number;
-export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-current-scale.js

@@ -1,46 +0,0 @@
-import React, { createContext } from 'react';
-import { getRemotionEnvironment } from './get-remotion-environment';
-import { useUnsafeVideoConfig } from './use-unsafe-video-config';
-export const CurrentScaleContext = React.createContext(null);
-export const PreviewSizeContext = createContext({
-    setSize: () => undefined,
-    size: { size: 'auto', translation: { x: 0, y: 0 } },
-});
-export const calculateScale = ({ canvasSize, compositionHeight, compositionWidth, previewSize, }) => {
-    const heightRatio = canvasSize.height / compositionHeight;
-    const widthRatio = canvasSize.width / compositionWidth;
-    const ratio = Math.min(heightRatio, widthRatio);
-    return previewSize === 'auto' ? ratio : Number(previewSize);
-};
-/**
- * Gets the current scale of the container in which the component is being rendered.
- * Only works in the Remotion Studio and in the Remotion Player.
- */
-export const useCurrentScale = (options) => {
-    const hasContext = React.useContext(CurrentScaleContext);
-    const zoomContext = React.useContext(PreviewSizeContext);
-    const config = useUnsafeVideoConfig();
-    if (hasContext === null || config === null || zoomContext === null) {
-        if (options === null || options === void 0 ? void 0 : options.dontThrowIfOutsideOfRemotion) {
-            return 1;
-        }
-        if (getRemotionEnvironment().isRendering) {
-            return 1;
-        }
-        throw new Error([
-            'useCurrentScale() was called outside of a Remotion context.',
-            'This hook can only be called in a component that is being rendered by Remotion.',
-            'If you want to this hook to return 1 outside of Remotion, pass {dontThrowIfOutsideOfRemotion: true} as an option.',
-            'If you think you called this hook in a Remotion component, make sure all versions of Remotion are aligned.',
-        ].join('\n'));
-    }
-    if (hasContext.type === 'scale') {
-        return hasContext.scale;
-    }
-    return calculateScale({
-        canvasSize: hasContext.canvasSize,
-        compositionHeight: config.height,
-        compositionWidth: config.width,
-        previewSize: zoomContext.size.size,
-    });
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-lazy-component.d.ts

@@ -1,7 +0,0 @@
-import type { ComponentPropsWithRef, ComponentType, ExoticComponent } from 'react';
-import type { CompProps } from './Composition.js';
-type LazyExoticComponent<T extends ComponentType<any>> = ExoticComponent<ComponentPropsWithRef<T>> & {
-    readonly _result: T;
-};
-export declare const useLazyComponent: <Props>(compProps: CompProps<Props>) => LazyExoticComponent<ComponentType<Props>>;
-export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-lazy-component.js

@@ -1,22 +0,0 @@
-import React, { useMemo } from 'react';
-// Expected, it can be any component props
-export const useLazyComponent = (compProps) => {
-    const lazy = useMemo(() => {
-        if ('lazyComponent' in compProps) {
-            return React.lazy(compProps.lazyComponent);
-        }
-        if ('component' in compProps) {
-            // In SSR, suspense is not yet supported, we cannot use React.lazy
-            if (typeof document === 'undefined') {
-                return compProps.component;
-            }
-            return React.lazy(() => Promise.resolve({ default: compProps.component }));
-        }
-        throw new Error("You must pass either 'component' or 'lazyComponent'");
-        // Very important to leave the dependencies as they are, or instead
-        // the player will remount on every frame.
-        // @ts-expect-error
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [compProps.component, compProps.lazyComponent]);
-    return lazy;
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-buffering.d.ts

@@ -1,6 +0,0 @@
-import type React from 'react';
-export declare const useMediaBuffering: ({ element, shouldBuffer, isPremounting, }: {
-    element: React.RefObject<HTMLVideoElement | HTMLAudioElement>;
-    shouldBuffer: boolean;
-    isPremounting: boolean;
-}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-buffering.js

@@ -1,48 +0,0 @@
-import { useEffect } from 'react';
-import { useBufferState } from './use-buffer-state';
-export const useMediaBuffering = ({ element, shouldBuffer, isPremounting, }) => {
-    const buffer = useBufferState();
-    useEffect(() => {
-        let cleanup = () => undefined;
-        const { current } = element;
-        if (!current) {
-            return;
-        }
-        if (!shouldBuffer) {
-            return;
-        }
-        if (isPremounting) {
-            return;
-        }
-        const onWaiting = () => {
-            const { unblock } = buffer.delayPlayback();
-            const onCanPlay = () => {
-                unblock();
-            };
-            const onError = () => {
-                unblock();
-            };
-            current.addEventListener('canplay', onCanPlay, {
-                once: true,
-            });
-            current.addEventListener('error', onError, {
-                once: true,
-            });
-            cleanup = () => {
-                current.removeEventListener('canplay', onCanPlay);
-                current.removeEventListener('error', onError);
-                unblock();
-                return undefined;
-            };
-        };
-        if (current.readyState < current.HAVE_FUTURE_DATA) {
-            onWaiting();
-        }
-        else {
-            current.addEventListener('waiting', onWaiting);
-        }
-        return () => {
-            cleanup();
-        };
-    }, [buffer, element, isPremounting, shouldBuffer]);
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-in-timeline.d.ts

@@ -1,15 +0,0 @@
-import type { RefObject } from 'react';
-import type { VolumeProp } from './volume-prop.js';
-export declare const useMediaInTimeline: ({ volume, mediaVolume, mediaRef, src, mediaType, playbackRate, displayName, id, stack, showInTimeline, premountDisplay, }: {
-    volume: VolumeProp | undefined;
-    mediaVolume: number;
-    mediaRef: RefObject<HTMLAudioElement | HTMLVideoElement>;
-    src: string | undefined;
-    mediaType: 'audio' | 'video';
-    playbackRate: number;
-    displayName: string | null;
-    id: string;
-    stack: string | null;
-    showInTimeline: boolean;
-    premountDisplay: number | null;
-}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-in-timeline.js

@@ -1,132 +0,0 @@
-import { useContext, useEffect, useMemo, useState } from 'react';
-import { SequenceContext } from './SequenceContext.js';
-import { SequenceManager } from './SequenceManager.js';
-import { useMediaStartsAt } from './audio/use-audio-frame.js';
-import { getAssetDisplayName } from './get-asset-file-name.js';
-import { getRemotionEnvironment } from './get-remotion-environment.js';
-import { useNonce } from './nonce.js';
-import { playAndHandleNotAllowedError } from './play-and-handle-not-allowed-error.js';
-import { TimelineContext, usePlayingState } from './timeline-position-state.js';
-import { useVideoConfig } from './use-video-config.js';
-import { evaluateVolume } from './volume-prop.js';
-const didWarn = {};
-const warnOnce = (message) => {
-    if (didWarn[message]) {
-        return;
-    }
-    // eslint-disable-next-line no-console
-    console.warn(message);
-    didWarn[message] = true;
-};
-export const useMediaInTimeline = ({ volume, mediaVolume, mediaRef, src, mediaType, playbackRate, displayName, id, stack, showInTimeline, premountDisplay, }) => {
-    const videoConfig = useVideoConfig();
-    const { rootId, audioAndVideoTags } = useContext(TimelineContext);
-    const parentSequence = useContext(SequenceContext);
-    const actualFrom = parentSequence
-        ? parentSequence.relativeFrom + parentSequence.cumulatedFrom
-        : 0;
-    const [playing] = usePlayingState();
-    const startsAt = useMediaStartsAt();
-    const { registerSequence, unregisterSequence } = useContext(SequenceManager);
-    const [initialVolume] = useState(() => volume);
-    const nonce = useNonce();
-    const duration = parentSequence
-        ? Math.min(parentSequence.durationInFrames, videoConfig.durationInFrames)
-        : videoConfig.durationInFrames;
-    const doesVolumeChange = typeof volume === 'function';
-    const volumes = useMemo(() => {
-        if (typeof volume === 'number') {
-            return volume;
-        }
-        return new Array(Math.floor(Math.max(0, duration + startsAt)))
-            .fill(true)
-            .map((_, i) => {
-            return evaluateVolume({
-                frame: i + startsAt,
-                volume,
-                mediaVolume,
-                allowAmplificationDuringRender: false,
-            });
-        })
-            .join(',');
-    }, [duration, startsAt, volume, mediaVolume]);
-    useEffect(() => {
-        if (typeof volume === 'number' && volume !== initialVolume) {
-            warnOnce(`Remotion: The ${mediaType} with src ${src} has changed it's volume. Prefer the callback syntax for setting volume to get better timeline display: https://www.remotion.dev/docs/using-audio/#controlling-volume`);
-        }
-    }, [initialVolume, mediaType, src, volume]);
-    useEffect(() => {
-        var _a;
-        if (!mediaRef.current) {
-            return;
-        }
-        if (!src) {
-            throw new Error('No src passed');
-        }
-        if (!getRemotionEnvironment().isStudio && process.env.NODE_ENV !== 'test') {
-            return;
-        }
-        if (!showInTimeline) {
-            return;
-        }
-        registerSequence({
-            type: mediaType,
-            src,
-            id,
-            duration,
-            from: 0,
-            parent: (_a = parentSequence === null || parentSequence === void 0 ? void 0 : parentSequence.id) !== null && _a !== void 0 ? _a : null,
-            displayName: displayName !== null && displayName !== void 0 ? displayName : getAssetDisplayName(src),
-            rootId,
-            volume: volumes,
-            showInTimeline: true,
-            nonce,
-            startMediaFrom: 0 - startsAt,
-            doesVolumeChange,
-            loopDisplay: undefined,
-            playbackRate,
-            stack,
-            premountDisplay,
-        });
-        return () => {
-            unregisterSequence(id);
-        };
-    }, [
-        actualFrom,
-        duration,
-        id,
-        parentSequence,
-        src,
-        registerSequence,
-        rootId,
-        unregisterSequence,
-        videoConfig,
-        volumes,
-        doesVolumeChange,
-        nonce,
-        mediaRef,
-        mediaType,
-        startsAt,
-        playbackRate,
-        displayName,
-        stack,
-        showInTimeline,
-        premountDisplay,
-    ]);
-    useEffect(() => {
-        const tag = {
-            id,
-            play: () => {
-                if (!playing) {
-                    // Don't play if for example in a <Freeze> state.
-                    return;
-                }
-                return playAndHandleNotAllowedError(mediaRef, mediaType);
-            },
-        };
-        audioAndVideoTags.current.push(tag);
-        return () => {
-            audioAndVideoTags.current = audioAndVideoTags.current.filter((a) => a.id !== id);
-        };
-    }, [audioAndVideoTags, id, mediaRef, mediaType, playing]);
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-playback.d.ts

@@ -1,10 +0,0 @@
-import type { RefObject } from 'react';
-export declare const DEFAULT_ACCEPTABLE_TIMESHIFT = 0.45;
-export declare const useMediaPlayback: ({ mediaRef, src, mediaType, playbackRate: localPlaybackRate, onlyWarnForMediaSeekingError, acceptableTimeshift, }: {
-    mediaRef: RefObject<HTMLVideoElement | HTMLAudioElement>;
-    src: string | undefined;
-    mediaType: 'audio' | 'video';
-    playbackRate: number;
-    onlyWarnForMediaSeekingError: boolean;
-    acceptableTimeshift: number;
-}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-playback.js

@@ -1,114 +0,0 @@
-import { useContext, useEffect } from 'react';
-import { useMediaStartsAt } from './audio/use-audio-frame.js';
-import { BufferingContextReact } from './buffering.js';
-import { playAndHandleNotAllowedError } from './play-and-handle-not-allowed-error.js';
-import { TimelineContext, usePlayingState, useTimelinePosition, } from './timeline-position-state.js';
-import { useCurrentFrame } from './use-current-frame.js';
-import { useVideoConfig } from './use-video-config.js';
-import { getMediaTime } from './video/get-current-time.js';
-import { isIosSafari } from './video/video-fragment.js';
-import { warnAboutNonSeekableMedia } from './warn-about-non-seekable-media.js';
-export const DEFAULT_ACCEPTABLE_TIMESHIFT = 0.45;
-const seek = (mediaRef, time) => {
-    if (!mediaRef.current) {
-        return;
-    }
-    // iOS seeking does not support multiple decimals
-    if (isIosSafari()) {
-        mediaRef.current.currentTime = Number(time.toFixed(1));
-        return;
-    }
-    mediaRef.current.currentTime = time;
-};
-export const useMediaPlayback = ({ mediaRef, src, mediaType, playbackRate: localPlaybackRate, onlyWarnForMediaSeekingError, acceptableTimeshift, }) => {
-    const { playbackRate: globalPlaybackRate } = useContext(TimelineContext);
-    const frame = useCurrentFrame();
-    const absoluteFrame = useTimelinePosition();
-    const [playing] = usePlayingState();
-    const buffering = useContext(BufferingContextReact);
-    const { fps } = useVideoConfig();
-    const mediaStartsAt = useMediaStartsAt();
-    const playbackRate = localPlaybackRate * globalPlaybackRate;
-    // For short audio, a lower acceptable time shift is used
-    const acceptableTimeShiftButLessThanDuration = (() => {
-        var _a;
-        if ((_a = mediaRef.current) === null || _a === void 0 ? void 0 : _a.duration) {
-            return Math.min(mediaRef.current.duration, acceptableTimeshift !== null && acceptableTimeshift !== void 0 ? acceptableTimeshift : DEFAULT_ACCEPTABLE_TIMESHIFT);
-        }
-        return acceptableTimeshift;
-    })();
-    const pausedOrBuffering = !playing || (buffering && buffering.buffering.current);
-    useEffect(() => {
-        var _a;
-        if (pausedOrBuffering) {
-            (_a = mediaRef.current) === null || _a === void 0 ? void 0 : _a.pause();
-        }
-    }, [mediaRef, mediaType, pausedOrBuffering]);
-    useEffect(() => {
-        const tagName = mediaType === 'audio' ? '<Audio>' : '<Video>';
-        if (!mediaRef.current) {
-            throw new Error(`No ${mediaType} ref found`);
-        }
-        if (!src) {
-            throw new Error(`No 'src' attribute was passed to the ${tagName} element.`);
-        }
-        const playbackRateToSet = Math.max(0, playbackRate);
-        if (mediaRef.current.playbackRate !== playbackRateToSet) {
-            mediaRef.current.playbackRate = playbackRateToSet;
-        }
-        const desiredUnclampedTime = getMediaTime({
-            frame,
-            playbackRate: localPlaybackRate,
-            startFrom: -mediaStartsAt,
-            fps,
-        });
-        const { duration } = mediaRef.current;
-        const shouldBeTime = !Number.isNaN(duration) && Number.isFinite(duration)
-            ? Math.min(duration, desiredUnclampedTime)
-            : desiredUnclampedTime;
-        const isTime = mediaRef.current.currentTime;
-        const timeShift = Math.abs(shouldBeTime - isTime);
-        if (timeShift > acceptableTimeShiftButLessThanDuration) {
-            // If scrubbing around, adjust timing
-            // or if time shift is bigger than 0.45sec
-            seek(mediaRef, shouldBeTime);
-            if (!onlyWarnForMediaSeekingError) {
-                warnAboutNonSeekableMedia(mediaRef.current, onlyWarnForMediaSeekingError ? 'console-warning' : 'console-error');
-            }
-            return;
-        }
-        // Only perform a seek if the time is not already the same.
-        // Chrome rounds to 6 digits, so 0.033333333 -> 0.033333,
-        // therefore a threshold is allowed.
-        // Refer to the https://github.com/remotion-dev/video-buffering-example
-        // which is fixed by only seeking conditionally.
-        const makesSenseToSeek = Math.abs(mediaRef.current.currentTime - shouldBeTime) > 0.00001;
-        if (pausedOrBuffering || absoluteFrame === 0) {
-            if (makesSenseToSeek) {
-                seek(mediaRef, shouldBeTime);
-            }
-        }
-        if (mediaRef.current.paused &&
-            !mediaRef.current.ended &&
-            !pausedOrBuffering) {
-            if (makesSenseToSeek) {
-                seek(mediaRef, shouldBeTime);
-            }
-            playAndHandleNotAllowedError(mediaRef, mediaType);
-        }
-    }, [
-        absoluteFrame,
-        fps,
-        playbackRate,
-        frame,
-        mediaRef,
-        mediaType,
-        src,
-        mediaStartsAt,
-        localPlaybackRate,
-        onlyWarnForMediaSeekingError,
-        acceptableTimeshift,
-        acceptableTimeShiftButLessThanDuration,
-        pausedOrBuffering,
-    ]);
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-tag-volume.d.ts

@@ -1,2 +0,0 @@
-import type { RefObject } from 'react';
-export declare const useMediaTagVolume: (mediaRef: RefObject<HTMLVideoElement | HTMLAudioElement>) => number;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-media-tag-volume.js

@@ -1,27 +0,0 @@
-import { useEffect, useState } from 'react';
-// Returns the real volume of the audio or video while playing,
-// no matter what the supposed volume should be
-export const useMediaTagVolume = (mediaRef) => {
-    const [actualVolume, setActualVolume] = useState(1);
-    useEffect(() => {
-        const ref = mediaRef.current;
-        if (!ref) {
-            return;
-        }
-        const onChange = () => {
-            setActualVolume(ref.volume);
-        };
-        ref.addEventListener('volumechange', onChange);
-        return () => ref.removeEventListener('volumechange', onChange);
-    }, [mediaRef]);
-    useEffect(() => {
-        const ref = mediaRef.current;
-        if (!ref) {
-            return;
-        }
-        if (ref.volume !== actualVolume) {
-            setActualVolume(ref.volume);
-        }
-    }, [actualVolume, mediaRef]);
-    return actualVolume;
-};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-sync-volume-with-media-tag.d.ts

@@ -1,10 +0,0 @@
-import type { RefObject } from 'react';
-import type { VolumeProp } from './volume-prop.js';
-export type UseSyncVolumeWithMediaTagOptions = {
-    volumePropFrame: number;
-    actualVolume: number;
-    volume?: VolumeProp;
-    mediaVolume: number;
-    mediaRef: RefObject<HTMLVideoElement | HTMLAudioElement>;
-};
-export declare const useSyncVolumeWithMediaTag: ({ volumePropFrame, actualVolume, volume, mediaVolume, mediaRef, }: UseSyncVolumeWithMediaTagOptions) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/use-sync-volume-with-media-tag.js

@@ -1,17 +0,0 @@
-import { useEffect } from 'react';
-import { isApproximatelyTheSame } from './is-approximately-the-same.js';
-import { evaluateVolume } from './volume-prop.js';
-export const useSyncVolumeWithMediaTag = ({ volumePropFrame, actualVolume, volume, mediaVolume, mediaRef, }) => {
-    useEffect(() => {
-        const userPreferredVolume = evaluateVolume({
-            frame: volumePropFrame,
-            volume,
-            mediaVolume,
-            allowAmplificationDuringRender: false,
-        });
-        if (!isApproximatelyTheSame(userPreferredVolume, actualVolume) &&
-            mediaRef.current) {
-            mediaRef.current.volume = userPreferredVolume;
-        }
-    }, [actualVolume, volumePropFrame, mediaRef, volume, mediaVolume]);
-};

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

@@ -1,2 +0,0 @@
-import type { VideoConfig } from './video-config.js';
-export declare const useUnsafeVideoConfig: () => VideoConfig | null;