remotion 3.3.51 → 3.3.52

package/dist/loading-indicator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loading = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const AbsoluteFill_1 = require("./AbsoluteFill");
+const rotate = {
+    transform: `rotate(90deg)`,
+};
+const ICON_SIZE = 40;
+const label = {
+    color: '#555',
+    fontSize: 14,
+    fontFamily: 'sans-serif',
+};
+const container = {
+    justifyContent: 'center',
+    alignItems: 'center',
+};
+const Loading = () => {
+    return ((0, jsx_runtime_1.jsxs)(AbsoluteFill_1.AbsoluteFill, { style: container, id: "remotion-comp-loading", children: [(0, jsx_runtime_1.jsx)("style", { type: "text/css", children: `
+				@keyframes anim {
+					from {
+						opacity: 0
+					}
+					to {
+						opacity: 1
+					}
+				}
+				#remotion-comp-loading {
+					animation: anim 2s;
+					animation-fill-mode: forwards;
+				}
+			` }), (0, jsx_runtime_1.jsx)("svg", { width: ICON_SIZE, height: ICON_SIZE, viewBox: "-100 -100 400 400", style: rotate, children: (0, jsx_runtime_1.jsx)("path", { fill: "#555", stroke: "#555", strokeWidth: "100", strokeLinejoin: "round", d: "M 2 172 a 196 100 0 0 0 195 5 A 196 240 0 0 0 100 2.259 A 196 240 0 0 0 2 172 z" }) }), (0, jsx_runtime_1.jsx)("p", { style: label, children: "Loading..." })] }));
+};
+exports.Loading = Loading;

package/dist/loop/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LayoutAndStyle } from '../Sequence';
+export declare type LoopProps = {
+    durationInFrames: number;
+    times?: number;
+    name?: string;
+    children: React.ReactNode;
+} & LayoutAndStyle;
+export declare const Loop: React.FC<LoopProps>;

package/dist/loop/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loop = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const Sequence_1 = require("../Sequence");
+const use_video_config_1 = require("../use-video-config");
+const validate_duration_in_frames_1 = require("../validation/validate-duration-in-frames");
+const Loop = ({ durationInFrames, times = Infinity, children, name, ...props }) => {
+    const { durationInFrames: compDuration } = (0, use_video_config_1.useVideoConfig)();
+    (0, validate_duration_in_frames_1.validateDurationInFrames)(durationInFrames, 'of the <Loop /> component');
+    if (typeof times !== 'number') {
+        throw new TypeError(`You passed to "times" an argument of type ${typeof times}, but it must be a number.`);
+    }
+    if (times !== Infinity && times % 1 !== 0) {
+        throw new TypeError(`The "times" prop of a loop must be an integer, but got ${times}.`);
+    }
+    if (times < 0) {
+        throw new TypeError(`The "times" prop of a loop must be at least 0, but got ${times}`);
+    }
+    const maxTimes = Math.ceil(compDuration / durationInFrames);
+    const actualTimes = Math.min(maxTimes, times);
+    const style = props.layout === 'none' ? undefined : props.style;
+    return ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: new Array(actualTimes).fill(true).map((_, i) => {
+            return ((0, jsx_runtime_1.jsx)(Sequence_1.Sequence
+            // eslint-disable-next-line react/no-array-index-key
+            , { durationInFrames: durationInFrames, from: i * durationInFrames, name: name, showLoopTimesInTimeline: actualTimes, showInTimeline: i === 0, layout: props.layout, style: style, children: children }, `loop-${i}`));
+        }) }));
+};
+exports.Loop = Loop;

package/dist/multiple-versions-warning.d.ts

@@ -0,0 +1 @@
+export declare const checkMultipleRemotionVersions: () => void;

package/dist/multiple-versions-warning.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMultipleRemotionVersions = void 0;
+const truthy_1 = require("./truthy");
+const version_1 = require("./version");
+const checkMultipleRemotionVersions = () => {
+    if (typeof globalThis === 'undefined') {
+        return;
+    }
+    const alreadyImported = globalThis.remotion_imported ||
+        (typeof window !== 'undefined' && window.remotion_imported);
+    if (alreadyImported) {
+        if (typeof window === 'undefined' && alreadyImported === version_1.VERSION) {
+            // Next.JS will reload the package and cause a server-side warning.
+            // It's okay if this happens during SSR in developement
+            return;
+        }
+        throw new TypeError(`🚨 Multiple versions of Remotion detected: ${[
+            version_1.VERSION,
+            typeof alreadyImported === 'string'
+                ? alreadyImported
+                : 'an older version',
+        ]
+            .filter(truthy_1.truthy)
+            .join(' and ')}. This will cause things to break in an unexpected way.\nCheck that all your Remotion packages are on the same version. If your dependencies depend on Remotion, make them peer dependencies. You can also run \`npx remotion versions\` from your terminal to see which versions are mismatching.`);
+    }
+    globalThis.remotion_imported = version_1.VERSION;
+    if (typeof window !== 'undefined') {
+        window.remotion_imported = version_1.VERSION;
+    }
+};
+exports.checkMultipleRemotionVersions = checkMultipleRemotionVersions;

