remotion 4.0.199 → 4.0.201

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/multiple-versions-warning.js

@@ -0,0 +1,28 @@
+import { truthy } from './truthy.js';
+import { VERSION } from './version.js';
+export const checkMultipleRemotionVersions = () => {
+    if (typeof globalThis === 'undefined') {
+        return;
+    }
+    const alreadyImported = globalThis.remotion_imported ||
+        (typeof window !== 'undefined' && window.remotion_imported);
+    if (alreadyImported) {
+        if (alreadyImported === 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,
+            typeof alreadyImported === 'string'
+                ? alreadyImported
+                : 'an older version',
+        ]
+            .filter(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;
+    if (typeof window !== 'undefined') {
+        window.remotion_imported = VERSION;
+    }
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/no-react.d.ts

@@ -0,0 +1,43 @@
+export type { TRenderAsset } from './CompositionManager';
+export { EasingFunction, ExtrapolateType, interpolate, InterpolateOptions, } from './interpolate';
+export type { ClipRegion } from './NativeLayers';
+export { random, RandomSeed } from './random.js';
+export type { VideoConfig } from './video-config';
+import { processColor } from './interpolate-colors';
+import { truthy } from './truthy';
+import { validateDimension } from './validation/validate-dimensions';
+import { validateDurationInFrames } from './validation/validate-duration-in-frames';
+import { validateFps } from './validation/validate-fps';
+export declare const NoReactInternals: {
+    processColor: typeof processColor;
+    truthy: typeof truthy;
+    validateFps: typeof validateFps;
+    validateDimension: typeof validateDimension;
+    validateDurationInFrames: typeof validateDurationInFrames;
+    validateDefaultAndInputProps: (defaultProps: unknown, name: "defaultProps" | "inputProps", compositionId: string | null) => void;
+    validateFrame: ({ allowFloats, durationInFrames, frame, }: {
+        frame: number;
+        durationInFrames: number;
+        allowFloats: boolean;
+    }) => void;
+    serializeJSONWithDate: ({ data, indent, staticBase, }: {
+        data: Record<string, unknown>;
+        indent: number | undefined;
+        staticBase: string | null;
+    }) => import("./input-props-serialization").SerializedJSONWithCustomFields;
+    bundleName: string;
+    bundleMapName: string;
+    deserializeJSONWithCustomFields: <T = Record<string, unknown>>(data: string) => T;
+    DELAY_RENDER_CALLSTACK_TOKEN: string;
+    getOffthreadVideoSource: ({ src, transparent, currentTime, toneMapped, }: {
+        src: string;
+        transparent: boolean;
+        currentTime: number;
+        toneMapped: boolean;
+    }) => string;
+    getExpectedMediaFrameUncorrected: ({ frame, playbackRate, startFrom, }: {
+        frame: number;
+        playbackRate: number;
+        startFrom: number;
+    }) => number;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/no-react.js

@@ -0,0 +1,29 @@
+export { interpolate, } from './interpolate';
+export { random } from './random.js';
+import { DELAY_RENDER_CALLSTACK_TOKEN } from './delay-render';
+import { deserializeJSONWithCustomFields, serializeJSONWithDate, } from './input-props-serialization';
+import { processColor } from './interpolate-colors';
+import { truthy } from './truthy';
+import { validateFrame } from './validate-frame';
+import { validateDefaultAndInputProps } from './validation/validate-default-props';
+import { validateDimension } from './validation/validate-dimensions';
+import { validateDurationInFrames } from './validation/validate-duration-in-frames';
+import { validateFps } from './validation/validate-fps';
+import { getExpectedMediaFrameUncorrected } from './video/get-current-time';
+import { getOffthreadVideoSource } from './video/offthread-video-source';
+export const NoReactInternals = {
+    processColor,
+    truthy,
+    validateFps,
+    validateDimension,
+    validateDurationInFrames,
+    validateDefaultAndInputProps,
+    validateFrame,
+    serializeJSONWithDate,
+    bundleName: 'bundle.js',
+    bundleMapName: 'bundle.js.map',
+    deserializeJSONWithCustomFields,
+    DELAY_RENDER_CALLSTACK_TOKEN,
+    getOffthreadVideoSource,
+    getExpectedMediaFrameUncorrected,
+};

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

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

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

@@ -0,0 +1,19 @@
+import { createContext, useContext, useEffect, useRef, useState } from 'react';
+export const NonceContext = createContext({
+    getNonce: () => 0,
+    fastRefreshes: 0,
+});
+export const useNonce = () => {
+    const context = useContext(NonceContext);
+    const [nonce, setNonce] = useState(() => context.getNonce());
+    const lastContext = useRef(context);
+    // Only if context changes, but not initially
+    useEffect(() => {
+        if (lastContext.current === context) {
+            return;
+        }
+        lastContext.current = context;
+        setNonce(context.getNonce);
+    }, [context]);
+    return nonce;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/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/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/play-and-handle-not-allowed-error.js

@@ -0,0 +1,42 @@
+export 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;
+            }
+            // eslint-disable-next-line no-console
+            console.log(`Could not play ${mediaType} due to following error: `, err);
+            if (!current.muted) {
+                // eslint-disable-next-line no-console
+                console.log(`The video will be muted and we'll retry playing it.`, err);
+                current.muted = true;
+                current.play();
+            }
+        });
+    }
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/portal-node.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/portal-node.js

@@ -0,0 +1,24 @@
+let _portalNode = null;
+export 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';
+        const containerNode = document.createElement('div');
+        containerNode.style.position = 'fixed';
+        containerNode.style.top = -999999 + 'px';
+        containerNode.appendChild(_portalNode);
+        document.body.appendChild(containerNode);
+    }
+    return _portalNode;
+};

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

