remotion 4.0.199 → 4.0.201

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

@@ -0,0 +1,123 @@
+/// <reference types="node" />
+/// <reference types="react" />
+import './asset-types.js';
+import type { Codec } from './codec.js';
+import type { TRenderAsset } from './CompositionManager.js';
+import type { StaticFile } from './get-static-files.js';
+import type { ClipRegion } from './NativeLayers.js';
+import type { VideoConfig } from './video-config.js';
+export type VideoConfigWithSerializedProps = Omit<VideoConfig, 'defaultProps' | 'props'> & {
+    serializedDefaultPropsWithCustomSchema: string;
+    serializedResolvedPropsWithCustomSchema: string;
+};
+declare global {
+    interface Window {
+        remotion_renderReady: boolean;
+        remotion_delayRenderTimeouts: {
+            [key: string]: {
+                label: string | null;
+                timeout: number | NodeJS.Timeout;
+            };
+        };
+        remotion_cancelledError: string | undefined;
+        remotion_getCompositionNames: () => string[];
+        getStaticCompositions: () => Promise<VideoConfigWithSerializedProps[]>;
+        remotion_calculateComposition: (compId: string) => Promise<VideoConfigWithSerializedProps>;
+        remotion_setBundleMode: (bundleMode: BundleState) => void;
+        remotion_staticBase: string;
+        remotion_staticFiles: StaticFile[];
+        remotion_publicFolderExists: string | null;
+        remotion_editorName: string | null;
+        remotion_numberOfAudioTags: number;
+        remotion_projectName: string;
+        remotion_cwd: string;
+        remotion_studioServerCommand: string;
+        remotion_setFrame: (frame: number, composition: string) => void;
+        remotion_initialFrame: number;
+        remotion_proxyPort: number;
+        remotion_audioEnabled: boolean;
+        remotion_videoEnabled: boolean;
+        remotion_puppeteerTimeout: number;
+        remotion_inputProps: string;
+        remotion_envVariables: string;
+        remotion_collectAssets: () => TRenderAsset[];
+        remotion_getClipRegion: () => ClipRegion | null;
+        remotion_isPlayer: boolean;
+        remotion_isStudio: boolean;
+        remotion_isBuilding: undefined | (() => void);
+        remotion_finishedBuilding: undefined | (() => void);
+        siteVersion: '10';
+        remotion_version: string;
+        remotion_imported: string | boolean;
+        remotion_unsavedProps: boolean | undefined;
+    }
+}
+export type BundleState = {
+    type: 'index';
+} | {
+    type: 'evaluation';
+} | {
+    type: 'composition';
+    compositionName: string;
+    serializedResolvedPropsWithSchema: string;
+    compositionHeight: number;
+    compositionDurationInFrames: number;
+    compositionWidth: number;
+    compositionFps: number;
+    compositionDefaultCodec: Codec;
+};
+export * from './AbsoluteFill.js';
+export * from './audio/index.js';
+export { cancelRender } from './cancel-render.js';
+export { CalculateMetadataFunction, Composition, CompositionProps, CompProps, StillProps, } from './Composition.js';
+export { AnyCompMetadata, AnyComposition, SmallTCompMetadata, TCompMetadata, TRenderAsset, } from './CompositionManager.js';
+export type { CanvasContent } from './CompositionManagerContext.js';
+export { getInputProps } from './config/input-props.js';
+export { continueRender, delayRender } from './delay-render.js';
+export * from './easing.js';
+export * from './Folder.js';
+export * from './freeze.js';
+export { getRemotionEnvironment } from './get-remotion-environment.js';
+export { getStaticFiles, StaticFile } from './get-static-files.js';
+export * from './IFrame.js';
+export { Img, ImgProps } from './Img.js';
+export * from './internals.js';
+export { interpolateColors } from './interpolate-colors.js';
+export { Loop } from './loop/index.js';
+export { ClipRegion } from './NativeLayers.js';
+export { EasingFunction, ExtrapolateType, interpolate, InterpolateOptions, random, RandomSeed, } from './no-react';
+export { prefetch, PrefetchOnProgress } from './prefetch.js';
+export { registerRoot } from './register-root.js';
+export { LayoutAndStyle, Sequence, SequenceProps, SequencePropsWithoutDuration, } from './Sequence.js';
+export { Series } from './series/index.js';
+export * from './spring/index.js';
+export { staticFile } from './static-file.js';
+export * from './Still.js';
+export type { PlayableMediaTag } from './timeline-position-state.js';
+export { useBufferState } from './use-buffer-state';
+export { useCurrentFrame } from './use-current-frame.js';
+export { CurrentScaleContextType, PreviewSize, PreviewSizeCtx, Translation, useCurrentScale, } from './use-current-scale';
+export * from './use-video-config.js';
+export * from './version.js';
+export * from './video-config.js';
+export * from './video/index.js';
+export { watchStaticFile } from './watch-static-file.js';
+export declare const Experimental: {
+    /**
+     * @description This is a special component that will cause Remotion to only partially capture the frame of the video.
+     * @see [Documentation](https://www.remotion.dev/docs/clipper)
+     */
+    Clipper: import("react").FC<{
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }>;
+    /**
+     * @description This is a special component, that, when rendered, will skip rendering the frame altogether.
+     * @see [Documentation](https://www.remotion.dev/docs/null)
+     */
+    Null: import("react").FC<{}>;
+    useIsPlayer: () => boolean;
+};
+export declare const Config: {};

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