package/dist/nonce.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare type TNonceContext = {
+    getNonce: () => number;
+    fastRefreshes: number;
+};
+export declare const NonceContext: import("react").Context<TNonceContext>;
+export declare const useNonce: () => number;

package/dist/nonce.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNonce = exports.NonceContext = void 0;
+const react_1 = require("react");
+exports.NonceContext = (0, react_1.createContext)({
+    getNonce: () => 0,
+    fastRefreshes: 0,
+});
+const useNonce = () => {
+    const context = (0, react_1.useContext)(exports.NonceContext);
+    const [nonce, setNonce] = (0, react_1.useState)(() => context.getNonce());
+    (0, react_1.useEffect)(() => {
+        setNonce(context.getNonce);
+    }, [context]);
+    return nonce;
+};
+exports.useNonce = useNonce;

package/dist/play-and-handle-not-allowed-error.d.ts

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

package/dist/play-and-handle-not-allowed-error.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playAndHandleNotAllowedError = void 0;
+const playAndHandleNotAllowedError = (mediaRef, mediaType) => {
+    const { current } = mediaRef;
+    if (!current) {
+        return;
+    }
+    const prom = current.play();
+    if (prom.catch) {
+        prom.catch((err) => {
+            if (!current) {
+                return;
+            }
+            // Pause was called after play in Chrome
+            if (err.message.includes('request was interrupted by a call to pause')) {
+                return;
+            }
+            // Pause was called after play in Safari
+            if (err.message.includes('The operation was aborted.')) {
+                return;
+            }
+            // Pause was called after play in Firefox
+            if (err.message.includes('The fetching process for the media resource was aborted by the user agent')) {
+                return;
+            }
+            // Got replaced by a different audio source in Chromium
+            if (err.message.includes('request was interrupted by a new load request')) {
+                return;
+            }
+            // Audio tag got unmounted
+            if (err.message.includes('because the media was removed from the document')) {
+                return;
+            }
+            console.log(`Could not play ${mediaType} due to following error: `, err);
+            if (!current.muted) {
+                console.log(`The video will be muted and we'll retry playing it.`, err);
+                current.muted = true;
+                current.play();
+            }
+        });
+    }
+};
+exports.playAndHandleNotAllowedError = playAndHandleNotAllowedError;

package/dist/portal-node.d.ts

@@ -0,0 +1 @@
+export declare const portalNode: () => HTMLElement;

package/dist/portal-node.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalNode = void 0;
+let _portalNode = null;
+const portalNode = () => {
+    if (!_portalNode) {
+        if (typeof document === 'undefined') {
+            throw new Error('Tried to call an API that only works in the browser from outside the browser');
+        }
+        _portalNode = document.createElement('div');
+        _portalNode.style.position = 'absolute';
+        _portalNode.style.top = '0px';
+        _portalNode.style.left = '0px';
+        _portalNode.style.right = '0px';
+        _portalNode.style.bottom = '0px';
+        _portalNode.style.width = '100%';
+        _portalNode.style.height = '100%';
+        _portalNode.style.display = 'flex';
+        _portalNode.style.flexDirection = 'column';
+    }
+    return _portalNode;
+};
+exports.portalNode = portalNode;

package/dist/prefetch-state.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare type Value = Record<string, string>;
+export declare const PreloadContext: React.Context<Value>;
+export declare const setPreloads: (updater: (p: Value) => Value) => void;
+export declare const PrefetchProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/prefetch-state.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefetchProvider = exports.setPreloads = exports.PreloadContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.PreloadContext = (0, react_1.createContext)({});
+let preloads = {};
+let updaters = [];
+const setPreloads = (updater) => {
+    preloads = updater(preloads);
+    updaters.forEach((u) => u());
+};
+exports.setPreloads = setPreloads;
+const PrefetchProvider = ({ children }) => {
+    const [_preloads, _setPreloads] = (0, react_1.useState)(() => preloads);
+    (0, react_1.useEffect)(() => {
+        const updaterFunction = () => {
+            _setPreloads(preloads);
+        };
+        updaters.push(updaterFunction);
+        return () => {
+            updaters = updaters.filter((u) => u !== updaterFunction);
+        };
+    }, []);
+    return ((0, jsx_runtime_1.jsx)(exports.PreloadContext.Provider, { value: _preloads, children: children }));
+};
+exports.PrefetchProvider = PrefetchProvider;