@@ -0,0 +1,8 @@
+import React from 'react';
+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/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/prefetch-state.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useState } from 'react';
+export const PreloadContext = createContext({});
+let preloads = {};
+let updaters = [];
+export const setPreloads = (updater) => {
+    preloads = updater(preloads);
+    updaters.forEach((u) => u());
+};
+export const PrefetchProvider = ({ children }) => {
+    const [_preloads, _setPreloads] = useState(() => preloads);
+    useEffect(() => {
+        const updaterFunction = () => {
+            _setPreloads(preloads);
+        };
+        updaters.push(updaterFunction);
+        return () => {
+            updaters = updaters.filter((u) => u !== updaterFunction);
+        };
+    }, []);
+    return (_jsx(PreloadContext.Provider, { value: _preloads, children: children }));
+};

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

@@ -0,0 +1,19 @@
+export declare const usePreload: (src: string) => string;
+type FetchAndPreload = {
+    free: () => void;
+    waitUntilDone: () => Promise<string>;
+};
+export type PrefetchOnProgress = (options: {
+    totalBytes: number | null;
+    loadedBytes: number;
+}) => void;
+/**
+ * @description When you call the preFetch() function, an asset will be fetched and kept in memory so it is ready when you want to play it in a <Player>.
+ * @see [Documentation](https://www.remotion.dev/docs/prefetch)
+ */
+export declare const prefetch: (src: string, options?: {
+    method?: 'blob-url' | 'base64';
+    contentType?: string;
+    onProgress?: PrefetchOnProgress;
+}) => FetchAndPreload;
+export {};

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

