remotion 3.3.51 → 3.3.52

package/dist/esm/test/series.test.js

@@ -1,9 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/**
- * @vitest-environment jsdom
- */
-/* eslint-disable react/jsx-no-constructed-context-values */
-import { render } from '@testing-library/react';
+import { renderToString } from 'react-dom/server';
 import { expect, test } from 'vitest';
 import { CanUseRemotionHooksProvider } from '../CanUseRemotionHooks.js';
 import { Series } from '../series';
@@ -23,7 +19,7 @@ const Third = () => {
     return _jsx("div", { children: 'third ' + frame });
 };
 const renderForFrame = (frame, markup) => {
-    return render(_jsx(CanUseRemotionHooksProvider, { children: _jsx(TimelineContext.Provider, { value: {
+    return renderToString(_jsx(CanUseRemotionHooksProvider, { children: _jsx(TimelineContext.Provider, { value: {
                 rootId: '',
                 frame,
                 playing: false,
@@ -38,27 +34,27 @@ const renderForFrame = (frame, markup) => {
             }, children: markup }) }));
 };
 test('Basic series test', () => {
-    const { queryByText } = renderForFrame(10, _jsxs(WrapSequenceContext, { children: [_jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Third, {}) })] }), ' '] }));
-    expect(queryByText(/^third\s0$/)).not.toBe(null);
+    const outerHTML = renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
+    expect(outerHTML).toBe('<div style="position:absolute;top:0;left:0;right:0;bottom:0;width:100%;height:100%;display:flex"><div>third 0</div></div>');
 });
 test('Should support fragments', () => {
-    const { container } = renderForFrame(10, _jsxs(WrapSequenceContext, { children: [_jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsxs(_Fragment, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Second, {}) }, "0"), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Third, {}) }, "1")] })] }), ' '] }));
-    expect(container.outerHTML).not.toBe(null);
+    const outerHtml = renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsxs(_Fragment, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Second, {}) }, "0"), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Third, {}) }, "1")] })] }) }));
+    expect(outerHtml).not.toBe('<div style="position:absolute;top:0;left:0;right:0;bottom:0;width:100%;height:100%;display:flex"><div>second 1</div></div>');
 });
 test('Should not allow foreign elements', () => {
     expect(() => {
-        render(_jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(First, {}) }) }));
+        renderForFrame(0, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(First, {}) }) }));
     }).toThrow(/only accepts a/);
 });
 test('Should allow layout prop', () => {
-    const { container } = renderForFrame(0, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, children: _jsx(First, {}) }) }) }));
-    expect(container.outerHTML).toBe('<div><div style="position: absolute; top: 0px; left: 0px; right: 0px; bottom: 0px; width: 100%; height: 100%; display: flex;"><div>first 0</div></div></div>');
-    const { container: withoutLayoutContainer } = renderForFrame(0, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, layout: "none", children: _jsx(First, {}) }) }) }));
-    expect(withoutLayoutContainer.outerHTML).toBe('<div><div>first 0</div></div>');
+    const outerHTML = renderForFrame(0, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, children: _jsx(First, {}) }) }) }));
+    expect(outerHTML).toBe('<div style="position:absolute;top:0;left:0;right:0;bottom:0;width:100%;height:100%;display:flex"><div>first 0</div></div>');
+    const outerHTML2 = renderForFrame(0, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, layout: "none", children: _jsx(First, {}) }) }) }));
+    expect(outerHTML2).toBe('<div>first 0</div>');
 });
 test('Should render nothing after the end', () => {
-    const { container } = renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, children: _jsx(First, {}) }) }) }));
-    expect(container.outerHTML).toBe('<div></div>');
+    const outerHTML = renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsx(Series, { children: _jsx(Series.Sequence, { durationInFrames: 1, children: _jsx(First, {}) }) }) }));
+    expect(outerHTML).toBe('');
 });
 test('Should throw if invalid or no duration provided', () => {
     expect(() => {
@@ -69,19 +65,19 @@ test('Should throw if invalid or no duration provided', () => {
     }).toThrow(/The "durationInFrames" prop of a <Series.Sequence \/> component must be a number, but you passed a value of type undefined/);
 });
 test('Should allow whitespace', () => {
-    const { queryByText } = renderForFrame(11, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 10, children: _jsx(First, {}) }), ' ', _jsx(Series.Sequence, { durationInFrames: 10, children: _jsx(Second, {}) })] }) }));
-    expect(queryByText(/^second\s1$/g)).not.toBe(null);
+    const outerHtml = renderForFrame(11, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 10, children: _jsx(First, {}) }), ' ', _jsx(Series.Sequence, { durationInFrames: 10, children: _jsx(Second, {}) })] }) }));
+    expect(outerHtml).toBe('<div style="position:absolute;top:0;left:0;right:0;bottom:0;width:100%;height:100%;display:flex"><div>second 1</div></div>');
 });
 test('Handle empty Series.Sequence', () => {
     expect(() => renderForFrame(11, _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 10, children: _jsx(First, {}) }), _jsx(Series.Sequence, { durationInFrames: 10 })] }))).toThrow(/A <Series.Sequence \/> component \(index = 1, duration = 10\) was detected to not have any children\. Delete it to fix this error\./);
 });
 test('Should allow negative overlap prop', () => {
-    const { container } = renderForFrame(4, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: -1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) })] }) }));
-    expect(container.outerHTML).toBe('<div><div>first 4</div><div>second 0</div></div>');
+    const outerHTML = renderForFrame(4, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: -1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) })] }) }));
+    expect(outerHTML).toBe('<div>first 4</div><div>second 0</div>');
 });
 test('Should allow positive overlap prop', () => {
-    const { container } = renderForFrame(5, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: 1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) })] }) }));
-    expect(container.outerHTML).toBe('<div></div>');
+    const outerHTML = renderForFrame(5, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: 1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) })] }) }));
+    expect(outerHTML).toBe('');
 });
 test('Should disallow NaN as offset prop', () => {
     expect(() => {
@@ -99,10 +95,19 @@ test('Should disallow non-integer numbers as offset prop', () => {
     }).toThrow(/The "offset" property of a <Series.Sequence \/> must be finite, but got 3.141592653589793 \(index = 0, duration = 5\)\./);
 });
 test('Should cascade negative offset props', () => {
-    const { container } = renderForFrame(9, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: -1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { layout: "none", durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
-    expect(container.outerHTML).toBe('<div><div>third 0</div></div>');
+    const outerHTML = renderForFrame(9, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: -1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { layout: "none", durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
+    expect(outerHTML).toBe('<div>third 0</div>');
 });
 test('Should cascade positive offset props', () => {
-    const { container } = renderForFrame(11, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: 1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { layout: "none", durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
-    expect(container.outerHTML).toBe('<div><div>third 0</div></div>');
+    const outerHTML = renderForFrame(11, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, layout: "none", children: _jsx(First, {}) }), _jsx(Series.Sequence, { offset: 1, layout: "none", durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { layout: "none", durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
+    expect(outerHTML).toBe('<div>third 0</div>');
+});
+test('Allow durationInFrames as Infinity for last Series.Sequence', () => {
+    const outerHTML = renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { durationInFrames: Infinity, children: _jsx(Third, {}) })] }) }));
+    expect(outerHTML).toBe('<div style="position:absolute;top:0;left:0;right:0;bottom:0;width:100%;height:100%;display:flex"><div>third 0</div></div>');
+});
+test('Disallow durationInFrames as Infinity for first n-1 Series.Sequence', () => {
+    expect(() => {
+        renderForFrame(10, _jsx(WrapSequenceContext, { children: _jsxs(Series, { children: [_jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(First, {}) }), _jsx(Series.Sequence, { durationInFrames: Infinity, children: _jsx(Second, {}) }), _jsx(Series.Sequence, { durationInFrames: 5, children: _jsx(Third, {}) })] }) }));
+    }).toThrow(/The "durationInFrames" prop of a <Series.Sequence \/> component must be an integer, but got Infinity\./);
 });

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.3.51";
+export declare const VERSION = "3.3.52";

package/dist/esm/version.js

@@ -1,2 +1,2 @@
 // Automatically generated on publish
-export const VERSION = '3.3.51';
+export const VERSION = '3.3.52';

package/dist/freeze.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare type FreezeProps = {
+    frame: number;
+    children: React.ReactNode;
+};
+export declare const Freeze: React.FC<FreezeProps>;
+export {};

package/dist/freeze.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Freeze = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const Sequence_1 = require("./Sequence");
+const timeline_position_state_1 = require("./timeline-position-state");
+const Freeze = ({ frame, children }) => {
+    if (typeof frame === 'undefined') {
+        throw new Error(`The <Freeze /> component requires a 'frame' prop, but none was passed.`);
+    }
+    if (typeof frame !== 'number') {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a number, but is of type ${typeof frame}`);
+    }
+    if (Number.isNaN(frame)) {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a real number, but it is NaN.`);
+    }
+    if (!Number.isFinite(frame)) {
+        throw new Error(`The 'frame' prop of <Freeze /> must be a finite number, but it is ${frame}.`);
+    }
+    const context = (0, react_1.useContext)(timeline_position_state_1.TimelineContext);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            ...context,
+            playing: false,
+            imperativePlaying: {
+                current: false,
+            },
+            frame,
+        };
+    }, [context, frame]);
+    return ((0, jsx_runtime_1.jsx)(timeline_position_state_1.TimelineContext.Provider, { value: value, children: (0, jsx_runtime_1.jsx)(Sequence_1.SequenceContext.Provider, { value: null, children: children }) }));
+};
+exports.Freeze = Freeze;