package/dist/prefetch.d.ts

@@ -0,0 +1,9 @@
+export declare const usePreload: (src: string) => string;
+declare type FetchAndPreload = {
+    free: () => void;
+    waitUntilDone: () => Promise<string>;
+};
+export declare const prefetch: (src: string, options?: {
+    method?: 'blob-url' | 'base64';
+}) => FetchAndPreload;
+export {};

package/dist/prefetch.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetch = exports.usePreload = void 0;
+const react_1 = require("react");
+const get_environment_1 = require("./get-environment");
+const prefetch_state_1 = require("./prefetch-state");
+const usePreload = (src) => {
+    var _a;
+    const preloads = (0, react_1.useContext)(prefetch_state_1.PreloadContext);
+    return (_a = preloads[src]) !== null && _a !== void 0 ? _a : src;
+};
+exports.usePreload = usePreload;
+const blobToBase64 = function (blob) {
+    const reader = new FileReader();
+    return new Promise((resolve, reject) => {
+        reader.onload = function () {
+            const dataUrl = reader.result;
+            resolve(dataUrl);
+        };
+        reader.onerror = (err) => {
+            return reject(err);
+        };
+        reader.readAsDataURL(blob);
+    });
+};
+const prefetch = (src, options) => {
+    var _a;
+    const method = (_a = options === null || options === void 0 ? void 0 : options.method) !== null && _a !== void 0 ? _a : 'blob-url';
+    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
+        return {
+            free: () => undefined,
+            waitUntilDone: () => Promise.resolve(src),
+        };
+    }
+    let canceled = false;
+    let objectUrl = null;
+    let resolve = () => undefined;
+    let reject = () => undefined;
+    const waitUntilDone = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const controller = new AbortController();
+    let canBeAborted = true;
+    fetch(src, {
+        signal: controller.signal,
+    })
+        .then((res) => {
+        canBeAborted = false;
+        if (canceled) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new Error(`HTTP error, status = ${res.status}`);
+        }
+        return res.blob();
+    })
+        .then((buf) => {
+        if (!buf) {
+            return;
+        }
+        if (method === 'base64') {
+            return blobToBase64(buf);
+        }
+        return URL.createObjectURL(buf);
+    })
+        .then((url) => {
+        if (canceled) {
+            return;
+        }
+        objectUrl = url;
+        (0, prefetch_state_1.setPreloads)((p) => ({
+            ...p,
+            [src]: objectUrl,
+        }));
+        resolve(objectUrl);
+    })
+        .catch((err) => {
+        reject(err);
+    });
+    return {
+        free: () => {
+            if (objectUrl) {
+                if (method === 'blob-url') {
+                    URL.revokeObjectURL(objectUrl);
+                }
+                (0, prefetch_state_1.setPreloads)((p) => {
+                    const copy = { ...p };
+                    delete copy[src];
+                    return copy;
+                });
+            }
+            else {
+                canceled = true;
+                if (canBeAborted) {
+                    try {
+                        controller.abort();
+                    }
+                    catch (e) { }
+                }
+            }
+        },
+        waitUntilDone: () => {
+            return waitUntilDone;
+        },
+    };
+};
+exports.prefetch = prefetch;

package/dist/random.d.ts

@@ -0,0 +1,7 @@
+export declare type RandomSeed = number | string | null;
+/**
+ * A deterministic pseudo-random number generator.
+ * Pass in the same seed and get the same pseudorandom number.
+ * See: https://remotion.dev/docs/random
+ */
+export declare const random: (seed: RandomSeed, dummy?: unknown) => number;

