@remotion/media 4.0.351

package/LICENSE.md

@@ -0,0 +1,49 @@
+# Remotion License
+
+In Remotion 5.0, the license will slightly change. [View the changes here](https://github.com/remotion-dev/remotion/pull/3750).
+
+---
+
+Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion to create videos for free (even commercial), while a company license is required for for-profit organizations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
+
+- [Free License](#free-license)
+- [Company License](#company-license)
+
+## Free License
+
+Copyright © 2025 [Remotion](https://www.remotion.dev)
+
+### Eligibility
+
+You are eligible to use Remotion for free if you are:
+
+- an individual
+- a for-profit organization with up to 3 employees
+- a non-profit or not-for-profit organization
+- evaluating whether Remotion is a good fit, and are not yet using it in a commercial way
+
+### Allowed use cases
+
+Permission is hereby granted, free of charge, to any person eligible for the "Free License", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
+
+### Disallowed use cases
+
+It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivate of Remotion.
+
+### Warranty notice
+
+The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
+
+### Support
+
+Support is provided on a best-we-can-do basis via GitHub Issues and Discord.
+
+## Company License
+
+You are required to obtain a Company License to use Remotion if you are not within the group of entities eligible for a Free License. This license will enable you to use Remotion for the allowed use cases specified in the Free License, and give you access to prioritized support (read the [Support Policy](https://www.remotion.dev/docs/support)).
+
+Visit [remotion.pro](https://www.remotion.pro/license) for pricing and to buy a license.
+
+### FAQs
+
+Are you not sure whether you need a Company License because of an edge case? Here are some [frequently asked questions](https://www.remotion.pro/faq).

package/README.md

@@ -0,0 +1,18 @@
+# @remotion/media
+ 
+Experimental WebCodecs-based media tags
+ 
+[![NPM Downloads](https://img.shields.io/npm/dm/@remotion/media.svg?style=flat&color=black&label=Downloads)](https://npmcharts.com/compare/@remotion/media?minimal=true)
+ 
+## Installation
+ 
+```bash
+npm install @remotion/media --save-exact
+```
+ 
+When installing a Remotion package, make sure to align the version of all `remotion` and `@remotion/*` packages to the same version.
+Remove the `^` character from the version number to use the exact version.
+ 
+## Usage
+ 
+See the [documentation](https://remotion.dev/docs/media) for more information.

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

@@ -0,0 +1,3 @@
+import type React from 'react';
+import type { AudioProps } from './props';
+export declare const AudioForRendering: React.FC<AudioProps>;

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

@@ -0,0 +1,99 @@
+import { useContext, useLayoutEffect, useMemo, useState } from 'react';
+import { cancelRender, Internals, useCurrentFrame, useDelayRender, useRemotionEnvironment, } from 'remotion';
+import { extractFrameViaBroadcastChannel } from '../video-extraction/extract-frame-via-broadcast-channel';
+export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, logLevel = window.remotion_logLevel, loop, }) => {
+    const absoluteFrame = Internals.useTimelinePosition();
+    const videoConfig = Internals.useUnsafeVideoConfig();
+    const { registerRenderAsset, unregisterRenderAsset } = useContext(Internals.RenderAssetManager);
+    const frame = useCurrentFrame();
+    const volumePropsFrame = Internals.useFrameForVolumeProp(loopVolumeCurveBehavior ?? 'repeat');
+    const environment = useRemotionEnvironment();
+    const [id] = useState(() => `${Math.random()}`.replace('0.', ''));
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    if (!src) {
+        throw new TypeError('No `src` was passed to <Audio>.');
+    }
+    const volume = Internals.evaluateVolume({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+    });
+    Internals.warnAboutTooHighVolume(volume);
+    const shouldRenderAudio = useMemo(() => {
+        if (!window.remotion_audioEnabled) {
+            return false;
+        }
+        if (muted) {
+            return false;
+        }
+        if (volume <= 0) {
+            return false;
+        }
+        return true;
+    }, [muted, volume]);
+    const { fps } = videoConfig;
+    const { delayRender, continueRender } = useDelayRender();
+    useLayoutEffect(() => {
+        const actualFps = playbackRate ? fps / playbackRate : fps;
+        const timestamp = frame / actualFps;
+        const durationInSeconds = 1 / actualFps;
+        const newHandle = delayRender(`Extracting audio for frame ${frame}`, {
+            retries: delayRenderRetries ?? undefined,
+            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds ?? undefined,
+        });
+        extractFrameViaBroadcastChannel({
+            src,
+            timeInSeconds: timestamp,
+            durationInSeconds,
+            logLevel: logLevel ?? 'info',
+            includeAudio: shouldRenderAudio,
+            includeVideo: false,
+            isClientSideRendering: environment.isClientSideRendering,
+            volume,
+            loop: loop ?? false,
+        })
+            .then(({ audio }) => {
+            if (audio) {
+                registerRenderAsset({
+                    type: 'inline-audio',
+                    id,
+                    audio: Array.from(audio.data),
+                    sampleRate: audio.sampleRate,
+                    numberOfChannels: audio.numberOfChannels,
+                    frame: absoluteFrame,
+                    timestamp: audio.timestamp,
+                    duration: (audio.numberOfFrames / audio.sampleRate) * 1000000,
+                });
+            }
+            continueRender(newHandle);
+        })
+            .catch((error) => {
+            cancelRender(error);
+        });
+        return () => {
+            continueRender(newHandle);
+            unregisterRenderAsset(id);
+        };
+    }, [
+        absoluteFrame,
+        continueRender,
+        delayRender,
+        delayRenderRetries,
+        delayRenderTimeoutInMilliseconds,
+        environment.isClientSideRendering,
+        fps,
+        frame,
+        id,
+        logLevel,
+        playbackRate,
+        registerRenderAsset,
+        shouldRenderAudio,
+        src,
+        unregisterRenderAsset,
+        volume,
+        loop,
+    ]);
+    return null;
+};

package/dist/audio/audio.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { AudioProps } from './props';
+export declare const Audio: React.FC<AudioProps>;

package/dist/audio/audio.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useContext } from 'react';
+import { cancelRender, Internals, Sequence, useRemotionEnvironment, } from 'remotion';
+import { SharedAudioContext } from '../../../core/src/audio/shared-audio-tags';
+import { AudioForRendering } from './audio-for-rendering';
+const { validateMediaTrimProps, resolveTrimProps, validateMediaProps, AudioForPreview, } = Internals;
+export const Audio = (props) => {
+    const audioContext = useContext(SharedAudioContext);
+    // Should only destruct `trimBefore` and `trimAfter` from props,
+    // rest gets drilled down
+    const { trimBefore, trimAfter, name, pauseWhenBuffering, stack, showInTimeline, onError: onRemotionError, loop, ...otherProps } = props;
+    const environment = useRemotionEnvironment();
+    const onDuration = useCallback(() => undefined, []);
+    if (typeof props.src !== 'string') {
+        throw new TypeError(`The \`<Audio>\` tag requires a string for \`src\`, but got ${JSON.stringify(props.src)} instead.`);
+    }
+    validateMediaTrimProps({
+        startFrom: undefined,
+        endAt: undefined,
+        trimBefore,
+        trimAfter,
+    });
+    const { trimBeforeValue, trimAfterValue } = resolveTrimProps({
+        startFrom: undefined,
+        endAt: undefined,
+        trimBefore,
+        trimAfter,
+    });
+    const onError = useCallback((e) => {
+        // eslint-disable-next-line no-console
+        console.log(e.currentTarget.error);
+        // If there is no `loop` property, we don't need to get the duration
+        // and this does not need to be a fatal error
+        const errMessage = `Could not play audio: ${e.currentTarget.error}. See https://remotion.dev/docs/media-playback-error for help.`;
+        if (loop) {
+            if (onRemotionError) {
+                onRemotionError(new Error(errMessage));
+                return;
+            }
+            cancelRender(new Error(errMessage));
+        }
+        else {
+            onRemotionError?.(new Error(errMessage));
+            // eslint-disable-next-line no-console
+            console.warn(errMessage);
+        }
+    }, [onRemotionError, loop]);
+    if (typeof trimBeforeValue !== 'undefined' ||
+        typeof trimAfterValue !== 'undefined') {
+        return (_jsx(Sequence, { layout: "none", from: 0 - (trimBeforeValue ?? 0), showInTimeline: false, durationInFrames: trimAfterValue, name: name, children: _jsx(Audio, { pauseWhenBuffering: pauseWhenBuffering ?? false, ...otherProps }) }));
+    }
+    validateMediaProps(props, 'Video');
+    if (environment.isRendering) {
+        return _jsx(AudioForRendering, { ...otherProps });
+    }
+    const { onAutoPlayError, crossOrigin, delayRenderRetries, delayRenderTimeoutInMilliseconds, ...propsForPreview } = otherProps;
+    return (_jsx(AudioForPreview, { _remotionInternalNativeLoopPassed: props._remotionInternalNativeLoopPassed ?? false, _remotionInternalStack: stack ?? null, shouldPreMountAudioTags: audioContext !== null && audioContext.numberOfAudioTags > 0, ...propsForPreview, onNativeError: onError, onDuration: onDuration, 
+        // Proposal: Make this default to true in v5
+        pauseWhenBuffering: pauseWhenBuffering ?? false, _remotionInternalNeedsDurationCalculation: Boolean(loop), showInTimeline: showInTimeline ?? true }));
+};

package/dist/audio/props.d.ts

@@ -0,0 +1,29 @@
+import type { LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+import type { LogLevel } from '../log';
+export type AudioProps = {
+    src: string;
+    trimBefore?: number;
+    trimAfter?: number;
+    volume?: VolumeProp;
+    loopVolumeCurveBehavior?: LoopVolumeCurveBehavior;
+    name?: string;
+    pauseWhenBuffering?: boolean;
+    showInTimeline?: boolean;
+    onAutoPlayError?: null | (() => void);
+    playbackRate?: number;
+    muted?: boolean;
+    delayRenderRetries?: number;
+    delayRenderTimeoutInMilliseconds?: number;
+    crossOrigin?: '' | 'anonymous' | 'use-credentials';
+    style?: React.CSSProperties;
+    onError?: (err: Error) => void;
+    useWebAudioApi?: boolean;
+    acceptableTimeShiftInSeconds?: number;
+    /**
+     * @deprecated For internal use only
+     */
+    stack?: string;
+    logLevel?: LogLevel;
+    loop?: boolean;
+    _remotionInternalNativeLoopPassed?: boolean;
+};

package/dist/audio/props.js

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

package/dist/audio-extraction/audio-cache.d.ts

@@ -0,0 +1,11 @@
+import type { AudioSample } from 'mediabunny';
+export declare const makeAudioCache: () => {
+    addFrame: (sample: AudioSample) => void;
+    clearBeforeThreshold: (threshold: number) => void;
+    deleteAll: () => void;
+    getSamples: (timestamp: number, durationInSeconds: number) => AudioSample[];
+    getOldestTimestamp: () => number;
+    getNewestTimestamp: () => number;
+    getOpenTimestamps: () => number[];
+};
+export type AudioCache = ReturnType<typeof makeAudioCache>;

package/dist/audio-extraction/audio-cache.js

@@ -0,0 +1,58 @@
+export const makeAudioCache = () => {
+    const timestamps = [];
+    const samples = {};
+    const addFrame = (sample) => {
+        timestamps.push(sample.timestamp);
+        samples[sample.timestamp] = sample;
+    };
+    const clearBeforeThreshold = (threshold) => {
+        for (const timestamp of timestamps) {
+            const endTimestamp = timestamp + samples[timestamp].duration;
+            if (endTimestamp < threshold) {
+                samples[timestamp].close();
+                delete samples[timestamp];
+                timestamps.splice(timestamps.indexOf(timestamp), 1);
+            }
+        }
+    };
+    const deleteAll = () => {
+        for (const timestamp of timestamps) {
+            delete samples[timestamp];
+        }
+        timestamps.length = 0;
+    };
+    const getSamples = (timestamp, durationInSeconds) => {
+        const selected = [];
+        for (let i = 0; i < timestamps.length; i++) {
+            const sampleTimestamp = timestamps[i];
+            const sample = samples[sampleTimestamp];
+            if (sample.timestamp + sample.duration - 0.0000000001 <= timestamp) {
+                continue;
+            }
+            if (sample.timestamp >= timestamp + durationInSeconds - 0.0000000001) {
+                break;
+            }
+            selected.push(sample);
+        }
+        return selected;
+    };
+    const getOpenTimestamps = () => {
+        return timestamps;
+    };
+    const getOldestTimestamp = () => {
+        return timestamps[0];
+    };
+    const getNewestTimestamp = () => {
+        const sample = samples[timestamps[timestamps.length - 1]];
+        return sample.timestamp + sample.duration;
+    };
+    return {
+        addFrame,
+        clearBeforeThreshold,
+        deleteAll,
+        getSamples,
+        getOldestTimestamp,
+        getNewestTimestamp,
+        getOpenTimestamps,
+    };
+};

package/dist/audio-extraction/audio-iterator.d.ts

@@ -0,0 +1,24 @@
+import type { AudioSample, AudioSampleSink } from 'mediabunny';
+import type { LogLevel } from '../log';
+import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
+export declare const makeAudioIterator: ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, }: {
+    audioSampleSink: AudioSampleSink;
+    isMatroska: boolean;
+    startTimestamp: number;
+    src: string;
+    actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+}) => {
+    src: string;
+    getSamples: (ts: number, dur: number) => Promise<AudioSample[]>;
+    waitForCompletion: () => Promise<boolean>;
+    canSatisfyRequestedTime: (timestamp: number) => boolean;
+    logOpenFrames: (logLevel: LogLevel) => void;
+    getCacheStats: () => {
+        count: number;
+        size: number;
+    };
+    getLastUsed: () => number;
+    prepareForDeletion: () => Promise<void>;
+    startTimestamp: number;
+};
+export type AudioSampleIterator = ReturnType<typeof makeAudioIterator>;

package/dist/audio-extraction/audio-iterator.js

@@ -0,0 +1,106 @@
+import { SAFE_BACK_WINDOW_IN_SECONDS } from '../caches';
+import { Log } from '../log';
+import { makeAudioCache } from './audio-cache';
+// https://discord.com/channels/@me/1409810025844838481/1415028953093111870
+// Audio frames might have dependencies on previous and next frames so we need to decode a bit more
+// and then discard it.
+// The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
+// So let's set a threshold of 1.5 seconds.
+const extraThreshold = 1.5;
+export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, }) => {
+    // Matroska timestamps are not accurate unless we start from the beginning
+    // So for matroska, we need to decode all samples :(
+    // https://github.com/Vanilagy/mediabunny/issues/105
+    const sampleIterator = audioSampleSink.samples(isMatroska ? 0 : Math.max(0, startTimestamp - extraThreshold));
+    let fullDuration = null;
+    const cache = makeAudioCache();
+    let lastUsed = Date.now();
+    const getNextSample = async () => {
+        lastUsed = Date.now();
+        const { value: sample, done } = await sampleIterator.next();
+        if (done) {
+            fullDuration = cache.getNewestTimestamp() ?? null;
+            return null;
+        }
+        const realTimestamp = actualMatroskaTimestamps.getRealTimestamp(sample.timestamp);
+        if (realTimestamp !== null && realTimestamp !== sample.timestamp) {
+            sample.setTimestamp(realTimestamp);
+        }
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp);
+        actualMatroskaTimestamps.observeTimestamp(sample.timestamp + sample.duration);
+        cache.addFrame(sample);
+        return sample;
+    };
+    const getSamples = async (timestamp, durationInSeconds) => {
+        lastUsed = Date.now();
+        if (fullDuration !== null && timestamp > fullDuration) {
+            // Clear all samples before the timestamp
+            // Do this in the while loop because samples might start from 0
+            cache.clearBeforeThreshold(fullDuration - SAFE_BACK_WINDOW_IN_SECONDS);
+            return [];
+        }
+        const samples = cache.getSamples(timestamp, durationInSeconds);
+        while (true) {
+            // Clear all samples before the timestamp
+            // Do this in the while loop because samples might start from 0
+            cache.clearBeforeThreshold(timestamp - SAFE_BACK_WINDOW_IN_SECONDS);
+            const sample = await getNextSample();
+            if (sample === null) {
+                break;
+            }
+            if (sample.timestamp + sample.duration - 0.0000000001 <= timestamp) {
+                continue;
+            }
+            if (sample.timestamp >= timestamp + durationInSeconds - 0.0000000001) {
+                break;
+            }
+            samples.push(sample);
+        }
+        return samples;
+    };
+    const logOpenFrames = (logLevel) => {
+        Log.verbose(logLevel, '[Audio] Open samples for src', src, cache
+            .getOpenTimestamps()
+            .map((t) => t.toFixed(3))
+            .join(', '));
+    };
+    const getCacheStats = () => {
+        return {
+            count: cache.getOpenTimestamps().length,
+            size: cache.getOpenTimestamps().reduce((acc, t) => acc + t, 0),
+        };
+    };
+    const canSatisfyRequestedTime = (timestamp) => {
+        const oldestTimestamp = cache.getOldestTimestamp() ?? startTimestamp;
+        if (fullDuration !== null && timestamp > fullDuration) {
+            return true;
+        }
+        return (oldestTimestamp < timestamp && Math.abs(oldestTimestamp - timestamp) < 10);
+    };
+    const prepareForDeletion = async () => {
+        cache.deleteAll();
+        const { value } = await sampleIterator.return();
+        if (value) {
+            value.close();
+        }
+        fullDuration = null;
+    };
+    let op = Promise.resolve([]);
+    return {
+        src,
+        getSamples: (ts, dur) => {
+            op = op.then(() => getSamples(ts, dur));
+            return op;
+        },
+        waitForCompletion: async () => {
+            await op;
+            return true;
+        },
+        canSatisfyRequestedTime,
+        logOpenFrames,
+        getCacheStats,
+        getLastUsed: () => lastUsed,
+        prepareForDeletion,
+        startTimestamp,
+    };
+};

package/dist/audio-extraction/audio-manager.d.ts

@@ -0,0 +1,64 @@
+import type { AudioSampleSink } from 'mediabunny';
+import type { LogLevel } from '../log';
+import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
+export declare const makeAudioManager: () => {
+    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+        timeInSeconds: number;
+        src: string;
+        audioSampleSink: AudioSampleSink;
+        isMatroska: boolean;
+        actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+    }) => {
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    };
+    getIterator: ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+        src: string;
+        timeInSeconds: number;
+        audioSampleSink: AudioSampleSink;
+        isMatroska: boolean;
+        actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+    }) => Promise<{
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    }>;
+    getCacheStats: () => {
+        count: number;
+        totalSize: number;
+    };
+    getIteratorMostInThePast: () => {
+        src: string;
+        getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
+        waitForCompletion: () => Promise<boolean>;
+        canSatisfyRequestedTime: (timestamp: number) => boolean;
+        logOpenFrames: (logLevel: LogLevel) => void;
+        getCacheStats: () => {
+            count: number;
+            size: number;
+        };
+        getLastUsed: () => number;
+        prepareForDeletion: () => Promise<void>;
+        startTimestamp: number;
+    } | null;
+    logOpenFrames: (logLevel: LogLevel) => void;
+};

