@remotion/media 4.0.403 → 4.0.404

package/dist/video/props.d.ts

@@ -1,4 +1,8 @@
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
+import type { MediaOnError } from '../on-error';
+export type MediaErrorEvent = {
+    error: Error;
+};
 export type FallbackOffthreadVideoProps = {
     acceptableTimeShiftInSeconds?: number;
     transparent?: boolean;
@@ -39,6 +43,7 @@ type OptionalVideoProps = {
     showInTimeline: boolean;
     debugOverlay: boolean;
     headless: boolean;
+    onError: MediaOnError | undefined;
 };
 export type InnerVideoProps = MandatoryVideoProps & OuterVideoProps & OptionalVideoProps;
 export type VideoProps = MandatoryVideoProps & Partial<OuterVideoProps> & Partial<OptionalVideoProps>;

package/dist/video/video-for-preview.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+import { type MediaOnError } from '../on-error';
 import type { FallbackOffthreadVideoProps } from './props';
 type VideoForPreviewProps = {
     readonly src: string;
@@ -22,6 +23,7 @@ type VideoForPreviewProps = {
     readonly audioStreamIndex: number;
     readonly debugOverlay: boolean;
     readonly headless: boolean;
+    readonly onError: MediaOnError | undefined;
 };
 export declare const VideoForPreview: React.FC<VideoForPreviewProps>;
 export {};

package/dist/video/video-for-rendering.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
+import { type MediaOnError } from '../on-error';
 import type { FallbackOffthreadVideoProps } from './props';
 type InnerVideoProps = {
     readonly className: string | undefined;
@@ -23,6 +24,7 @@ type InnerVideoProps = {
     readonly trimBeforeValue: number | undefined;
     readonly trimAfterValue: number | undefined;
     readonly headless: boolean;
+    readonly onError: MediaOnError | undefined;
 };
 export declare const VideoForRendering: React.FC<InnerVideoProps>;
 export {};

package/dist/video/video-preview-iterator.d.ts

@@ -1,6 +1,11 @@
 import type { WrappedCanvas } from 'mediabunny';
-import type { PrewarmedVideoIteratorCache } from '../prewarm-iterator-for-looping';
-export declare const createVideoIterator: (timeToSeek: number, cache: PrewarmedVideoIteratorCache) => {
+export declare const createVideoIterator: (timeToSeek: number, cache: {
+    prewarmIteratorForLooping: ({ timeToSeek }: {
+        timeToSeek: number;
+    }) => void;
+    makeIteratorOrUsePrewarmed: (timeToSeek: number) => AsyncGenerator<WrappedCanvas, void, unknown>;
+    destroy: () => void;
+}) => {
     destroy: () => void;
     getNext: () => Promise<IteratorResult<WrappedCanvas, void>>;
     isDestroyed: () => boolean;

package/dist/video-extraction/extract-frame-via-broadcast-channel.d.ts

@@ -1,4 +1,3 @@
-import { type LogLevel } from 'remotion';
 import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
 export type ExtractFrameViaBroadcastChannelResult = {
     type: 'success';
@@ -21,7 +20,7 @@ export declare const extractFrameViaBroadcastChannel: ({ src, timeInSeconds, log
     timeInSeconds: number;
     durationInSeconds: number;
     playbackRate: number;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     includeAudio: boolean;
     includeVideo: boolean;
     isClientSideRendering: boolean;

package/dist/video-extraction/extract-frame.d.ts

@@ -26,7 +26,5 @@ type ExtractFrameParams = {
     fps: number;
     maxCacheSize: number;
 };
-declare const extractFrameInternal: ({ src, timeInSeconds: unloopedTimeInSeconds, logLevel, loop, trimAfter, trimBefore, playbackRate, fps, maxCacheSize, }: ExtractFrameParams) => Promise<ExtractFrameResult>;
-type ExtractFrameReturnType = Awaited<ReturnType<typeof extractFrameInternal>>;
-export declare const extractFrame: (params: ExtractFrameParams) => Promise<ExtractFrameReturnType>;
+export declare const extractFrame: (params: ExtractFrameParams) => Promise<ExtractFrameResult>;
 export {};

package/dist/video-extraction/keyframe-bank.d.ts

@@ -6,7 +6,7 @@ export type KeyframeBank = {
     prepareForDeletion: (logLevel: LogLevel, reason: string) => {
         framesDeleted: number;
     };
-    deleteFramesBeforeTimestamp: ({ logLevel, timestampInSeconds, }: {
+    deleteFramesBeforeTimestamp: ({ logLevel, timestampInSeconds }: {
         timestampInSeconds: number;
         logLevel: LogLevel;
     }) => void;
@@ -24,7 +24,7 @@ export type KeyframeBank = {
     } | null;
 };
 export declare const makeKeyframeBank: ({ logLevel: parentLogLevel, src, videoSampleSink, requestedTimestamp, }: {
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     src: string;
     videoSampleSink: VideoSampleSink;
     requestedTimestamp: number;

package/dist/video-extraction/keyframe-manager.d.ts

@@ -1,18 +1,17 @@
 import type { VideoSampleSink } from 'mediabunny';
-import { type LogLevel } from 'remotion';
 import { type KeyframeBank } from './keyframe-bank';
 export declare const makeKeyframeManager: () => {
     requestKeyframeBank: ({ timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
         timestamp: number;
         videoSampleSink: VideoSampleSink;
         src: string;
-        logLevel: LogLevel;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         maxCacheSize: number;
     }) => Promise<KeyframeBank>;
     getCacheStats: () => {
         count: number;
         totalSize: number;
     };
-    clearAll: (logLevel: LogLevel) => void;
+    clearAll: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
 };
 export type KeyframeManager = Awaited<ReturnType<typeof makeKeyframeManager>>;

package/dist/video-iterator-manager.d.ts

@@ -1,15 +1,14 @@
 import type { InputVideoTrack, WrappedCanvas } from 'mediabunny';
-import type { LogLevel } from 'remotion';
 import type { Nonce } from './nonce-manager';
 export declare const videoIteratorManager: ({ delayPlaybackHandleIfNotPremounting, canvas, context, drawDebugOverlay, logLevel, getOnVideoFrameCallback, videoTrack, getEndTime, getStartTime, getIsLooping, }: {
     videoTrack: InputVideoTrack;
     delayPlaybackHandleIfNotPremounting: () => {
         unblock: () => void;
     };
-    context: OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D | null;
-    canvas: OffscreenCanvas | HTMLCanvasElement | null;
-    getOnVideoFrameCallback: () => null | ((frame: CanvasImageSource) => void);
-    logLevel: LogLevel;
+    context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+    canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    getOnVideoFrameCallback: () => ((frame: CanvasImageSource) => void) | null;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     drawDebugOverlay: () => void;
     getEndTime: () => number;
     getStartTime: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.403",
+	"version": "4.0.404",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -12,30 +12,32 @@
 	"bugs": {
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
+	"type": "module",
 	"scripts": {
 		"if-node-18+": "node -e \"const [maj]=process.versions.node.split('.').map(Number); process.exit(maj>=18?0:1)\"",
 		"formatting": "prettier --experimental-cli src --check",
 		"lint": "eslint src",
-		"watch": "tsc -w",
+		"watch": "tsgo -w",
 		"test": "node src/test/execute.mjs",
-		"make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
+		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
 		"mediabunny": "1.27.3",
-		"remotion": "4.0.403"
+		"remotion": "4.0.404"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.403",
+		"@remotion/eslint-config-internal": "4.0.404",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",
 		"react-dom": "19.2.3",
 		"vitest": "4.0.9",
-		"webdriverio": "9.19.2"
+		"webdriverio": "9.19.2",
+		"@typescript/native-preview": "7.0.0-dev.20260105.1"
 	},
 	"keywords": [],
 	"publishConfig": {
@@ -44,7 +46,6 @@
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"require": "./dist/index.js",
 			"module": "./dist/esm/index.mjs",
 			"import": "./dist/esm/index.mjs"
 		},

package/dist/audio/allow-wait.js

@@ -1,15 +0,0 @@
-export const allowWaitRoutine = async (next, waitFn) => {
-    const result = await Promise.race([
-        next,
-        new Promise((resolve) => {
-            Promise.resolve().then(() => resolve());
-        }),
-    ]);
-    if (!result) {
-        const unblock = waitFn.waitCallback();
-        const newRes = await next;
-        unblock();
-        return newRes;
-    }
-    return result;
-};

package/dist/audio/audio-for-preview.js

@@ -1,302 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
-import { Internals, Audio as RemotionAudio, useBufferState, useCurrentFrame, useVideoConfig, } from 'remotion';
-import { getTimeInSeconds } from '../get-time-in-seconds';
-import { MediaPlayer } from '../media-player';
-import { useLoopDisplay } from '../show-in-timeline';
-import { useMediaInTimeline } from '../use-media-in-timeline';
-const { useUnsafeVideoConfig, Timeline, SharedAudioContext, useMediaMutedState, useMediaVolumeState, useFrameForVolumeProp, evaluateVolume, warnAboutTooHighVolume, usePreload, SequenceContext, } = Internals;
-const AudioForPreviewAssertedShowing = ({ src, playbackRate, logLevel, muted, volume, loopVolumeCurveBehavior, loop, trimAfter, trimBefore, name, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
-    const videoConfig = useUnsafeVideoConfig();
-    const frame = useCurrentFrame();
-    const mediaPlayerRef = useRef(null);
-    const initialTrimBeforeRef = useRef(trimBefore);
-    const initialTrimAfterRef = useRef(trimAfter);
-    const [mediaPlayerReady, setMediaPlayerReady] = useState(false);
-    const [shouldFallbackToNativeAudio, setShouldFallbackToNativeAudio] = useState(false);
-    const [playing] = Timeline.usePlayingState();
-    const timelineContext = useContext(Internals.TimelineContext);
-    const globalPlaybackRate = timelineContext.playbackRate;
-    const sharedAudioContext = useContext(SharedAudioContext);
-    const buffer = useBufferState();
-    const [mediaMuted] = useMediaMutedState();
-    const [mediaVolume] = useMediaVolumeState();
-    const [mediaDurationInSeconds, setMediaDurationInSeconds] = useState(null);
-    const volumePropFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? 'repeat');
-    const userPreferredVolume = evaluateVolume({
-        frame: volumePropFrame,
-        volume,
-        mediaVolume,
-    });
-    warnAboutTooHighVolume(userPreferredVolume);
-    if (!videoConfig) {
-        throw new Error('No video config found');
-    }
-    if (!src) {
-        throw new TypeError('No `src` was passed to <NewAudioForPreview>.');
-    }
-    const currentTime = frame / videoConfig.fps;
-    const currentTimeRef = useRef(currentTime);
-    currentTimeRef.current = currentTime;
-    const preloadedSrc = usePreload(src);
-    const parentSequence = useContext(SequenceContext);
-    const isPremounting = Boolean(parentSequence?.premounting);
-    const isPostmounting = Boolean(parentSequence?.postmounting);
-    const loopDisplay = useLoopDisplay({
-        loop,
-        mediaDurationInSeconds,
-        playbackRate,
-        trimAfter,
-        trimBefore,
-    });
-    useMediaInTimeline({
-        volume,
-        mediaVolume,
-        mediaType: 'audio',
-        src,
-        playbackRate,
-        displayName: name ?? null,
-        stack,
-        showInTimeline,
-        premountDisplay: parentSequence?.premountDisplay ?? null,
-        postmountDisplay: parentSequence?.postmountDisplay ?? null,
-        loopDisplay,
-        trimAfter,
-        trimBefore,
-    });
-    const bufferingContext = useContext(Internals.BufferingContextReact);
-    if (!bufferingContext) {
-        throw new Error('useMediaPlayback must be used inside a <BufferingContext>');
-    }
-    const isPlayerBuffering = Internals.useIsPlayerBuffering(bufferingContext);
-    const initialPlaying = useRef(playing && !isPlayerBuffering);
-    const initialIsPremounting = useRef(isPremounting);
-    const initialIsPostmounting = useRef(isPostmounting);
-    const initialGlobalPlaybackRate = useRef(globalPlaybackRate);
-    const initialPlaybackRate = useRef(playbackRate);
-    useEffect(() => {
-        if (!sharedAudioContext)
-            return;
-        if (!sharedAudioContext.audioContext)
-            return;
-        try {
-            const player = new MediaPlayer({
-                src: preloadedSrc,
-                logLevel,
-                sharedAudioContext: sharedAudioContext.audioContext,
-                loop,
-                trimAfter: initialTrimAfterRef.current,
-                trimBefore: initialTrimBeforeRef.current,
-                fps: videoConfig.fps,
-                canvas: null,
-                playbackRate: initialPlaybackRate.current,
-                audioStreamIndex: audioStreamIndex ?? 0,
-                debugOverlay: false,
-                bufferState: buffer,
-                isPostmounting: initialIsPostmounting.current,
-                isPremounting: initialIsPremounting.current,
-                globalPlaybackRate: initialGlobalPlaybackRate.current,
-                onVideoFrameCallback: null,
-                playing: initialPlaying.current,
-            });
-            mediaPlayerRef.current = player;
-            player
-                .initialize(currentTimeRef.current)
-                .then((result) => {
-                if (result.type === 'disposed') {
-                    return;
-                }
-                if (result.type === 'unknown-container-format') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Unknown container format ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'network-error') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Network error fetching ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Network error fetching ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'cannot-decode') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Cannot decode ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Cannot decode ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'no-tracks') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`No video or audio tracks found for ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `No video or audio tracks found for ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'success') {
-                    setMediaPlayerReady(true);
-                    setMediaDurationInSeconds(result.durationInSeconds);
-                    Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] MediaPlayer initialized successfully`);
-                }
-            })
-                .catch((error) => {
-                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] Failed to initialize MediaPlayer', error);
-                setShouldFallbackToNativeAudio(true);
-            });
-        }
-        catch (error) {
-            Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] MediaPlayer initialization failed', error);
-            setShouldFallbackToNativeAudio(true);
-        }
-        return () => {
-            if (mediaPlayerRef.current) {
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Disposing MediaPlayer`);
-                mediaPlayerRef.current.dispose();
-                mediaPlayerRef.current = null;
-            }
-            setMediaPlayerReady(false);
-            setShouldFallbackToNativeAudio(false);
-        };
-    }, [
-        preloadedSrc,
-        logLevel,
-        sharedAudioContext,
-        currentTimeRef,
-        loop,
-        videoConfig.fps,
-        audioStreamIndex,
-        disallowFallbackToHtml5Audio,
-        buffer,
-    ]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer)
-            return;
-        if (playing && !isPlayerBuffering) {
-            audioPlayer.play(currentTimeRef.current);
-        }
-        else {
-            audioPlayer.pause();
-        }
-    }, [isPlayerBuffering, logLevel, playing]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setTrimBefore(trimBefore, currentTimeRef.current);
-    }, [trimBefore, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setTrimAfter(trimAfter, currentTimeRef.current);
-    }, [trimAfter, mediaPlayerReady]);
-    const effectiveMuted = muted || mediaMuted || userPreferredVolume <= 0;
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady)
-            return;
-        audioPlayer.setMuted(effectiveMuted);
-    }, [effectiveMuted, mediaPlayerReady]);
-    useEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setVolume(userPreferredVolume);
-    }, [userPreferredVolume, mediaPlayerReady]);
-    useEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setPlaybackRate(playbackRate);
-    }, [playbackRate, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setGlobalPlaybackRate(globalPlaybackRate);
-    }, [globalPlaybackRate, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setFps(videoConfig.fps);
-    }, [videoConfig.fps, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setLoop(loop);
-    }, [loop, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setIsPremounting(isPremounting);
-    }, [isPremounting, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setIsPostmounting(isPostmounting);
-    }, [isPostmounting, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady)
-            return;
-        audioPlayer.seekTo(currentTime).catch(() => {
-            // Might be disposed
-        });
-        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
-    }, [currentTime, logLevel, mediaPlayerReady]);
-    if (shouldFallbackToNativeAudio && !disallowFallbackToHtml5Audio) {
-        return (_jsx(RemotionAudio, { src: src, muted: muted, volume: volume, startFrom: trimBefore, endAt: trimAfter, playbackRate: playbackRate, loopVolumeCurveBehavior: loopVolumeCurveBehavior, name: name, loop: loop, showInTimeline: showInTimeline, stack: stack ?? undefined, toneFrequency: toneFrequency, audioStreamIndex: audioStreamIndex, pauseWhenBuffering: fallbackHtml5AudioProps?.pauseWhenBuffering, crossOrigin: fallbackHtml5AudioProps?.crossOrigin, ...fallbackHtml5AudioProps }));
-    }
-    return null;
-};
-export const AudioForPreview = ({ loop, src, logLevel, muted, name, volume, loopVolumeCurveBehavior, playbackRate, trimAfter, trimBefore, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
-    const preloadedSrc = usePreload(src);
-    const defaultLogLevel = Internals.useLogLevel();
-    const frame = useCurrentFrame();
-    const videoConfig = useVideoConfig();
-    const currentTime = frame / videoConfig.fps;
-    const showShow = useMemo(() => {
-        return (getTimeInSeconds({
-            unloopedTimeInSeconds: currentTime,
-            playbackRate: playbackRate ?? 1,
-            loop: loop ?? false,
-            trimBefore,
-            trimAfter,
-            mediaDurationInSeconds: Infinity,
-            fps: videoConfig.fps,
-            ifNoMediaDuration: 'infinity',
-            src,
-        }) !== null);
-    }, [
-        currentTime,
-        loop,
-        playbackRate,
-        src,
-        trimAfter,
-        trimBefore,
-        videoConfig.fps,
-    ]);
-    if (!showShow) {
-        return null;
-    }
-    return (_jsx(AudioForPreviewAssertedShowing, { audioStreamIndex: audioStreamIndex ?? 0, src: preloadedSrc, playbackRate: playbackRate ?? 1, logLevel: logLevel ?? defaultLogLevel, muted: muted ?? false, volume: volume ?? 1, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', loop: loop ?? false, trimAfter: trimAfter, trimBefore: trimBefore, name: name, showInTimeline: showInTimeline ?? true, stack: stack, disallowFallbackToHtml5Audio: disallowFallbackToHtml5Audio ?? false, toneFrequency: toneFrequency, fallbackHtml5AudioProps: fallbackHtml5AudioProps }));
-};