package/dist/random.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+function mulberry32(a) {
+    let t = a + 0x6d2b79f5;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+function hashCode(str) {
+    let i = 0;
+    let chr = 0;
+    let hash = 0;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+/**
+ * A deterministic pseudo-random number generator.
+ * Pass in the same seed and get the same pseudorandom number.
+ * See: https://remotion.dev/docs/random
+ */
+const random = (seed, dummy) => {
+    if (dummy !== undefined) {
+        throw new TypeError('random() takes only one argument');
+    }
+    if (seed === null) {
+        return Math.random();
+    }
+    if (typeof seed === 'string') {
+        return mulberry32(hashCode(seed));
+    }
+    if (typeof seed === 'number') {
+        return mulberry32(seed * 10000000000);
+    }
+    throw new Error('random() argument must be a number or a string');
+};
+exports.random = random;

package/dist/register-root.d.ts

@@ -0,0 +1,4 @@
+import type React from 'react';
+export declare const registerRoot: (comp: React.FC) => void;
+export declare const getRoot: () => React.FC<{}> | null;
+export declare const waitForRoot: (fn: (comp: React.FC) => void) => (() => void);

package/dist/register-root.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForRoot = exports.getRoot = exports.registerRoot = void 0;
+let Root = null;
+let listeners = [];
+const registerRoot = (comp) => {
+    if (!comp) {
+        throw new Error(`You must pass a React component to registerRoot(), but ${JSON.stringify(comp)} was passed.`);
+    }
+    if (Root) {
+        throw new Error('registerRoot() was called more than once.');
+    }
+    Root = comp;
+    listeners.forEach((l) => {
+        l(comp);
+    });
+};
+exports.registerRoot = registerRoot;
+const getRoot = () => {
+    return Root;
+};
+exports.getRoot = getRoot;
+const waitForRoot = (fn) => {
+    if (Root) {
+        fn(Root);
+        return () => undefined;
+    }
+    listeners.push(fn);
+    return () => {
+        listeners = listeners.filter((l) => l !== fn);
+    };
+};
+exports.waitForRoot = waitForRoot;

package/dist/series/flatten-children.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const flattenChildren: (children: React.ReactNode) => (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment | React.ReactPortal)[];

package/dist/series/flatten-children.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenChildren = void 0;
+const react_1 = __importDefault(require("react"));
+const flattenChildren = (children) => {
+    const childrenArray = react_1.default.Children.toArray(children);
+    return childrenArray.reduce((flatChildren, child) => {
+        if (child.type === react_1.default.Fragment) {
+            return flatChildren.concat((0, exports.flattenChildren)(child.props
+                .children));
+        }
+        flatChildren.push(child);
+        return flatChildren;
+    }, []);
+};
+exports.flattenChildren = flattenChildren;

package/dist/series/index.d.ts

@@ -0,0 +1,13 @@
+import type { FC, PropsWithChildren } from 'react';
+import type { LayoutAndStyle, SequenceProps } from '../Sequence';
+declare type SeriesSequenceProps = PropsWithChildren<{
+    durationInFrames: number;
+    offset?: number;
+} & Pick<SequenceProps, 'layout' | 'name'> & LayoutAndStyle>;
+declare const SeriesSequence: import("react").ForwardRefExoticComponent<SeriesSequenceProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const Series: FC<{
+    children: React.ReactNode;
+}> & {
+    Sequence: typeof SeriesSequence;
+};
+export { Series };

package/dist/series/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Series = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const Sequence_1 = require("../Sequence");
+const validate_duration_in_frames_1 = require("../validation/validate-duration-in-frames");
+const flatten_children_1 = require("./flatten-children");
+const SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
+    // Discard ref
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
+};
+const SeriesSequence = (0, react_1.forwardRef)(SeriesSequenceRefForwardingFunction);
+const Series = ({ children }) => {
+    const childrenValue = (0, react_1.useMemo)(() => {
+        let startFrame = 0;
+        const flattenedChildren = (0, flatten_children_1.flattenChildren)(children);
+        return react_1.Children.map(flattenedChildren, (child, i) => {
+            var _a;
+            const castedChild = child;
+            if (typeof castedChild === 'string') {
+                // Don't throw if it's just some accidential whitespace
+                if (castedChild.trim() === '') {
+                    return null;
+                }
+                throw new TypeError(`The <Series /> component only accepts a list of <Series.Sequence /> components as it's children, but you passed a string "${castedChild}"`);
+            }
+            if (castedChild.type !== SeriesSequence) {
+                throw new TypeError(`The <Series /> component only accepts a list of <Series.Sequence /> components as it's children, but got ${castedChild} instead`);
+            }
+            const debugInfo = `index = ${i}, duration = ${castedChild.props.durationInFrames}`;
+            if (!castedChild || !castedChild.props.children) {
+                throw new TypeError(`A <Series.Sequence /> component (${debugInfo}) was detected to not have any children. Delete it to fix this error.`);
+            }
+            const durationInFramesProp = castedChild.props.durationInFrames;
+            const { durationInFrames, children: _children, ...passedProps } = castedChild.props;
+            if (i !== flattenedChildren.length - 1 || durationInFramesProp !== Infinity) {
+                (0, validate_duration_in_frames_1.validateDurationInFrames)(durationInFramesProp, `of a <Series.Sequence /> component`);
+            }
+            const offset = (_a = castedChild.props.offset) !== null && _a !== void 0 ? _a : 0;
+            if (Number.isNaN(offset)) {
+                throw new TypeError(`The "offset" property of a <Series.Sequence /> must not be NaN, but got NaN (${debugInfo}).`);
+            }
+            if (!Number.isFinite(offset)) {
+                throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+            }
+            if (offset % 1 !== 0) {
+                throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+            }
+            const currentStartFrame = startFrame + offset;
+            startFrame += durationInFramesProp + offset;
+            return ((0, jsx_runtime_1.jsx)(Sequence_1.Sequence, { from: currentStartFrame, durationInFrames: durationInFramesProp, ...passedProps, ref: castedChild.ref, children: child }));
+        });
+    }, [children]);
+    /* eslint-disable react/jsx-no-useless-fragment */
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: childrenValue });
+};
+exports.Series = Series;
+Series.Sequence = SeriesSequence;