package/dist/get-asset-file-name.d.ts

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

package/dist/get-asset-file-name.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetDisplayName = void 0;
+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];
+};
+exports.getAssetDisplayName = getAssetDisplayName;

package/dist/get-environment.d.ts

@@ -0,0 +1,3 @@
+export declare type RemotionEnvironment = 'preview' | 'rendering' | 'player-development' | 'player-production';
+export declare const getRemotionEnvironment: () => RemotionEnvironment;
+export declare const useRemotionEnvironment: () => RemotionEnvironment;

package/dist/get-environment.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRemotionEnvironment = exports.getRemotionEnvironment = void 0;
+const is_player_1 = require("./is-player");
+const getRemotionEnvironment = () => {
+    if (process.env.NODE_ENV === 'production') {
+        if (typeof window !== 'undefined' && window.remotion_isPlayer) {
+            return 'player-production';
+        }
+        return 'rendering';
+    }
+    // The Vitest framework sets NODE_ENV as test.
+    // Right now we don't need to treat it in a special
+    // way which is good - defaulting to `rendering`.
+    if (process.env.NODE_ENV === 'test') {
+        return 'rendering';
+    }
+    if (typeof window !== 'undefined' && window.remotion_isPlayer) {
+        return 'player-development';
+    }
+    return 'preview';
+};
+exports.getRemotionEnvironment = getRemotionEnvironment;
+const useRemotionEnvironment = () => {
+    const isPlayer = (0, is_player_1.useIsPlayer)();
+    if (isPlayer) {
+        if (process.env.NODE_ENV === 'production') {
+            return 'player-production';
+        }
+        return 'player-development';
+    }
+    return (0, exports.getRemotionEnvironment)();
+};
+exports.useRemotionEnvironment = useRemotionEnvironment;