package/dist/audio-extraction/audio-manager.js

@@ -0,0 +1,83 @@
+import { getTotalCacheStats, MAX_CACHE_SIZE } from '../caches';
+import { makeAudioIterator } from './audio-iterator';
+export const makeAudioManager = () => {
+    const iterators = [];
+    const makeIterator = ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }) => {
+        const iterator = makeAudioIterator({
+            audioSampleSink,
+            isMatroska,
+            startTimestamp: timeInSeconds,
+            src,
+            actualMatroskaTimestamps,
+        });
+        iterators.push(iterator);
+        return iterator;
+    };
+    const getIteratorMostInThePast = () => {
+        let mostInThePast = null;
+        let mostInThePastIterator = null;
+        for (const iterator of iterators) {
+            const lastUsed = iterator.getLastUsed();
+            if (mostInThePast === null || lastUsed < mostInThePast) {
+                mostInThePast = lastUsed;
+                mostInThePastIterator = iterator;
+            }
+        }
+        return mostInThePastIterator;
+    };
+    const deleteOldestIterator = async () => {
+        const iterator = getIteratorMostInThePast();
+        if (iterator) {
+            await iterator.prepareForDeletion();
+            iterators.splice(iterators.indexOf(iterator), 1);
+        }
+    };
+    const getIterator = async ({ src, timeInSeconds, audioSampleSink, isMatroska, actualMatroskaTimestamps, }) => {
+        while ((await getTotalCacheStats()).totalSize > MAX_CACHE_SIZE) {
+            await deleteOldestIterator();
+        }
+        for (const iterator of iterators) {
+            if (iterator.src === src &&
+                (await iterator.waitForCompletion()) &&
+                iterator.canSatisfyRequestedTime(timeInSeconds)) {
+                return iterator;
+            }
+        }
+        for (const iterator of iterators) {
+            // delete iterator with same starting timestamp
+            if (iterator.src === src && iterator.startTimestamp === timeInSeconds) {
+                await iterator.prepareForDeletion();
+                iterators.splice(iterators.indexOf(iterator), 1);
+            }
+        }
+        return makeIterator({
+            src,
+            timeInSeconds,
+            audioSampleSink,
+            isMatroska,
+            actualMatroskaTimestamps,
+        });
+    };
+    const getCacheStats = () => {
+        let totalCount = 0;
+        let totalSize = 0;
+        for (const iterator of iterators) {
+            const { count, size } = iterator.getCacheStats();
+            totalCount += count;
+            totalSize += size;
+        }
+        return { count: totalCount, totalSize };
+    };
+    const logOpenFrames = (logLevel) => {
+        for (const iterator of iterators) {
+            iterator.logOpenFrames(logLevel);
+        }
+    };
+    return {
+        makeIterator,
+        getIterator,
+        getCacheStats,
+        getIteratorMostInThePast,
+        logOpenFrames,
+    };
+};

package/dist/audio-extraction/extract-audio.d.ts

@@ -0,0 +1,10 @@
+import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
+import type { LogLevel } from '../log';
+export declare const extractAudio: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, volume, logLevel, loop, }: {
+    src: string;
+    timeInSeconds: number;
+    durationInSeconds: number;
+    volume: number;
+    logLevel: LogLevel;
+    loop: boolean;
+}) => Promise<PcmS16AudioData | null>;