package/dist/setup-env-variables.d.ts

@@ -0,0 +1,2 @@
+export declare const ENV_VARIABLES_ENV_NAME: "ENV_VARIABLES";
+export declare const setupEnvVariables: () => void;

package/dist/setup-env-variables.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupEnvVariables = exports.ENV_VARIABLES_ENV_NAME = void 0;
+const get_environment_1 = require("./get-environment");
+exports.ENV_VARIABLES_ENV_NAME = 'ENV_VARIABLES';
+const getEnvVariables = () => {
+    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
+        const param = window.remotion_envVariables;
+        if (!param) {
+            return {};
+        }
+        return { ...JSON.parse(param), NODE_ENV: process.env.NODE_ENV };
+    }
+    if ((0, get_environment_1.getRemotionEnvironment)() === 'preview') {
+        // Webpack will convert this to an object at compile time.
+        // Don't convert this syntax to a computed property.
+        return {
+            ...process.env.ENV_VARIABLES,
+            NODE_ENV: process.env.NODE_ENV,
+        };
+    }
+    throw new Error('Can only call getEnvVariables() if environment is `rendering` or `preview`');
+};
+const setupEnvVariables = () => {
+    const env = getEnvVariables();
+    if (!window.process) {
+        window.process = {};
+    }
+    if (!window.process.env) {
+        window.process.env = {};
+    }
+    Object.keys(env).forEach((key) => {
+        window.process.env[key] = env[key];
+    });
+};
+exports.setupEnvVariables = setupEnvVariables;

package/dist/spring/index.d.ts

@@ -0,0 +1,27 @@
+import type { SpringConfig } from './spring-utils';
+/**
+ * Calculates a position based on physical parameters, start and end value, and time.
+ * @link https://www.remotion.dev/docs/spring
+ * @param {number} frame The current time value. Most of the time you want to pass in the return value of useCurrentFrame.
+ * @param {number} fps The framerate at which the animation runs. Pass in the value obtained by `useVideoConfig()`.
+ * @param {?Object} config optional object that allows you to customize the physical properties of the animation.
+ * @param {number} [config.mass=1] The weight of the spring. If you reduce the mass, the animation becomes faster!
+ * @param {number} [config.damping=10] How hard the animation decelerates.
+ * @param {number} [config.stiffness=100] Affects bounciness of the animation.
+ * @param {boolean} [config.overshootClamping=false] Whether to prevent the animation going beyond the target value.
+ * @param {?number} [config.from] The initial value of the animation. Default `0`
+ * @param {?number} [config.to] The end value of the animation. Default `1`
+ * @param {?number} [config.durationInFrames] Stretch the duration of an animation to  a set value.. Default `undefined`
+ * @param {?number} [config.durationThreshold] How close to the end the animation is considered to be done. Default `0.005`
+ */
+export declare function spring({ frame, fps, config, from, to, durationInFrames, durationRestThreshold, }: {
+    frame: number;
+    fps: number;
+    config?: Partial<SpringConfig>;
+    from?: number;
+    to?: number;
+    durationInFrames?: number;
+    durationRestThreshold?: number;
+}): number;
+export { measureSpring } from './measure-spring';
+export { SpringConfig } from './spring-utils';