package/dist/get-preview-dom-element.d.ts

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

package/dist/get-preview-dom-element.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreviewDomElement = void 0;
+const getPreviewDomElement = () => {
+    return document.getElementById('container');
+};
+exports.getPreviewDomElement = getPreviewDomElement;

package/dist/get-static-files.d.ts

@@ -0,0 +1,17 @@
+export declare const getStaticFiles: () => StaticFile[];
+export declare 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/dist/get-static-files.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticFiles = void 0;
+let warnedServer = false;
+let warnedPlayer = false;
+const warnServerOnce = () => {
+    if (warnedServer) {
+        return;
+    }
+    warnedServer = true;
+    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;
+    console.warn('Called getStaticFiles() while using the Remotion Player. The API is only available while using the Remotion Preview. An empty array was returned.');
+};
+const getStaticFiles = () => {
+    if (typeof document === 'undefined') {
+        warnServerOnce();
+        return [];
+    }
+    if (window.remotion_isPlayer) {
+        warnPlayerOnce();
+        return [];
+    }
+    return window.remotion_staticFiles;
+};
+exports.getStaticFiles = getStaticFiles;

package/dist/get-timeline-clip-name.d.ts

@@ -0,0 +1 @@
+export declare const getTimelineClipName: (children: React.ReactNode) => string;