@@ -0,0 +1,80 @@
+import './asset-types.js';
+import { Clipper } from './Clipper.js';
+import { addSequenceStackTraces } from './enable-sequence-stack-traces.js';
+import { useIsPlayer } from './is-player.js';
+import { checkMultipleRemotionVersions } from './multiple-versions-warning.js';
+import { Null } from './Null.js';
+import { Sequence } from './Sequence.js';
+checkMultipleRemotionVersions();
+export * from './AbsoluteFill.js';
+export * from './audio/index.js';
+export { cancelRender } from './cancel-render.js';
+export { Composition, } from './Composition.js';
+export { getInputProps } from './config/input-props.js';
+export { continueRender, delayRender } from './delay-render.js';
+export * from './easing.js';
+export * from './Folder.js';
+export * from './freeze.js';
+export { getRemotionEnvironment } from './get-remotion-environment.js';
+export { getStaticFiles } from './get-static-files.js';
+export * from './IFrame.js';
+export { Img } from './Img.js';
+export * from './internals.js';
+export { interpolateColors } from './interpolate-colors.js';
+export { Loop } from './loop/index.js';
+export { interpolate, random, } from './no-react';
+export { prefetch } from './prefetch.js';
+export { registerRoot } from './register-root.js';
+export { Sequence, } from './Sequence.js';
+export { Series } from './series/index.js';
+export * from './spring/index.js';
+export { staticFile } from './static-file.js';
+export * from './Still.js';
+export { useBufferState } from './use-buffer-state';
+export { useCurrentFrame } from './use-current-frame.js';
+export { useCurrentScale, } from './use-current-scale';
+export * from './use-video-config.js';
+export * from './version.js';
+export * from './video-config.js';
+export * from './video/index.js';
+export { watchStaticFile } from './watch-static-file.js';
+export const Experimental = {
+    /**
+     * @description This is a special component that will cause Remotion to only partially capture the frame of the video.
+     * @see [Documentation](https://www.remotion.dev/docs/clipper)
+     */
+    Clipper,
+    /**
+     * @description This is a special component, that, when rendered, will skip rendering the frame altogether.
+     * @see [Documentation](https://www.remotion.dev/docs/null)
+     */
+    Null,
+    useIsPlayer,
+};
+const proxyObj = {};
+export const Config = new Proxy(proxyObj, {
+    get(_, prop) {
+        if (prop === 'Bundling' ||
+            prop === 'Rendering' ||
+            prop === 'Log' ||
+            prop === 'Puppeteer' ||
+            prop === 'Output') {
+            return Config;
+        }
+        return () => {
+            /* eslint-disable no-console */
+            console.warn('⚠️  The CLI configuration has been extracted from Remotion Core.');
+            console.warn('Update the import from the config file:');
+            console.warn();
+            console.warn('- Delete:');
+            console.warn('import {Config} from "remotion";');
+            console.warn('+ Replace:');
+            console.warn('import {Config} from "@remotion/cli/config";');
+            console.warn();
+            console.warn('For more information, see https://www.remotion.dev/docs/4-0-migration.');
+            /* eslint-enable no-console */
+            process.exit(1);
+        };
+    },
+});
+addSequenceStackTraces(Sequence);

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

