@remotion/player 4.1.0-alpha11 → 4.1.0-alpha12

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-player.js

@@ -0,0 +1,147 @@
+import { useCallback, useContext, useMemo, useRef, useState } from 'react';
+import { Internals } from 'remotion';
+import { PlayerEventEmitterContext } from './emitter-context.js';
+export const usePlayer = () => {
+    var _a;
+    const [playing, setPlaying, imperativePlaying] = Internals.Timeline.usePlayingState();
+    const [hasPlayed, setHasPlayed] = useState(false);
+    const frame = Internals.Timeline.useTimelinePosition();
+    const playStart = useRef(frame);
+    const setFrame = Internals.Timeline.useTimelineSetFrame();
+    const setTimelinePosition = Internals.Timeline.useTimelineSetFrame();
+    const audioContext = useContext(Internals.SharedAudioContext);
+    const { audioAndVideoTags } = useContext(Internals.Timeline.TimelineContext);
+    const frameRef = useRef();
+    frameRef.current = frame;
+    const video = Internals.useVideo();
+    const config = Internals.useUnsafeVideoConfig();
+    const emitter = useContext(PlayerEventEmitterContext);
+    const lastFrame = ((_a = config === null || config === void 0 ? void 0 : config.durationInFrames) !== null && _a !== void 0 ? _a : 1) - 1;
+    const isLastFrame = frame === lastFrame;
+    const isFirstFrame = frame === 0;
+    if (!emitter) {
+        throw new TypeError('Expected Player event emitter context');
+    }
+    const seek = useCallback((newFrame) => {
+        if (video === null || video === void 0 ? void 0 : video.id) {
+            setTimelinePosition((c) => ({ ...c, [video.id]: newFrame }));
+        }
+        emitter.dispatchSeek(newFrame);
+    }, [emitter, setTimelinePosition, video === null || video === void 0 ? void 0 : video.id]);
+    const play = useCallback((e) => {
+        if (imperativePlaying.current) {
+            return;
+        }
+        setHasPlayed(true);
+        if (isLastFrame) {
+            seek(0);
+        }
+        /**
+         * Play silent audio tags to warm them up for autoplay
+         */
+        if (audioContext && audioContext.numberOfAudioTags > 0 && e) {
+            audioContext.playAllAudios();
+        }
+        /**
+         * Play audios and videos directly here so they can benefit from
+         * being triggered by a click
+         */
+        audioAndVideoTags.current.forEach((a) => a.play());
+        imperativePlaying.current = true;
+        setPlaying(true);
+        playStart.current = frameRef.current;
+        emitter.dispatchPlay();
+    }, [
+        imperativePlaying,
+        isLastFrame,
+        audioContext,
+        setPlaying,
+        emitter,
+        seek,
+        audioAndVideoTags,
+    ]);
+    const pause = useCallback(() => {
+        if (imperativePlaying.current) {
+            imperativePlaying.current = false;
+            setPlaying(false);
+            emitter.dispatchPause();
+        }
+    }, [emitter, imperativePlaying, setPlaying]);
+    const pauseAndReturnToPlayStart = useCallback(() => {
+        if (imperativePlaying.current) {
+            imperativePlaying.current = false;
+            if (config) {
+                setTimelinePosition((c) => ({
+                    ...c,
+                    [config.id]: playStart.current,
+                }));
+                setPlaying(false);
+                emitter.dispatchPause();
+            }
+        }
+    }, [config, emitter, imperativePlaying, setPlaying, setTimelinePosition]);
+    const videoId = video === null || video === void 0 ? void 0 : video.id;
+    const frameBack = useCallback((frames) => {
+        if (!videoId) {
+            return null;
+        }
+        if (imperativePlaying.current) {
+            return;
+        }
+        setFrame((c) => {
+            var _a, _b;
+            const prev = (_b = (_a = c[videoId]) !== null && _a !== void 0 ? _a : window.remotion_initialFrame) !== null && _b !== void 0 ? _b : 0;
+            return {
+                ...c,
+                [videoId]: Math.max(0, prev - frames),
+            };
+        });
+    }, [imperativePlaying, setFrame, videoId]);
+    const frameForward = useCallback((frames) => {
+        if (!videoId) {
+            return null;
+        }
+        if (imperativePlaying.current) {
+            return;
+        }
+        setFrame((c) => {
+            var _a, _b;
+            const prev = (_b = (_a = c[videoId]) !== null && _a !== void 0 ? _a : window.remotion_initialFrame) !== null && _b !== void 0 ? _b : 0;
+            return {
+                ...c,
+                [videoId]: Math.min(lastFrame, prev + frames),
+            };
+        });
+    }, [videoId, imperativePlaying, lastFrame, setFrame]);
+    const returnValue = useMemo(() => {
+        return {
+            frameBack,
+            frameForward,
+            isLastFrame,
+            emitter,
+            playing,
+            play,
+            pause,
+            seek,
+            isFirstFrame,
+            getCurrentFrame: () => frameRef.current,
+            isPlaying: () => imperativePlaying.current,
+            pauseAndReturnToPlayStart,
+            hasPlayed,
+        };
+    }, [
+        frameBack,
+        frameForward,
+        isLastFrame,
+        emitter,
+        playing,
+        play,
+        pause,
+        seek,
+        isFirstFrame,
+        pauseAndReturnToPlayStart,
+        imperativePlaying,
+        hasPlayed,
+    ]);
+    return returnValue;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-thumbnail.d.ts

@@ -0,0 +1,6 @@
+import type { ThumbnailEmitter } from './event-emitter.js';
+type UseThumbnailMethods = {
+    emitter: ThumbnailEmitter;
+};
+export declare const useThumbnail: () => UseThumbnailMethods;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-thumbnail.js

@@ -0,0 +1,14 @@
+import { useContext, useMemo } from 'react';
+import { ThumbnailEmitterContext } from './emitter-context.js';
+export const useThumbnail = () => {
+    const emitter = useContext(ThumbnailEmitterContext);
+    if (!emitter) {
+        throw new TypeError('Expected Player event emitter context');
+    }
+    const returnValue = useMemo(() => {
+        return {
+            emitter,
+        };
+    }, [emitter]);
+    return returnValue;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-video-controls-resize.d.ts

@@ -0,0 +1,11 @@
+type Info = {
+    maxTimeLabelWidth: number | null;
+    displayVerticalVolumeSlider: boolean;
+};
+export declare const X_SPACER = 10;
+export declare const X_PADDING = 12;
+export declare const useVideoControlsResize: ({ allowFullscreen: allowFullScreen, playerWidth, }: {
+    allowFullscreen: boolean;
+    playerWidth: number;
+}) => Info;
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-video-controls-resize.js

@@ -0,0 +1,35 @@
+import { useMemo } from 'react';
+import { fullscreenIconSize, ICON_SIZE } from './icons.js';
+import { VOLUME_SLIDER_WIDTH } from './MediaVolumeSlider.js';
+export const X_SPACER = 10;
+export const X_PADDING = 12;
+export const useVideoControlsResize = ({ allowFullscreen: allowFullScreen, playerWidth, }) => {
+    const resizeInfo = useMemo(() => {
+        const playPauseIconSize = ICON_SIZE;
+        const volumeIconSize = ICON_SIZE;
+        const _fullscreenIconSize = allowFullScreen ? fullscreenIconSize : 0;
+        const elementsSize = volumeIconSize +
+            playPauseIconSize +
+            _fullscreenIconSize +
+            X_PADDING * 2 +
+            X_SPACER * 2;
+        const maxTimeLabelWidth = playerWidth - elementsSize;
+        const maxTimeLabelWidthWithoutNegativeValue = Math.max(maxTimeLabelWidth, 0);
+        const availableTimeLabelWidthIfVolumeOpen = maxTimeLabelWidthWithoutNegativeValue - VOLUME_SLIDER_WIDTH;
+        // If max label width is lower than the volume width
+        // then it means we need to take it's width as the max label width
+        // otherwise we took the available width when volume open
+        const computedLabelWidth = availableTimeLabelWidthIfVolumeOpen < VOLUME_SLIDER_WIDTH
+            ? maxTimeLabelWidthWithoutNegativeValue
+            : availableTimeLabelWidthIfVolumeOpen;
+        const minWidthForHorizontalDisplay = computedLabelWidth + elementsSize + VOLUME_SLIDER_WIDTH;
+        const displayVerticalVolumeSlider = playerWidth < minWidthForHorizontalDisplay;
+        return {
+            maxTimeLabelWidth: maxTimeLabelWidthWithoutNegativeValue === 0
+                ? null
+                : maxTimeLabelWidthWithoutNegativeValue,
+            displayVerticalVolumeSlider,
+        };
+    }, [allowFullScreen, playerWidth]);
+    return resizeInfo;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/calculate-player-size.d.ts

@@ -0,0 +1,9 @@
+import type { StandardLonghandProperties } from 'csstype';
+import type { Size } from './use-element-size.js';
+export declare const calculatePlayerSize: ({ currentSize, width, height, compositionWidth, compositionHeight, }: {
+    currentSize: Size | null;
+    width: StandardLonghandProperties['width'] | undefined;
+    height: StandardLonghandProperties['height'] | undefined;
+    compositionWidth: number;
+    compositionHeight: number;
+}) => React.CSSProperties;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/calculate-player-size.js

@@ -0,0 +1,24 @@
+export const calculatePlayerSize = ({ currentSize, width, height, compositionWidth, compositionHeight, }) => {
+    if (width !== undefined && height === undefined) {
+        return {
+            aspectRatio: [compositionWidth, compositionHeight].join('/'),
+        };
+    }
+    // Opposite: If has height specified, evaluate the height and specify a default width.
+    if (height !== undefined && width === undefined) {
+        return {
+            // Aspect ratio CSS prop will work
+            aspectRatio: [compositionWidth, compositionHeight].join('/'),
+        };
+    }
+    if (!currentSize) {
+        return {
+            width: compositionWidth,
+            height: compositionHeight,
+        };
+    }
+    return {
+        width: compositionWidth,
+        height: compositionHeight,
+    };
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/cancellable-promise.d.ts

@@ -0,0 +1,5 @@
+export type CancellablePromise = {
+    promise: Promise<unknown>;
+    cancel: () => void;
+};
+export declare const cancellablePromise: (promise: Promise<unknown>) => CancellablePromise;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/cancellable-promise.js

@@ -0,0 +1,22 @@
+export const cancellablePromise = (promise) => {
+    let isCanceled = false;
+    const wrappedPromise = new Promise((resolve, reject) => {
+        promise
+            .then((value) => {
+            if (isCanceled) {
+                reject({ isCanceled, value });
+                return;
+            }
+            resolve(value);
+        })
+            .catch((error) => {
+            reject({ isCanceled, error });
+        });
+    });
+    return {
+        promise: wrappedPromise,
+        cancel: () => {
+            isCanceled = true;
+        },
+    };
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/delay.d.ts

@@ -0,0 +1 @@
+export declare const delay: (n: number) => Promise<unknown>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/delay.js

@@ -0,0 +1,2 @@
+/* eslint-disable no-promise-executor-return */
+export const delay = (n) => new Promise((resolve) => setTimeout(resolve, n));

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/is-node.d.ts

@@ -0,0 +1 @@
+export declare const IS_NODE: boolean;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/is-node.js

@@ -0,0 +1 @@
+export const IS_NODE = typeof document === 'undefined';

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/preview-size.d.ts

@@ -0,0 +1,8 @@
+export type Translation = {
+    x: number;
+    y: number;
+};
+export type PreviewSize = {
+    size: number | 'auto';
+    translation: Translation;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/preview-size.js

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/props-if-has-props.d.ts

@@ -0,0 +1,10 @@
+import type { AnyZodObject, z } from 'zod';
+export type PropsIfHasProps<Schema extends AnyZodObject, Props> = AnyZodObject extends Schema ? {} extends Props ? {
+    inputProps?: z.infer<Schema> & Props;
+} : {
+    inputProps: Props;
+} : {} extends Props ? {
+    inputProps: z.infer<Schema>;
+} : {
+    inputProps: z.infer<Schema> & Props;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/props-if-has-props.js

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-cancellable-promises.d.ts

@@ -0,0 +1,7 @@
+import type { CancellablePromise } from './cancellable-promise.js';
+declare const useCancellablePromises: () => {
+    appendPendingPromise: (promise: CancellablePromise) => void;
+    removePendingPromise: (promise: CancellablePromise) => void;
+    clearPendingPromises: () => void[];
+};
+export { useCancellablePromises };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-cancellable-promises.js

@@ -0,0 +1,18 @@
+import { useCallback, useMemo, useRef } from 'react';
+const useCancellablePromises = () => {
+    const pendingPromises = useRef([]);
+    const appendPendingPromise = useCallback((promise) => {
+        pendingPromises.current = [...pendingPromises.current, promise];
+    }, []);
+    const removePendingPromise = useCallback((promise) => {
+        pendingPromises.current = pendingPromises.current.filter((p) => p !== promise);
+    }, []);
+    const clearPendingPromises = useCallback(() => pendingPromises.current.map((p) => p.cancel()), []);
+    const api = useMemo(() => ({
+        appendPendingPromise,
+        removePendingPromise,
+        clearPendingPromises,
+    }), [appendPendingPromise, clearPendingPromises, removePendingPromise]);
+    return api;
+};
+export { useCancellablePromises };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-click-prevention-on-double-click.d.ts

@@ -0,0 +1,3 @@
+import type { SyntheticEvent } from 'react';
+declare const useClickPreventionOnDoubleClick: (onClick: (e: SyntheticEvent) => void, onDoubleClick: () => void, doubleClickToFullscreen: boolean) => [(e: SyntheticEvent) => void, () => void];
+export { useClickPreventionOnDoubleClick };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-click-prevention-on-double-click.js

@@ -0,0 +1,42 @@
+import { useCallback, useMemo } from 'react';
+import { cancellablePromise } from './cancellable-promise.js';
+import { delay } from './delay.js';
+import { useCancellablePromises } from './use-cancellable-promises.js';
+const useClickPreventionOnDoubleClick = (onClick, onDoubleClick, doubleClickToFullscreen) => {
+    const api = useCancellablePromises();
+    const handleClick = useCallback(async (e) => {
+        api.clearPendingPromises();
+        const waitForClick = cancellablePromise(delay(200));
+        api.appendPendingPromise(waitForClick);
+        try {
+            await waitForClick.promise;
+            api.removePendingPromise(waitForClick);
+            onClick(e);
+        }
+        catch (errorInfo) {
+            const info = errorInfo;
+            api.removePendingPromise(waitForClick);
+            if (!info.isCanceled) {
+                throw info.error;
+            }
+        }
+    }, [api, onClick]);
+    const handleDoubleClick = useCallback(() => {
+        api.clearPendingPromises();
+        onDoubleClick();
+    }, [api, onDoubleClick]);
+    const returnValue = useMemo(() => {
+        if (!doubleClickToFullscreen) {
+            return [onClick, onDoubleClick];
+        }
+        return [handleClick, handleDoubleClick];
+    }, [
+        doubleClickToFullscreen,
+        handleClick,
+        handleDoubleClick,
+        onClick,
+        onDoubleClick,
+    ]);
+    return returnValue;
+};
+export { useClickPreventionOnDoubleClick };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-component-visible.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export default function useComponentVisible(initialIsVisible: boolean): {
+    ref: import("react").RefObject<HTMLDivElement>;
+    isComponentVisible: boolean;
+    setIsComponentVisible: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-component-visible.js

@@ -0,0 +1,18 @@
+import { useEffect, useRef, useState } from 'react';
+// hook to hide a popup/modal when clicked outside
+export default function useComponentVisible(initialIsVisible) {
+    const [isComponentVisible, setIsComponentVisible] = useState(initialIsVisible);
+    const ref = useRef(null);
+    useEffect(() => {
+        const handleClickOutside = (event) => {
+            if (ref.current && !ref.current.contains(event.target)) {
+                setIsComponentVisible(false);
+            }
+        };
+        document.addEventListener('pointerup', handleClickOutside, true);
+        return () => {
+            document.removeEventListener('pointerup', handleClickOutside, true);
+        };
+    }, []);
+    return { ref, isComponentVisible, setIsComponentVisible };
+}

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-element-size.d.ts

@@ -0,0 +1,16 @@
+export type Size = {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    windowSize: {
+        width: number;
+        height: number;
+    };
+    refresh: () => void;
+};
+export declare const updateAllElementsSizes: () => void;
+export declare const useElementSize: (ref: React.RefObject<HTMLElement>, options: {
+    triggerOnWindowResize: boolean;
+    shouldApplyCssTransforms: boolean;
+}) => Size | null;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/use-element-size.js

@@ -0,0 +1,127 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+let elementSizeHooks = [];
+export const updateAllElementsSizes = () => {
+    for (const listener of elementSizeHooks) {
+        listener();
+    }
+};
+export const useElementSize = (ref, options) => {
+    const [size, setSize] = useState(() => {
+        if (!ref.current) {
+            return null;
+        }
+        const rect = ref.current.getClientRects();
+        if (!rect[0]) {
+            return null;
+        }
+        return {
+            width: rect[0].width,
+            height: rect[0].height,
+            left: rect[0].x,
+            top: rect[0].y,
+            windowSize: {
+                height: window.innerHeight,
+                width: window.innerWidth,
+            },
+        };
+    });
+    const observer = useMemo(() => {
+        if (typeof ResizeObserver === 'undefined') {
+            return null;
+        }
+        return new ResizeObserver((entries) => {
+            // The contentRect returns the width without any `scale()`'s being applied. The height is wrong
+            const { contentRect, target } = entries[0];
+            // The clientRect returns the size with `scale()` being applied.
+            const newSize = target.getClientRects();
+            if (!(newSize === null || newSize === void 0 ? void 0 : newSize[0])) {
+                setSize(null);
+                return;
+            }
+            const probableCssParentScale = contentRect.width === 0 ? 1 : newSize[0].width / contentRect.width;
+            const width = options.shouldApplyCssTransforms
+                ? newSize[0].width
+                : newSize[0].width * (1 / probableCssParentScale);
+            const height = options.shouldApplyCssTransforms
+                ? newSize[0].height
+                : newSize[0].height * (1 / probableCssParentScale);
+            setSize({
+                width,
+                height,
+                left: newSize[0].x,
+                top: newSize[0].y,
+                windowSize: {
+                    height: window.innerHeight,
+                    width: window.innerWidth,
+                },
+            });
+        });
+    }, [options.shouldApplyCssTransforms]);
+    const updateSize = useCallback(() => {
+        if (!ref.current) {
+            return;
+        }
+        const rect = ref.current.getClientRects();
+        if (!rect[0]) {
+            setSize(null);
+            return;
+        }
+        setSize((prevState) => {
+            const isSame = prevState &&
+                prevState.width === rect[0].width &&
+                prevState.height === rect[0].height &&
+                prevState.left === rect[0].x &&
+                prevState.top === rect[0].y &&
+                prevState.windowSize.height === window.innerHeight &&
+                prevState.windowSize.width === window.innerWidth;
+            if (isSame) {
+                return prevState;
+            }
+            return {
+                width: rect[0].width,
+                height: rect[0].height,
+                left: rect[0].x,
+                top: rect[0].y,
+                windowSize: {
+                    height: window.innerHeight,
+                    width: window.innerWidth,
+                },
+            };
+        });
+    }, [ref]);
+    useEffect(() => {
+        if (!observer) {
+            return;
+        }
+        const { current } = ref;
+        if (ref.current) {
+            observer.observe(ref.current);
+        }
+        return () => {
+            if (current) {
+                observer.unobserve(current);
+            }
+        };
+    }, [observer, ref, updateSize]);
+    useEffect(() => {
+        if (!options.triggerOnWindowResize) {
+            return;
+        }
+        window.addEventListener('resize', updateSize);
+        return () => {
+            window.removeEventListener('resize', updateSize);
+        };
+    }, [options.triggerOnWindowResize, updateSize]);
+    useEffect(() => {
+        elementSizeHooks.push(updateSize);
+        return () => {
+            elementSizeHooks = elementSizeHooks.filter((e) => e !== updateSize);
+        };
+    }, [updateSize]);
+    return useMemo(() => {
+        if (!size) {
+            return null;
+        }
+        return { ...size, refresh: updateSize };
+    }, [size, updateSize]);
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/validate-in-out-frame.d.ts

@@ -0,0 +1,6 @@
+export declare const validateSingleFrame: (frame: unknown, variableName: string) => number | null;
+export declare const validateInOutFrames: ({ inFrame, durationInFrames, outFrame, }: {
+    inFrame: unknown;
+    outFrame: unknown;
+    durationInFrames: number;
+}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/validate-in-out-frame.js

@@ -0,0 +1,49 @@
+export const validateSingleFrame = (frame, variableName) => {
+    if (typeof frame === 'undefined' || frame === null) {
+        return frame !== null && frame !== void 0 ? frame : null;
+    }
+    if (typeof frame !== 'number') {
+        throw new TypeError(`"${variableName}" must be a number, but is ${JSON.stringify(frame)}`);
+    }
+    if (Number.isNaN(frame)) {
+        throw new TypeError(`"${variableName}" must not be NaN, but is ${JSON.stringify(frame)}`);
+    }
+    if (!Number.isFinite(frame)) {
+        throw new TypeError(`"${variableName}" must be finite, but is ${JSON.stringify(frame)}`);
+    }
+    if (frame % 1 !== 0) {
+        throw new TypeError(`"${variableName}" must be an integer, but is ${JSON.stringify(frame)}`);
+    }
+    return frame;
+};
+export const validateInOutFrames = ({ inFrame, durationInFrames, outFrame, }) => {
+    const validatedInFrame = validateSingleFrame(inFrame, 'inFrame');
+    const validatedOutFrame = validateSingleFrame(outFrame, 'outFrame');
+    if (validatedInFrame === null && validatedOutFrame === null) {
+        return;
+    }
+    // Must not be over the duration
+    if (validatedInFrame !== null && validatedInFrame > durationInFrames - 1) {
+        throw new Error('inFrame must be less than (durationInFrames - 1), but is ' +
+            validatedInFrame);
+    }
+    if (validatedOutFrame !== null && validatedOutFrame > durationInFrames - 1) {
+        throw new Error('outFrame must be less than (durationInFrames - 1), but is ' +
+            validatedOutFrame);
+    }
+    // Must not be under 0
+    if (validatedInFrame !== null && validatedInFrame < 0) {
+        throw new Error('inFrame must be greater than 0, but is ' + validatedInFrame);
+    }
+    if (validatedOutFrame !== null && validatedOutFrame <= 0) {
+        throw new Error(`outFrame must be greater than 0, but is ${validatedOutFrame}. If you want to render a single frame, use <Thumbnail /> instead.`);
+    }
+    if (validatedOutFrame !== null &&
+        validatedInFrame !== null &&
+        validatedOutFrame <= validatedInFrame) {
+        throw new Error('outFrame must be greater than inFrame, but is ' +
+            validatedOutFrame +
+            ' <= ' +
+            validatedInFrame);
+    }
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/validate-initial-frame.d.ts

@@ -0,0 +1,4 @@
+export declare const validateInitialFrame: ({ initialFrame, durationInFrames, }: {
+    initialFrame: unknown;
+    durationInFrames: unknown;
+}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/utils/validate-initial-frame.js

@@ -0,0 +1,23 @@
+export const validateInitialFrame = ({ initialFrame, durationInFrames, }) => {
+    if (typeof durationInFrames !== 'number') {
+        throw new Error(`\`durationInFrames\` must be a number, but is ${JSON.stringify(durationInFrames)}`);
+    }
+    if (typeof initialFrame === 'undefined') {
+        return;
+    }
+    if (typeof initialFrame !== 'number') {
+        throw new Error(`\`initialFrame\` must be a number, but is ${JSON.stringify(initialFrame)}`);
+    }
+    if (Number.isNaN(initialFrame)) {
+        throw new Error(`\`initialFrame\` must be a number, but is NaN`);
+    }
+    if (!Number.isFinite(initialFrame)) {
+        throw new Error(`\`initialFrame\` must be a number, but is Infinity`);
+    }
+    if (initialFrame % 1 !== 0) {
+        throw new Error(`\`initialFrame\` must be an integer, but is ${JSON.stringify(initialFrame)}`);
+    }
+    if (initialFrame > durationInFrames - 1) {
+        throw new Error(`\`initialFrame\` must be less or equal than \`durationInFrames - 1\`, but is ${JSON.stringify(initialFrame)}`);
+    }
+};