package/dist/get-timeline-clip-name.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimelineClipName = void 0;
+const react_1 = require("react");
+const HIDDEN_NAMES = ['__WEBPACK_DEFAULT_EXPORT__'];
+const getTimelineClipName = (children) => {
+    var _a;
+    const tree = (_a = react_1.Children.map(children, (ch) => {
+        if (!(0, react_1.isValidElement)(ch)) {
+            return null;
+        }
+        // Must be name, not ID
+        const name = typeof ch.type !== 'string' && ch.type.name;
+        if (name && !HIDDEN_NAMES.includes(name)) {
+            return name;
+        }
+        if (ch.props.children) {
+            const chName = (0, exports.getTimelineClipName)(ch.props.children);
+            return chName;
+        }
+        return null;
+    })) === null || _a === void 0 ? void 0 : _a.filter(Boolean);
+    return (tree === null || tree === void 0 ? void 0 : tree.length) ? tree[0] : '';
+};
+exports.getTimelineClipName = getTimelineClipName;

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+import './asset-types';
+import type { TAsset, TCompMetadata } from './CompositionManager';
+import type { StaticFile } from './get-static-files';
+import type { ClipRegion } from './NativeLayers';
+declare global {
+    interface Window {
+        ready: boolean;
+        remotion_cancelledError: string | undefined;
+        getStaticCompositions: () => TCompMetadata[];
+        setBundleMode: (bundleMode: BundleState) => void;
+        remotion_staticBase: string;
+        remotion_staticFiles: StaticFile[];
+        remotion_editorName: string | null;
+        remotion_numberOfAudioTags: number;
+        remotion_projectName: string;
+        remotion_cwd: string;
+        remotion_previewServerCommand: string;
+        remotion_setFrame: (frame: number) => void;
+        remotion_initialFrame: number;
+        remotion_proxyPort: number;
+        remotion_audioEnabled: boolean;
+        remotion_videoEnabled: boolean;
+        remotion_puppeteerTimeout: number;
+        remotion_inputProps: string;
+        remotion_envVariables: string;
+        remotion_collectAssets: () => TAsset[];
+        remotion_getClipRegion: () => ClipRegion | null;
+        remotion_isPlayer: boolean;
+        remotion_isBuilding: undefined | (() => void);
+        remotion_finishedBuilding: undefined | (() => void);
+        siteVersion: '4';
+        remotion_version: string;
+        remotion_imported: string | boolean;
+    }
+}
+export declare type BundleState = {
+    type: 'index';
+} | {
+    type: 'evaluation';
+} | {
+    type: 'composition';
+    compositionName: string;
+    compositionDefaultProps: unknown;
+    compositionHeight: number;
+    compositionDurationInFrames: number;
+    compositionWidth: number;
+    compositionFps: number;
+};
+export * from './AbsoluteFill';
+export * from './audio';
+export { cancelRender } from './cancel-render';
+export * from './Composition';
+export { SmallTCompMetadata, TAsset, TCompMetadata } from './CompositionManager';
+export { Config, ConfigType } from './config';
+export { getInputProps } from './config/input-props';
+export { continueRender, delayRender } from './delay-render';
+export * from './easing';
+export * from './Folder';
+export * from './freeze';
+export { getStaticFiles, StaticFile } from './get-static-files';
+export * from './IFrame';
+export * from './Img';
+export * from './internals';
+export * from './interpolate';
+export { interpolateColors } from './interpolate-colors';
+export { Loop } from './loop';
+export { ClipRegion } from './NativeLayers';
+export { prefetch } from './prefetch';
+export { random, RandomSeed } from './random';
+export { registerRoot } from './register-root';
+export { Sequence } from './Sequence';
+export { Series } from './series';
+export * from './spring';
+export { staticFile } from './static-file';
+export * from './Still';
+export type { PlayableMediaTag } from './timeline-position-state';
+export { useCurrentFrame } from './use-current-frame';
+export * from './use-video-config';
+export * from './version';
+export * from './video';
+export * from './video-config';
+export declare const Experimental: {
+    Clipper: import("react").FC<{
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }>;
+    Null: import("react").FC<{}>;
+    useIsPlayer: () => boolean;
+};
+export declare type WebpackOverrideFn = "The 'WebpackOverrideFn' has been moved to '@remotion/bundler'. Update your imports and install '@remotion/bundler' if necessary.";