@@ -0,0 +1,15 @@
+export type SerializedJSONWithCustomFields = {
+    serializedString: string;
+    customDateUsed: boolean;
+    customFileUsed: boolean;
+    mapUsed: boolean;
+    setUsed: boolean;
+};
+export declare const DATE_TOKEN = "remotion-date:";
+export declare const FILE_TOKEN = "remotion-file:";
+export declare const serializeJSONWithDate: ({ data, indent, staticBase, }: {
+    data: Record<string, unknown>;
+    indent: number | undefined;
+    staticBase: string | null;
+}) => SerializedJSONWithCustomFields;
+export declare const deserializeJSONWithCustomFields: <T = Record<string, unknown>>(data: string) => T;

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

@@ -0,0 +1,44 @@
+// Must keep this file in sync with the one in packages/lambda/src/shared/serialize-props.ts!
+import { staticFile } from './static-file.js';
+export const DATE_TOKEN = 'remotion-date:';
+export const FILE_TOKEN = 'remotion-file:';
+export const serializeJSONWithDate = ({ data, indent, staticBase, }) => {
+    let customDateUsed = false;
+    let customFileUsed = false;
+    let mapUsed = false;
+    let setUsed = false;
+    const serializedString = JSON.stringify(data, function (key, value) {
+        const item = this[key];
+        if (item instanceof Date) {
+            customDateUsed = true;
+            return `${DATE_TOKEN}${item.toISOString()}`;
+        }
+        if (item instanceof Map) {
+            mapUsed = true;
+            return value;
+        }
+        if (item instanceof Set) {
+            setUsed = true;
+            return value;
+        }
+        if (typeof item === 'string' &&
+            staticBase !== null &&
+            item.startsWith(staticBase)) {
+            customFileUsed = true;
+            return `${FILE_TOKEN}${item.replace(staticBase + '/', '')}`;
+        }
+        return value;
+    }, indent);
+    return { serializedString, customDateUsed, customFileUsed, mapUsed, setUsed };
+};
+export const deserializeJSONWithCustomFields = (data) => {
+    return JSON.parse(data, (_, value) => {
+        if (typeof value === 'string' && value.startsWith(DATE_TOKEN)) {
+            return new Date(value.replace(DATE_TOKEN, ''));
+        }
+        if (typeof value === 'string' && value.startsWith(FILE_TOKEN)) {
+            return staticFile(value.replace(FILE_TOKEN, ''));
+        }
+        return value;
+    });
+};

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