@@ -0,0 +1,157 @@
+import { useContext } from 'react';
+import { getRemotionEnvironment } from './get-remotion-environment.js';
+import { PreloadContext, setPreloads } from './prefetch-state.js';
+export const usePreload = (src) => {
+    var _a;
+    const preloads = useContext(PreloadContext);
+    return (_a = preloads[src]) !== null && _a !== void 0 ? _a : src;
+};
+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 getBlobFromReader = async ({ reader, contentType, contentLength, onProgress, }) => {
+    let receivedLength = 0;
+    const chunks = [];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        receivedLength += value.length;
+        if (onProgress) {
+            onProgress({ loadedBytes: receivedLength, totalBytes: contentLength });
+        }
+    }
+    const chunksAll = new Uint8Array(receivedLength);
+    let position = 0;
+    for (const chunk of chunks) {
+        chunksAll.set(chunk, position);
+        position += chunk.length;
+    }
+    return new Blob([chunksAll], {
+        type: contentType !== null && contentType !== void 0 ? contentType : undefined,
+    });
+};
+/**
+ * @description When you call the preFetch() function, an asset will be fetched and kept in memory so it is ready when you want to play it in a <Player>.
+ * @see [Documentation](https://www.remotion.dev/docs/prefetch)
+ */
+export 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 (getRemotionEnvironment().isRendering) {
+        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) => {
+        var _a, _b, _c;
+        canBeAborted = false;
+        if (canceled) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new Error(`HTTP error, status = ${res.status}`);
+        }
+        const headerContentType = res.headers.get('Content-Type');
+        const contentType = (_a = options === null || options === void 0 ? void 0 : options.contentType) !== null && _a !== void 0 ? _a : headerContentType;
+        const hasProperContentType = contentType &&
+            (contentType.startsWith('video/') ||
+                contentType.startsWith('audio/') ||
+                contentType.startsWith('image/'));
+        if (!hasProperContentType) {
+            // eslint-disable-next-line no-console
+            console.warn(`Called prefetch() on ${src} which returned a "Content-Type" of ${headerContentType}. Prefetched content should have a proper content type (video/... or audio/...) or a contentType passed the options of prefetch(). Otherwise, prefetching will not work properly in all browsers.`);
+        }
+        if (!res.body) {
+            throw new Error(`HTTP response of ${src} has no body`);
+        }
+        const reader = res.body.getReader();
+        return getBlobFromReader({
+            reader,
+            contentType: (_c = (_b = options === null || options === void 0 ? void 0 : options.contentType) !== null && _b !== void 0 ? _b : headerContentType) !== null && _c !== void 0 ? _c : null,
+            contentLength: res.headers.get('Content-Length')
+                ? parseInt(res.headers.get('Content-Length'), 10)
+                : null,
+            onProgress: options === null || options === void 0 ? void 0 : options.onProgress,
+        });
+    })
+        .then((buf) => {
+        if (!buf) {
+            return;
+        }
+        const actualBlob = (options === null || options === void 0 ? void 0 : options.contentType)
+            ? new Blob([buf], { type: options.contentType })
+            : buf;
+        if (method === 'base64') {
+            return blobToBase64(actualBlob);
+        }
+        return URL.createObjectURL(actualBlob);
+    })
+        .then((url) => {
+        if (canceled) {
+            return;
+        }
+        objectUrl = url;
+        setPreloads((p) => ({
+            ...p,
+            [src]: objectUrl,
+        }));
+        resolve(objectUrl);
+    })
+        .catch((err) => {
+        reject(err);
+    });
+    return {
+        free: () => {
+            if (objectUrl) {
+                if (method === 'blob-url') {
+                    URL.revokeObjectURL(objectUrl);
+                }
+                setPreloads((p) => {
+                    const copy = { ...p };
+                    delete copy[src];
+                    return copy;
+                });
+            }
+            else {
+                canceled = true;
+                if (canBeAborted) {
+                    try {
+                        controller.abort();
+                    }
+                    catch (e) { }
+                }
+            }
+        },
+        waitUntilDone: () => {
+            return waitUntilDone;
+        },
+    };
+};

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

@@ -0,0 +1,10 @@
+import type { AnyZodObject, z } from 'zod';
+type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
+export type PropsIfHasProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = And<AnyZodObject extends Schema ? true : false, {} extends Props ? true : false> extends true ? {
+    defaultProps?: {};
+} : {
+    defaultProps: InferProps<Schema, Props>;
+};
+export type InferProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = AnyZodObject extends Schema ? {} extends Props ? Record<string, unknown> : Props : {} extends Props ? z.input<Schema> : // Props and schema specified
+z.input<Schema> & Props;
+export {};

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

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

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

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

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