package/dist/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Experimental = exports.useCurrentFrame = exports.staticFile = exports.Series = exports.Sequence = exports.registerRoot = exports.random = exports.prefetch = exports.Loop = exports.interpolateColors = exports.getStaticFiles = exports.delayRender = exports.continueRender = exports.getInputProps = exports.Config = exports.cancelRender = void 0;
+require("./asset-types");
+const Clipper_1 = require("./Clipper");
+const is_player_1 = require("./is-player");
+const multiple_versions_warning_1 = require("./multiple-versions-warning");
+const Null_1 = require("./Null");
+(0, multiple_versions_warning_1.checkMultipleRemotionVersions)();
+__exportStar(require("./AbsoluteFill"), exports);
+__exportStar(require("./audio"), exports);
+var cancel_render_1 = require("./cancel-render");
+Object.defineProperty(exports, "cancelRender", { enumerable: true, get: function () { return cancel_render_1.cancelRender; } });
+__exportStar(require("./Composition"), exports);
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+var input_props_1 = require("./config/input-props");
+Object.defineProperty(exports, "getInputProps", { enumerable: true, get: function () { return input_props_1.getInputProps; } });
+var delay_render_1 = require("./delay-render");
+Object.defineProperty(exports, "continueRender", { enumerable: true, get: function () { return delay_render_1.continueRender; } });
+Object.defineProperty(exports, "delayRender", { enumerable: true, get: function () { return delay_render_1.delayRender; } });
+__exportStar(require("./easing"), exports);
+__exportStar(require("./Folder"), exports);
+__exportStar(require("./freeze"), exports);
+var get_static_files_1 = require("./get-static-files");
+Object.defineProperty(exports, "getStaticFiles", { enumerable: true, get: function () { return get_static_files_1.getStaticFiles; } });
+__exportStar(require("./IFrame"), exports);
+__exportStar(require("./Img"), exports);
+__exportStar(require("./internals"), exports);
+__exportStar(require("./interpolate"), exports);
+var interpolate_colors_1 = require("./interpolate-colors");
+Object.defineProperty(exports, "interpolateColors", { enumerable: true, get: function () { return interpolate_colors_1.interpolateColors; } });
+var loop_1 = require("./loop");
+Object.defineProperty(exports, "Loop", { enumerable: true, get: function () { return loop_1.Loop; } });
+var prefetch_1 = require("./prefetch");
+Object.defineProperty(exports, "prefetch", { enumerable: true, get: function () { return prefetch_1.prefetch; } });
+var random_1 = require("./random");
+Object.defineProperty(exports, "random", { enumerable: true, get: function () { return random_1.random; } });
+var register_root_1 = require("./register-root");
+Object.defineProperty(exports, "registerRoot", { enumerable: true, get: function () { return register_root_1.registerRoot; } });
+var Sequence_1 = require("./Sequence");
+Object.defineProperty(exports, "Sequence", { enumerable: true, get: function () { return Sequence_1.Sequence; } });
+var series_1 = require("./series");
+Object.defineProperty(exports, "Series", { enumerable: true, get: function () { return series_1.Series; } });
+__exportStar(require("./spring"), exports);
+var static_file_1 = require("./static-file");
+Object.defineProperty(exports, "staticFile", { enumerable: true, get: function () { return static_file_1.staticFile; } });
+__exportStar(require("./Still"), exports);
+var use_current_frame_1 = require("./use-current-frame");
+Object.defineProperty(exports, "useCurrentFrame", { enumerable: true, get: function () { return use_current_frame_1.useCurrentFrame; } });
+__exportStar(require("./use-video-config"), exports);
+__exportStar(require("./version"), exports);
+__exportStar(require("./video"), exports);
+__exportStar(require("./video-config"), exports);
+exports.Experimental = {
+    Clipper: Clipper_1.Clipper,
+    Null: Null_1.Null,
+    useIsPlayer: is_player_1.useIsPlayer,
+};

package/dist/internals.d.ts