@@ -0,0 +1,164 @@
+/// <reference types="react" />
+import { type CompProps } from './Composition.js';
+import type { TCompMetadata, TComposition, TRenderAsset, TSequence } from './CompositionManager.js';
+import type { CompositionManagerContext } from './CompositionManagerContext.js';
+import * as CSSUtils from './default-css.js';
+import type { RemotionEnvironment } from './get-remotion-environment.js';
+import type { SerializedJSONWithCustomFields } from './input-props-serialization.js';
+import type { SetTimelineContextValue, TimelineContextValue } from './timeline-position-state.js';
+import * as TimelinePosition from './timeline-position-state.js';
+import { truthy } from './truthy.js';
+import type { MediaVolumeContextValue, SetMediaVolumeContextValue } from './volume-position-state.js';
+import type { WatchRemotionStaticFilesPayload } from './watch-static-file.js';
+import { useRemotionContexts } from './wrap-remotion-context.js';
+export declare const Internals: {
+    readonly useUnsafeVideoConfig: () => import("./video-config.js").VideoConfig | null;
+    readonly Timeline: typeof TimelinePosition;
+    readonly CompositionManager: import("react").Context<CompositionManagerContext>;
+    readonly SequenceManager: import("react").Context<import("./SequenceManager.js").SequenceManagerContext>;
+    readonly SequenceVisibilityToggleContext: import("react").Context<import("./SequenceManager.js").SequenceVisibilityToggleState>;
+    readonly RemotionRoot: import("react").FC<{
+        children: import("react").ReactNode;
+        numberOfAudioTags: number;
+    }>;
+    readonly useVideo: () => (import("./video-config.js").VideoConfig & {
+        component: import("react").LazyExoticComponent<import("react").ComponentType<Record<string, unknown>>>;
+    }) | null;
+    readonly getRoot: () => import("react").FC<{}> | null;
+    readonly useMediaVolumeState: () => readonly [number, (u: number) => void];
+    readonly useMediaMutedState: () => readonly [boolean, (u: import("react").SetStateAction<boolean>) => void];
+    readonly useLazyComponent: <Props>(compProps: CompProps<Props>) => import("react").ExoticComponent<(import("react").PropsWithoutRef<Props> & import("react").RefAttributes<import("react").Component<Props, any, any>>) | import("react").PropsWithRef<Props>> & {
+        readonly _result: import("react").ComponentType<Props>;
+    };
+    readonly truthy: typeof truthy;
+    readonly SequenceContext: import("react").Context<import("./SequenceContext.js").SequenceContextType | null>;
+    readonly useRemotionContexts: typeof useRemotionContexts;
+    readonly RemotionContextProvider: (props: import("./wrap-remotion-context.js").RemotionContextProviderProps) => import("react/jsx-runtime.js").JSX.Element;
+    readonly CSSUtils: typeof CSSUtils;
+    readonly setupEnvVariables: () => void;
+    readonly MediaVolumeContext: import("react").Context<MediaVolumeContextValue>;
+    readonly SetMediaVolumeContext: import("react").Context<SetMediaVolumeContextValue>;
+    readonly getRemotionEnvironment: () => RemotionEnvironment;
+    readonly SharedAudioContext: import("react").Context<{
+        registerAudio: (aud: import("./index.js").RemotionAudioProps, audioId: string) => {
+            id: number;
+            props: import("./index.js").RemotionAudioProps;
+            el: import("react").RefObject<HTMLAudioElement>;
+            audioId: string;
+        };
+        unregisterAudio: (id: number) => void;
+        updateAudio: (options: {
+            id: number;
+            aud: import("./index.js").RemotionAudioProps;
+            audioId: string;
+        }) => void;
+        playAllAudios: () => void;
+        numberOfAudioTags: number;
+    } | null>;
+    readonly SharedAudioContextProvider: import("react").FC<{
+        numberOfAudioTags: number;
+        children: import("react").ReactNode;
+        component: import("react").LazyExoticComponent<import("react").ComponentType<Record<string, unknown>>> | null;
+    }>;
+    readonly invalidCompositionErrorMessage: string;
+    readonly isCompositionIdValid: (id: string) => RegExpMatchArray | null;
+    readonly getPreviewDomElement: () => HTMLElement | null;
+    readonly compositionsRef: import("react").RefObject<{
+        getCompositions: () => import("./CompositionManager.js").TCompMetadataWithCalcFunction<import("zod").AnyZodObject, Record<string, unknown>>[];
+    }>;
+    readonly portalNode: () => HTMLElement;
+    readonly waitForRoot: (fn: (comp: import("react").FC<{}>) => void) => () => void;
+    readonly CanUseRemotionHooksProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    readonly CanUseRemotionHooks: import("react").Context<boolean>;
+    readonly PrefetchProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    readonly DurationsContextProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    readonly IsPlayerContextProvider: import("react").FC<{
+        children?: import("react").ReactNode;
+    }>;
+    readonly useIsPlayer: () => boolean;
+    readonly EditorPropsProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    readonly EditorPropsContext: import("react").Context<import("./EditorProps.js").EditorPropsContextType>;
+    readonly usePreload: (src: string) => string;
+    readonly NonceContext: import("react").Context<import("./nonce.js").TNonceContext>;
+    readonly resolveVideoConfig: ({ composition, editorProps: editorPropsOrUndefined, signal, inputProps, }: {
+        composition: import("./CompositionManager.js").TCompMetadataWithCalcFunction<import("zod").AnyZodObject, Record<string, unknown>>;
+        editorProps: object;
+        signal: AbortSignal;
+        inputProps: Record<string, unknown>;
+    }) => import("./video-config.js").VideoConfig | Promise<import("./video-config.js").VideoConfig>;
+    readonly useResolvedVideoConfig: (preferredCompositionId: string | null) => ({
+        type: "loading";
+    } | {
+        type: "success";
+        result: import("./video-config.js").VideoConfig;
+    } | {
+        type: "error";
+        error: Error;
+    }) | null;
+    readonly resolveCompositionsRef: import("react").RefObject<{
+        setCurrentRenderModalComposition: (compositionId: string | null) => void;
+        reloadCurrentlySelectedComposition: () => void;
+    }>;
+    readonly ResolveCompositionConfig: import("react").FC<import("react").PropsWithChildren<{
+        children: import("react").ReactNode;
+    }>>;
+    readonly REMOTION_STUDIO_CONTAINER_ELEMENT: "__remotion-studio-container";
+    readonly RenderAssetManager: import("react").Context<import("./RenderAssetManager.js").RenderAssetManagerContext>;
+    readonly persistCurrentFrame: (time: {
+        [x: string]: number;
+    }) => void;
+    readonly useTimelineSetFrame: () => (u: import("react").SetStateAction<Record<string, number>>) => void;
+    readonly FILE_TOKEN: "remotion-file:";
+    readonly DATE_TOKEN: "remotion-date:";
+    readonly NativeLayersProvider: import("react").FC<{
+        children?: import("react").ReactNode;
+    }>;
+    readonly ClipComposition: import("react").FC<{
+        children?: import("react").ReactNode;
+    }>;
+    readonly isIosSafari: () => boolean;
+    readonly WATCH_REMOTION_STATIC_FILES: "remotion_staticFilesChanged";
+    readonly addSequenceStackTraces: (component: unknown) => void;
+    readonly useMediaStartsAt: () => number;
+    readonly BufferingProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    readonly BufferingContextReact: import("react").Context<{
+        addBlock: (block: {
+            id: string;
+        }) => {
+            unblock: () => void;
+        };
+        listenForBuffering: (callback: () => void) => {
+            remove: () => void;
+        };
+        listenForResume: (callback: () => void) => {
+            remove: () => void;
+        };
+        buffering: import("react").MutableRefObject<boolean>;
+    } | null>;
+    readonly enableSequenceStackTraces: () => void;
+    readonly colorNames: {
+        [key: string]: number;
+    };
+    readonly CurrentScaleContext: import("react").Context<import("./use-current-scale.js").CurrentScaleContextType | null>;
+    readonly PreviewSizeContext: import("react").Context<import("./use-current-scale.js").PreviewSizeCtx>;
+    readonly calculateScale: ({ canvasSize, compositionHeight, compositionWidth, previewSize, }: {
+        previewSize: number | "auto";
+        compositionWidth: number;
+        compositionHeight: number;
+        canvasSize: {
+            width: number;
+            height: number;
+        };
+    }) => number;
+};
+export type { TComposition, TimelinePosition as Timeline, TCompMetadata, TSequence, TRenderAsset as TAsset, TimelineContextValue, SetTimelineContextValue, CompProps, CompositionManagerContext, MediaVolumeContextValue, SetMediaVolumeContextValue, RemotionEnvironment, SerializedJSONWithCustomFields, WatchRemotionStaticFilesPayload, };

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

