remotion 4.0.199 → 4.0.201

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/cancel-render.js

@@ -0,0 +1,43 @@
+const isErrorLike = (err) => {
+    if (err === null) {
+        return false;
+    }
+    if (typeof err !== 'object') {
+        return false;
+    }
+    if (!('stack' in err)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore we just asserted
+    if (typeof err.stack !== 'string') {
+        return false;
+    }
+    if (!('message' in err)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+    // @ts-ignore we just asserted
+    if (typeof err.message !== 'string') {
+        return false;
+    }
+    return true;
+};
+/**
+ * @description When you invoke this function, Remotion will stop rendering all the frames without any retries
+ * @see [Documentation](https://www.remotion.dev/docs/cancel-render)
+ */
+export function cancelRender(err) {
+    let error;
+    if (isErrorLike(err)) {
+        error = err;
+    }
+    else if (typeof err === 'string') {
+        error = Error(err);
+    }
+    else {
+        error = Error('Rendering was cancelled');
+    }
+    window.remotion_cancelledError = error.stack;
+    throw error;
+}

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

@@ -0,0 +1,4 @@
+export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "h264-ts", "gif"];
+export type Codec = (typeof validCodecs)[number];
+export type CodecOrUndefined = Codec | undefined;
+export declare const DEFAULT_CODEC: Codec;

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

@@ -0,0 +1,14 @@
+export const validCodecs = [
+    'h264',
+    'h265',
+    'vp8',
+    'vp9',
+    'mp3',
+    'aac',
+    'wav',
+    'prores',
+    'h264-mkv',
+    'h264-ts',
+    'gif',
+];
+export const DEFAULT_CODEC = 'h264';

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/config/input-props.d.ts

@@ -0,0 +1 @@
+export declare const getInputProps: <T extends Record<string, unknown> = Record<string, unknown>>() => T;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/config/input-props.js

@@ -0,0 +1,30 @@
+import { getRemotionEnvironment } from '../get-remotion-environment.js';
+import { deserializeJSONWithCustomFields } from '../input-props-serialization.js';
+let didWarnSSRImport = false;
+const warnOnceSSRImport = () => {
+    if (didWarnSSRImport) {
+        return;
+    }
+    didWarnSSRImport = true;
+    // eslint-disable-next-line no-console
+    console.warn('Called `getInputProps()` on the server. This function is not available server-side and has returned an empty object.');
+    // eslint-disable-next-line no-console
+    console.warn("To hide this warning, don't call this function on the server:");
+    // eslint-disable-next-line no-console
+    console.warn("  typeof window === 'undefined' ? {} : getInputProps()");
+};
+export const getInputProps = () => {
+    if (typeof window === 'undefined') {
+        warnOnceSSRImport();
+        return {};
+    }
+    if (getRemotionEnvironment().isPlayer) {
+        throw new Error('You cannot call `getInputProps()` from a <Player>. Instead, the props are available as React props from component that you passed as `component` prop.');
+    }
+    const param = window.remotion_inputProps;
+    if (!param) {
+        return {};
+    }
+    const parsed = deserializeJSONWithCustomFields(param);
+    return parsed;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/default-css.d.ts

@@ -0,0 +1,3 @@
+export declare const injectCSS: (css: string) => void;
+export declare const OFFTHREAD_VIDEO_CLASS_NAME = "__remotion_offthreadvideo";
+export declare const makeDefaultCSS: (scope: string | null, backgroundColor: string) => string;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/default-css.js

@@ -0,0 +1,44 @@
+const injected = {};
+export const injectCSS = (css) => {
+    // Skip in node
+    if (typeof document === 'undefined') {
+        return;
+    }
+    if (injected[css]) {
+        return;
+    }
+    const head = document.head || document.getElementsByTagName('head')[0];
+    const style = document.createElement('style');
+    style.appendChild(document.createTextNode(css));
+    head.prepend(style);
+    injected[css] = true;
+};
+export const OFFTHREAD_VIDEO_CLASS_NAME = '__remotion_offthreadvideo';
+export const makeDefaultCSS = (scope, backgroundColor) => {
+    if (!scope) {
+        return `
+    * {
+      box-sizing: border-box;
+    }
+    body {
+      margin: 0;
+	    background-color: ${backgroundColor};
+    }
+    .${OFFTHREAD_VIDEO_CLASS_NAME} {
+      object-fit: contain;
+    }
+    `;
+    }
+    return `
+    ${scope} * {
+      box-sizing: border-box;
+    }
+    ${scope} *:-webkit-full-screen {
+      width: 100%;
+      height: 100%;
+    }
+    ${scope} .${OFFTHREAD_VIDEO_CLASS_NAME} {
+      object-fit: contain;
+    }
+  `;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/delay-render.d.ts

@@ -0,0 +1,14 @@
+export declare const DELAY_RENDER_CALLSTACK_TOKEN = "The delayRender was called:";
+/**
+ * @description Call this function to tell Remotion to wait before capturing this frame until data has loaded. Use continueRender() to unblock the render.
+ * @param label _optional_ A label to identify the call in case it does time out.
+ * @returns {number} An identifier to be passed to continueRender().
+ * @see [Documentation](https://www.remotion.dev/docs/delay-render)
+ */
+export declare const delayRender: (label?: string) => number;
+/**
+ * @description Unblock a render that has been blocked by delayRender()
+ * @param handle The return value of delayRender().
+ * @see [Documentation](https://www.remotion.dev/docs/continue-render)
+ */
+export declare const continueRender: (handle: number) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/delay-render.js

@@ -0,0 +1,80 @@
+import { getRemotionEnvironment } from './get-remotion-environment.js';
+import { truthy } from './truthy.js';
+if (typeof window !== 'undefined') {
+    window.remotion_renderReady = false;
+}
+let handles = [];
+if (typeof window !== 'undefined') {
+    window.remotion_delayRenderTimeouts = {};
+}
+export const DELAY_RENDER_CALLSTACK_TOKEN = 'The delayRender was called:';
+const defaultTimeout = 30000;
+/**
+ * @description Call this function to tell Remotion to wait before capturing this frame until data has loaded. Use continueRender() to unblock the render.
+ * @param label _optional_ A label to identify the call in case it does time out.
+ * @returns {number} An identifier to be passed to continueRender().
+ * @see [Documentation](https://www.remotion.dev/docs/delay-render)
+ */
+export const delayRender = (label) => {
+    var _a, _b, _c;
+    if (typeof label !== 'string' && typeof label !== 'undefined') {
+        throw new Error('The label parameter of delayRender() must be a string or undefined, got: ' +
+            JSON.stringify(label));
+    }
+    const handle = Math.random();
+    handles.push(handle);
+    const called = (_b = (_a = Error().stack) === null || _a === void 0 ? void 0 : _a.replace(/^Error/g, '')) !== null && _b !== void 0 ? _b : '';
+    if (getRemotionEnvironment().isRendering) {
+        const timeoutToUse = typeof window === 'undefined'
+            ? defaultTimeout
+            : ((_c = window.remotion_puppeteerTimeout) !== null && _c !== void 0 ? _c : defaultTimeout) - 2000;
+        if (typeof window !== 'undefined') {
+            window.remotion_delayRenderTimeouts[handle] = {
+                label: label !== null && label !== void 0 ? label : null,
+                timeout: setTimeout(() => {
+                    const message = [
+                        `A delayRender()`,
+                        label ? `"${label}"` : null,
+                        `was called but not cleared after ${timeoutToUse}ms. See https://remotion.dev/docs/timeout for help.`,
+                        DELAY_RENDER_CALLSTACK_TOKEN,
+                        called,
+                    ]
+                        .filter(truthy)
+                        .join(' ');
+                    throw new Error(message);
+                }, timeoutToUse),
+            };
+        }
+    }
+    if (typeof window !== 'undefined') {
+        window.remotion_renderReady = false;
+    }
+    return handle;
+};
+/**
+ * @description Unblock a render that has been blocked by delayRender()
+ * @param handle The return value of delayRender().
+ * @see [Documentation](https://www.remotion.dev/docs/continue-render)
+ */
+export const continueRender = (handle) => {
+    if (typeof handle === 'undefined') {
+        throw new TypeError('The continueRender() method must be called with a parameter that is the return value of delayRender(). No value was passed.');
+    }
+    if (typeof handle !== 'number') {
+        throw new TypeError('The parameter passed into continueRender() must be the return value of delayRender() which is a number. Got: ' +
+            JSON.stringify(handle));
+    }
+    handles = handles.filter((h) => {
+        if (h === handle) {
+            if (getRemotionEnvironment().isRendering) {
+                clearTimeout(window.remotion_delayRenderTimeouts[handle].timeout);
+                delete window.remotion_delayRenderTimeouts[handle];
+            }
+            return false;
+        }
+        return true;
+    });
+    if (handles.length === 0 && typeof window !== 'undefined') {
+        window.remotion_renderReady = true;
+    }
+};

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

@@ -0,0 +1,23 @@
+/**
+ * @description The Easing module implements common easing functions. You can use it with the interpolate() API.
+ * @see [Documentation](https://www.remotion.dev/docs/easing)
+ */
+export declare class Easing {
+    static step0(n: number): number;
+    static step1(n: number): number;
+    static linear(t: number): number;
+    static ease(t: number): number;
+    static quad(t: number): number;
+    static cubic(t: number): number;
+    static poly(n: number): (t: number) => number;
+    static sin(t: number): number;
+    static circle(t: number): number;
+    static exp(t: number): number;
+    static elastic(bounciness?: number): (t: number) => number;
+    static back(s?: number): (t: number) => number;
+    static bounce(t: number): number;
+    static bezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
+    static in(easing: (t: number) => number): (t: number) => number;
+    static out(easing: (t: number) => number): (t: number) => number;
+    static inOut(easing: (t: number) => number): (t: number) => number;
+}

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

@@ -0,0 +1,77 @@
+// Taken from https://github.com/facebook/react-native/blob/0b9ea60b4fee8cacc36e7160e31b91fc114dbc0d/Libraries/Animated/src/Easing.js
+import { bezier } from './bezier.js';
+/**
+ * @description The Easing module implements common easing functions. You can use it with the interpolate() API.
+ * @see [Documentation](https://www.remotion.dev/docs/easing)
+ */
+export class Easing {
+    static step0(n) {
+        return n > 0 ? 1 : 0;
+    }
+    static step1(n) {
+        return n >= 1 ? 1 : 0;
+    }
+    static linear(t) {
+        return t;
+    }
+    static ease(t) {
+        return Easing.bezier(0.42, 0, 1, 1)(t);
+    }
+    static quad(t) {
+        return t * t;
+    }
+    static cubic(t) {
+        return t * t * t;
+    }
+    static poly(n) {
+        return (t) => t ** n;
+    }
+    static sin(t) {
+        return 1 - Math.cos((t * Math.PI) / 2);
+    }
+    static circle(t) {
+        return 1 - Math.sqrt(1 - t * t);
+    }
+    static exp(t) {
+        return 2 ** (10 * (t - 1));
+    }
+    static elastic(bounciness = 1) {
+        const p = bounciness * Math.PI;
+        return (t) => 1 - Math.cos((t * Math.PI) / 2) ** 3 * Math.cos(t * p);
+    }
+    static back(s = 1.70158) {
+        return (t) => t * t * ((s + 1) * t - s);
+    }
+    static bounce(t) {
+        if (t < 1 / 2.75) {
+            return 7.5625 * t * t;
+        }
+        if (t < 2 / 2.75) {
+            const t2_ = t - 1.5 / 2.75;
+            return 7.5625 * t2_ * t2_ + 0.75;
+        }
+        if (t < 2.5 / 2.75) {
+            const t2_ = t - 2.25 / 2.75;
+            return 7.5625 * t2_ * t2_ + 0.9375;
+        }
+        const t2 = t - 2.625 / 2.75;
+        return 7.5625 * t2 * t2 + 0.984375;
+    }
+    static bezier(x1, y1, x2, y2) {
+        return bezier(x1, y1, x2, y2);
+    }
+    static in(easing) {
+        return easing;
+    }
+    static out(easing) {
+        return (t) => 1 - easing(1 - t);
+    }
+    static inOut(easing) {
+        return (t) => {
+            if (t < 0.5) {
+                return easing(t * 2) / 2;
+            }
+            return 1 - easing((1 - t) * 2) / 2;
+        };
+    }
+}

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/enable-sequence-stack-traces.d.ts

@@ -0,0 +1,2 @@
+export declare const enableSequenceStackTraces: () => void;
+export declare const addSequenceStackTraces: (component: unknown) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/enable-sequence-stack-traces.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import { getRemotionEnvironment } from './get-remotion-environment';
+const originalCreateElement = React.createElement;
+const componentsToAddStacksTo = [];
+// Gets called when a new component is added,
+// also when the Studio is mounted
+export const enableSequenceStackTraces = () => {
+    if (!getRemotionEnvironment().isStudio) {
+        return;
+    }
+    const proxy = new Proxy(originalCreateElement, {
+        apply(target, thisArg, argArray) {
+            if (componentsToAddStacksTo.includes(argArray[0])) {
+                const [first, props, ...rest] = argArray;
+                const newProps = {
+                    ...(props !== null && props !== void 0 ? props : {}),
+                    stack: new Error().stack,
+                };
+                return Reflect.apply(target, thisArg, [first, newProps, ...rest]);
+            }
+            return Reflect.apply(target, thisArg, argArray);
+        },
+    });
+    React.createElement = proxy;
+};
+export const addSequenceStackTraces = (component) => {
+    componentsToAddStacksTo.push(component);
+    enableSequenceStackTraces();
+};

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

@@ -0,0 +1,12 @@
+import React from 'react';
+type FreezeProps = {
+    frame: number;
+    children: React.ReactNode;
+    active?: boolean | ((f: number) => boolean);
+};
+/**
+ * @description This method freezes all of its children to the frame that you specify as a prop
+ * @see [Documentation](https://www.remotion.dev/docs/freeze)
+ */
+export declare const Freeze: React.FC<FreezeProps>;
+export {};

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

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useContext, useMemo } from 'react';
+import { SequenceContext } from './SequenceContext.js';
+import { TimelineContext } from './timeline-position-state.js';
+import { useCurrentFrame } from './use-current-frame.js';
+import { useVideoConfig } from './use-video-config.js';
+/**
+ * @description This method freezes all of its children to the frame that you specify as a prop
+ * @see [Documentation](https://www.remotion.dev/docs/freeze)
+ */
+export const Freeze = ({ frame: frameToFreeze, children, active = true, }) => {
+    const frame = useCurrentFrame();
+    const videoConfig = useVideoConfig();
+    if (typeof frameToFreeze === 'undefined') {
+        throw new Error(`The <Freeze /> component requires a 'frame' prop, but none was passed.`);
+    }
+    if (typeof frameToFreeze !== 'number') {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a number, but is of type ${typeof frameToFreeze}`);
+    }
+    if (Number.isNaN(frameToFreeze)) {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a real number, but it is NaN.`);
+    }
+    if (!Number.isFinite(frameToFreeze)) {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a finite number, but it is ${frameToFreeze}.`);
+    }
+    const isActive = useMemo(() => {
+        if (typeof active === 'boolean') {
+            return active;
+        }
+        if (typeof active === 'function') {
+            return active(frame);
+        }
+    }, [active, frame]);
+    const timelineContext = useContext(TimelineContext);
+    const sequenceContext = useContext(SequenceContext);
+    const timelineValue = useMemo(() => {
+        if (!isActive) {
+            return timelineContext;
+        }
+        return {
+            ...timelineContext,
+            playing: false,
+            imperativePlaying: {
+                current: false,
+            },
+            frame: {
+                [videoConfig.id]: frameToFreeze,
+            },
+        };
+    }, [timelineContext, frameToFreeze, isActive, videoConfig.id]);
+    const sequenceValue = useMemo(() => {
+        if (isActive) {
+            return null;
+        }
+        return sequenceContext;
+    }, [isActive, sequenceContext]);
+    return (_jsx(TimelineContext.Provider, { value: timelineValue, children: _jsx(SequenceContext.Provider, { value: sequenceValue, children: children }) }));
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-asset-file-name.d.ts

@@ -0,0 +1 @@
+export declare const getAssetDisplayName: (filename: string) => string;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-asset-file-name.js

@@ -0,0 +1,10 @@
+export const getAssetDisplayName = (filename) => {
+    if (/data:|blob:/.test(filename.substring(0, 5))) {
+        return 'Data URL';
+    }
+    const splitted = filename
+        .split('/')
+        .map((s) => s.split('\\'))
+        .flat(1);
+    return splitted[splitted.length - 1];
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-preview-dom-element.d.ts

@@ -0,0 +1,2 @@
+export declare const REMOTION_STUDIO_CONTAINER_ELEMENT = "__remotion-studio-container";
+export declare const getPreviewDomElement: () => HTMLElement | null;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-preview-dom-element.js

@@ -0,0 +1,4 @@
+export const REMOTION_STUDIO_CONTAINER_ELEMENT = '__remotion-studio-container';
+export const getPreviewDomElement = () => {
+    return document.getElementById(REMOTION_STUDIO_CONTAINER_ELEMENT);
+};

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

@@ -0,0 +1,10 @@
+export type RemotionEnvironment = {
+    isStudio: boolean;
+    isRendering: boolean;
+    isPlayer: boolean;
+};
+/**
+ * @description Provides information about the Remotion Environment
+ * @see [Documentation](https://www.remotion.dev/docs/get-remotion-environment)
+ */
+export declare const getRemotionEnvironment: () => RemotionEnvironment;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-remotion-environment.js

@@ -0,0 +1,17 @@
+/**
+ * @description Provides information about the Remotion Environment
+ * @see [Documentation](https://www.remotion.dev/docs/get-remotion-environment)
+ */
+export const getRemotionEnvironment = () => {
+    const isPlayer = typeof window !== 'undefined' && window.remotion_isPlayer;
+    const isRendering = process.env.NODE_ENV === 'test' ||
+        (process.env.NODE_ENV === 'production' &&
+            typeof window !== 'undefined' &&
+            typeof window.remotion_puppeteerTimeout !== 'undefined');
+    const isStudio = typeof window !== 'undefined' && window.remotion_isStudio;
+    return {
+        isStudio,
+        isRendering,
+        isPlayer,
+    };
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-static-files.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @description The function array containing all files in the public/ folder. You can reference them by using staticFile().
+ * @see [Documentation](https://www.remotion.dev/docs/getstaticfiles)
+ */
+export declare const getStaticFiles: () => StaticFile[];
+export type StaticFile = {
+    /**
+     * A string that you can pass to the `src` attribute of an `<Audio>`, `<Img>` and `<Video>` element.
+     */
+    src: string;
+    /**
+     * The filepath of the file, relative to the public folder.
+     * Example: `subfolder/image.png`
+     */
+    name: string;
+    sizeInBytes: number;
+    /**
+     * UNIX timestamp in milliseconds
+     */
+    lastModified: number;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/get-static-files.js

@@ -0,0 +1,33 @@
+let warnedServer = false;
+let warnedPlayer = false;
+const warnServerOnce = () => {
+    if (warnedServer) {
+        return;
+    }
+    warnedServer = true;
+    // eslint-disable-next-line no-console
+    console.warn('Called getStaticFiles() on the server. The API is only available in the browser. An empty array was returned.');
+};
+const warnPlayerOnce = () => {
+    if (warnedPlayer) {
+        return;
+    }
+    warnedPlayer = true;
+    // eslint-disable-next-line no-console
+    console.warn('Called getStaticFiles() while using the Remotion Player. The API is only available while using the Remotion Studio. An empty array was returned.');
+};
+/**
+ * @description The function array containing all files in the public/ folder. You can reference them by using staticFile().
+ * @see [Documentation](https://www.remotion.dev/docs/getstaticfiles)
+ */
+export const getStaticFiles = () => {
+    if (typeof document === 'undefined') {
+        warnServerOnce();
+        return [];
+    }
+    if (window.remotion_isPlayer) {
+        warnPlayerOnce();
+        return [];
+    }
+    return window.remotion_staticFiles;
+};