@@ -0,0 +1,37 @@
+/* eslint-disable no-bitwise */
+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;
+}
+/**
+ * @description A deterministic pseudo-random number generator. Pass in the same seed and get the same pseudorandom number.
+ * @see [Documentation](https://remotion.dev/docs/random)
+ */
+export 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');
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/register-root.d.ts

@@ -0,0 +1,8 @@
+import type React from 'react';
+/**
+ * @description This function registers the root component of the Remotion project
+ * @see [Documentation](https://www.remotion.dev/docs/register-root)
+ */
+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/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/register-root.js

@@ -0,0 +1,31 @@
+let Root = null;
+let listeners = [];
+/**
+ * @description This function registers the root component of the Remotion project
+ * @see [Documentation](https://www.remotion.dev/docs/register-root)
+ */
+export 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);
+    });
+};
+export const getRoot = () => {
+    return Root;
+};
+export const waitForRoot = (fn) => {
+    if (Root) {
+        fn(Root);
+        return () => undefined;
+    }
+    listeners.push(fn);
+    return () => {
+        listeners = listeners.filter((l) => l !== fn);
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { AnyZodObject } from 'zod';
+import type { TCompMetadataWithCalcFunction } from './CompositionManager.js';
+import type { VideoConfig } from './video-config.js';
+export declare const resolveVideoConfig: ({ composition, editorProps: editorPropsOrUndefined, signal, inputProps, }: {
+    composition: TCompMetadataWithCalcFunction<AnyZodObject, Record<string, unknown>>;
+    editorProps: object;
+    signal: AbortSignal;
+    inputProps: Record<string, unknown>;
+}) => VideoConfig | Promise<VideoConfig>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/resolve-video-config.js

@@ -0,0 +1,80 @@
+import { validateDefaultCodec } from './validation/validate-default-codec.js';
+import { validateDimension } from './validation/validate-dimensions.js';
+import { validateDurationInFrames } from './validation/validate-duration-in-frames.js';
+import { validateFps } from './validation/validate-fps.js';
+const validateCalculated = ({ composition, calculated, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const calculateMetadataErrorLocation = `calculated by calculateMetadata() for the composition "${composition.id}"`;
+    const defaultErrorLocation = `of the "<Composition />" component with the id "${composition.id}"`;
+    const width = (_b = (_a = calculated === null || calculated === void 0 ? void 0 : calculated.width) !== null && _a !== void 0 ? _a : composition.width) !== null && _b !== void 0 ? _b : undefined;
+    validateDimension(width, 'width', (calculated === null || calculated === void 0 ? void 0 : calculated.width) ? calculateMetadataErrorLocation : defaultErrorLocation);
+    const height = (_d = (_c = calculated === null || calculated === void 0 ? void 0 : calculated.height) !== null && _c !== void 0 ? _c : composition.height) !== null && _d !== void 0 ? _d : undefined;
+    validateDimension(height, 'height', (calculated === null || calculated === void 0 ? void 0 : calculated.height) ? calculateMetadataErrorLocation : defaultErrorLocation);
+    const fps = (_f = (_e = calculated === null || calculated === void 0 ? void 0 : calculated.fps) !== null && _e !== void 0 ? _e : composition.fps) !== null && _f !== void 0 ? _f : null;
+    validateFps(fps, (calculated === null || calculated === void 0 ? void 0 : calculated.fps) ? calculateMetadataErrorLocation : defaultErrorLocation, false);
+    const durationInFrames = (_h = (_g = calculated === null || calculated === void 0 ? void 0 : calculated.durationInFrames) !== null && _g !== void 0 ? _g : composition.durationInFrames) !== null && _h !== void 0 ? _h : null;
+    validateDurationInFrames(durationInFrames, {
+        allowFloats: false,
+        component: `of the "<Composition />" component with the id "${composition.id}"`,
+    });
+    const defaultCodec = calculated === null || calculated === void 0 ? void 0 : calculated.defaultCodec;
+    validateDefaultCodec(defaultCodec, calculateMetadataErrorLocation);
+    return { width, height, fps, durationInFrames, defaultCodec };
+};
+export const resolveVideoConfig = ({ composition, editorProps: editorPropsOrUndefined, signal, inputProps, }) => {
+    var _a, _b, _c, _d, _e, _f;
+    const originalProps = {
+        ...((_a = composition.defaultProps) !== null && _a !== void 0 ? _a : {}),
+        ...(editorPropsOrUndefined !== null && editorPropsOrUndefined !== void 0 ? editorPropsOrUndefined : {}),
+        ...(inputProps !== null && inputProps !== void 0 ? inputProps : {}),
+    };
+    const calculatedProm = composition.calculateMetadata
+        ? composition.calculateMetadata({
+            defaultProps: (_b = composition.defaultProps) !== null && _b !== void 0 ? _b : {},
+            props: originalProps,
+            abortSignal: signal,
+            compositionId: composition.id,
+        })
+        : null;
+    if (calculatedProm !== null &&
+        typeof calculatedProm === 'object' &&
+        'then' in calculatedProm) {
+        return calculatedProm.then((c) => {
+            var _a, _b;
+            const { height, width, durationInFrames, fps, defaultCodec } = validateCalculated({
+                calculated: c,
+                composition,
+            });
+            return {
+                width,
+                height,
+                fps,
+                durationInFrames,
+                id: composition.id,
+                defaultProps: (_a = composition.defaultProps) !== null && _a !== void 0 ? _a : {},
+                props: (_b = c.props) !== null && _b !== void 0 ? _b : originalProps,
+                defaultCodec: defaultCodec !== null && defaultCodec !== void 0 ? defaultCodec : null,
+            };
+        });
+    }
+    const data = validateCalculated({
+        calculated: calculatedProm,
+        composition,
+    });
+    if (calculatedProm === null) {
+        return {
+            ...data,
+            id: composition.id,
+            defaultProps: (_c = composition.defaultProps) !== null && _c !== void 0 ? _c : {},
+            props: originalProps,
+            defaultCodec: null,
+        };
+    }
+    return {
+        ...data,
+        id: composition.id,
+        defaultProps: (_d = composition.defaultProps) !== null && _d !== void 0 ? _d : {},
+        props: (_e = calculatedProm.props) !== null && _e !== void 0 ? _e : originalProps,
+        defaultCodec: (_f = calculatedProm.defaultCodec) !== null && _f !== void 0 ? _f : null,
+    };
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/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>> | Iterable<React.ReactNode> | React.ReactPortal)[];

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/series/flatten-children.js

@@ -0,0 +1,12 @@
+import React from 'react';
+export const flattenChildren = (children) => {
+    const childrenArray = React.Children.toArray(children);
+    return childrenArray.reduce((flatChildren, child) => {
+        if (child.type === React.Fragment) {
+            return flatChildren.concat(flattenChildren(child.props
+                .children));
+        }
+        flatChildren.push(child);
+        return flatChildren;
+    }, []);
+};

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

@@ -0,0 +1,18 @@
+import type { FC, PropsWithChildren } from 'react';
+import type { LayoutAndStyle, SequenceProps } from '../Sequence.js';
+type SeriesSequenceProps = PropsWithChildren<{
+    durationInFrames: number;
+    offset?: number;
+    className?: string;
+} & Pick<SequenceProps, 'layout' | 'name'> & LayoutAndStyle>;
+declare const SeriesSequence: import("react").ForwardRefExoticComponent<SeriesSequenceProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * @description with this component, you can easily stitch together scenes that should play sequentially after another.
+ * @see [Documentation](https://www.remotion.dev/docs/series)
+ */
+declare const Series: FC<{
+    children: React.ReactNode;
+}> & {
+    Sequence: typeof SeriesSequence;
+};
+export { Series };