@@ -0,0 +1,106 @@
+import { SharedAudioContext, SharedAudioContextProvider, } from './audio/shared-audio-tags.js';
+import { useMediaStartsAt } from './audio/use-audio-frame.js';
+import { BufferingContextReact, BufferingProvider } from './buffering.js';
+import { CanUseRemotionHooks, CanUseRemotionHooksProvider, } from './CanUseRemotionHooks.js';
+import { ClipComposition } from './Composition.js';
+import { compositionsRef } from './CompositionManager.js';
+import { CompositionManager } from './CompositionManagerContext.js';
+import * as CSSUtils from './default-css.js';
+import { EditorPropsContext, EditorPropsProvider } from './EditorProps.js';
+import { addSequenceStackTraces, enableSequenceStackTraces, } from './enable-sequence-stack-traces.js';
+import { getPreviewDomElement, REMOTION_STUDIO_CONTAINER_ELEMENT, } from './get-preview-dom-element.js';
+import { getRemotionEnvironment } from './get-remotion-environment.js';
+import { DATE_TOKEN, FILE_TOKEN } from './input-props-serialization.js';
+import { colorNames } from './interpolate-colors.js';
+import { IsPlayerContextProvider, useIsPlayer } from './is-player.js';
+import { NativeLayersProvider } from './NativeLayers.js';
+import { NonceContext } from './nonce.js';
+import { portalNode } from './portal-node.js';
+import { PrefetchProvider } from './prefetch-state.js';
+import { usePreload } from './prefetch.js';
+import { getRoot, waitForRoot } from './register-root.js';
+import { RemotionRoot } from './RemotionRoot.js';
+import { RenderAssetManager } from './RenderAssetManager.js';
+import { resolveVideoConfig } from './resolve-video-config.js';
+import { ResolveCompositionConfig, resolveCompositionsRef, useResolvedVideoConfig, } from './ResolveCompositionConfig.js';
+import { SequenceContext } from './SequenceContext.js';
+import { SequenceManager, SequenceVisibilityToggleContext, } from './SequenceManager.js';
+import { setupEnvVariables } from './setup-env-variables.js';
+import * as TimelinePosition from './timeline-position-state.js';
+import { persistCurrentFrame, useTimelineSetFrame, } from './timeline-position-state.js';
+import { truthy } from './truthy.js';
+import { calculateScale, CurrentScaleContext, PreviewSizeContext, } from './use-current-scale.js';
+import { useLazyComponent } from './use-lazy-component.js';
+import { useUnsafeVideoConfig } from './use-unsafe-video-config.js';
+import { useVideo } from './use-video.js';
+import { invalidCompositionErrorMessage, isCompositionIdValid, } from './validation/validate-composition-id.js';
+import { DurationsContextProvider } from './video/duration-state.js';
+import { isIosSafari } from './video/video-fragment.js';
+import { MediaVolumeContext, SetMediaVolumeContext, useMediaMutedState, useMediaVolumeState, } from './volume-position-state.js';
+import { WATCH_REMOTION_STATIC_FILES } from './watch-static-file.js';
+import { RemotionContextProvider, useRemotionContexts, } from './wrap-remotion-context.js';
+// Mark them as Internals so use don't assume this is public
+// API and are less likely to use it
+export const Internals = {
+    useUnsafeVideoConfig,
+    Timeline: TimelinePosition,
+    CompositionManager,
+    SequenceManager,
+    SequenceVisibilityToggleContext,
+    RemotionRoot,
+    useVideo,
+    getRoot,
+    useMediaVolumeState,
+    useMediaMutedState,
+    useLazyComponent,
+    truthy,
+    SequenceContext,
+    useRemotionContexts,
+    RemotionContextProvider,
+    CSSUtils,
+    setupEnvVariables,
+    MediaVolumeContext,
+    SetMediaVolumeContext,
+    getRemotionEnvironment,
+    SharedAudioContext,
+    SharedAudioContextProvider,
+    invalidCompositionErrorMessage,
+    isCompositionIdValid,
+    getPreviewDomElement,
+    compositionsRef,
+    portalNode,
+    waitForRoot,
+    CanUseRemotionHooksProvider,
+    CanUseRemotionHooks,
+    PrefetchProvider,
+    DurationsContextProvider,
+    IsPlayerContextProvider,
+    useIsPlayer,
+    EditorPropsProvider,
+    EditorPropsContext,
+    usePreload,
+    NonceContext,
+    resolveVideoConfig,
+    useResolvedVideoConfig,
+    resolveCompositionsRef,
+    ResolveCompositionConfig,
+    REMOTION_STUDIO_CONTAINER_ELEMENT,
+    RenderAssetManager,
+    persistCurrentFrame,
+    useTimelineSetFrame,
+    FILE_TOKEN,
+    DATE_TOKEN,
+    NativeLayersProvider,
+    ClipComposition,
+    isIosSafari,
+    WATCH_REMOTION_STATIC_FILES,
+    addSequenceStackTraces,
+    useMediaStartsAt,
+    BufferingProvider,
+    BufferingContextReact,
+    enableSequenceStackTraces,
+    colorNames,
+    CurrentScaleContext,
+    PreviewSizeContext,
+    calculateScale,
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/interpolate-colors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copied from:
+ * https://github.com/software-mansion/react-native-reanimated/blob/master/src/reanimated2/Colors.ts
+ */
+export declare const colorNames: {
+    [key: string]: number;
+};
+export declare function processColor(color: string): number;
+/**
+ * @description This function allows you to map a range of values to colors using a concise syntax.
+ * @see [Documentation](https://www.remotion.dev/docs/interpolate-colors)
+ */
+export declare const interpolateColors: (input: number, inputRange: readonly number[], outputRange: readonly string[]) => string;