@@ -0,0 +1,97 @@
+import type { CompProps } from './Composition';
+import type { CompositionManagerContext, TAsset, TCompMetadata, TComposition, TSequence } from './CompositionManager';
+import * as CSSUtils from './default-css';
+import type { RemotionEnvironment } from './get-environment';
+import type { SetTimelineContextValue, TimelineContextValue } from './timeline-position-state';
+import * as TimelinePosition from './timeline-position-state';
+import { truthy } from './truthy';
+import type { MediaVolumeContextValue, SetMediaVolumeContextValue } from './volume-position-state';
+import { useRemotionContexts } from './wrap-remotion-context';
+declare const Timeline: typeof TimelinePosition;
+export declare const Internals: {
+    useUnsafeVideoConfig: () => import("./video-config").VideoConfig | null;
+    Timeline: typeof TimelinePosition;
+    CompositionManager: import("react").Context<CompositionManagerContext>;
+    RemotionRoot: import("react").FC<{
+        children: import("react").ReactNode;
+        numberOfAudioTags: number;
+    }>;
+    useVideo: () => {
+        height: number;
+        width: number;
+        fps: number;
+        durationInFrames: number;
+        defaultProps: unknown;
+        id: string;
+        folderName: string | null;
+        parentFolderName: string | null;
+        component: import("react").LazyExoticComponent<import("react").ComponentType<unknown>>;
+        nonce: number;
+    } | null;
+    getRoot: () => import("react").FC<{}> | null;
+    useMediaVolumeState: () => readonly [number, (u: number) => void];
+    useMediaMutedState: () => readonly [boolean, (u: import("react").SetStateAction<boolean>) => void];
+    useLazyComponent: <T>(compProps: CompProps<T>) => import("react").ExoticComponent<(import("react").PropsWithoutRef<T> & import("react").RefAttributes<import("react").Component<T, any, any>>) | import("react").PropsWithRef<T>> & {
+        readonly _result: import("react").ComponentType<T>;
+    };
+    truthy: typeof truthy;
+    SequenceContext: import("react").Context<import("./Sequence").SequenceContextType | null>;
+    useRemotionContexts: typeof useRemotionContexts;
+    RemotionContextProvider: (props: import("./wrap-remotion-context").RemotionContextProviderProps) => JSX.Element;
+    CSSUtils: typeof CSSUtils;
+    setupEnvVariables: () => void;
+    ENV_VARIABLES_ENV_NAME: "ENV_VARIABLES";
+    MediaVolumeContext: import("react").Context<MediaVolumeContextValue>;
+    SetMediaVolumeContext: import("react").Context<SetMediaVolumeContextValue>;
+    validateDurationInFrames: (durationInFrames: number, component: string) => void;
+    validateFps: (fps: number, location: string, isGif: boolean) => void;
+    validateDimension: (amount: number, nameOfProp: string, location: string) => void;
+    getRemotionEnvironment: () => RemotionEnvironment;
+    SharedAudioContext: import("react").Context<{
+        registerAudio: (aud: import("./audio").RemotionAudioProps, audioId: string) => {
+            id: number;
+            props: import("./audio").RemotionAudioProps;
+            el: import("react").RefObject<HTMLAudioElement>;
+            audioId: string;
+        };
+        unregisterAudio: (id: number) => void;
+        updateAudio: (options: {
+            id: number;
+            aud: import("./audio").RemotionAudioProps;
+            audioId: string;
+        }) => void;
+        playAllAudios: () => void;
+        numberOfAudioTags: number;
+    } | null>;
+    SharedAudioContextProvider: import("react").FC<{
+        numberOfAudioTags: number;
+        children: import("react").ReactNode;
+    }>;
+    invalidCompositionErrorMessage: string;
+    isCompositionIdValid: (id: string) => RegExpMatchArray | null;
+    getPreviewDomElement: () => HTMLElement | null;
+    compositionsRef: import("react").RefObject<{
+        getCompositions: () => TCompMetadata[];
+    }>;
+    DELAY_RENDER_CALLSTACK_TOKEN: string;
+    portalNode: () => HTMLElement;
+    waitForRoot: (fn: (comp: import("react").FC<{}>) => void) => () => void;
+    validateOffthreadVideoImageFormat: (input: unknown) => void;
+    CanUseRemotionHooksProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    CanUseRemotionHooks: import("react").Context<boolean>;
+    enableLegacyRemotionConfig: () => void;
+    PrefetchProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    DurationsContextProvider: import("react").FC<{
+        children: import("react").ReactNode;
+    }>;
+    IsPlayerContextProvider: import("react").FC<{
+        children?: import("react").ReactNode;
+    }>;
+    useIsPlayer: () => boolean;
+    useRemotionEnvironment: () => RemotionEnvironment;
+};
+export type { TComposition, Timeline, TCompMetadata, TSequence, TAsset, TimelineContextValue, SetTimelineContextValue, CompProps, CompositionManagerContext, MediaVolumeContextValue, SetMediaVolumeContextValue, RemotionEnvironment, };