@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/assets/download-and-map-assets-to-file.js

@@ -0,0 +1,312 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachDownloadListenerToEmitter = exports.downloadAndMapAssetsToFileUrl = exports.getSanitizedFilenameForAssetUrl = exports.markAllAssetsAsDownloaded = exports.downloadAsset = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importStar(require("node:path"));
+const no_react_1 = require("remotion/no-react");
+const compress_assets_1 = require("../compress-assets");
+const ensure_output_directory_1 = require("../ensure-output-directory");
+const mime_types_1 = require("../mime-types");
+const download_file_1 = require("./download-file");
+const get_audio_channels_1 = require("./get-audio-channels");
+const sanitize_filepath_1 = require("./sanitize-filepath");
+const waitForAssetToBeDownloaded = ({ src, downloadDir, downloadMap, }) => {
+    var _a, _b;
+    if ((_a = downloadMap.hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        return Promise.resolve((_b = downloadMap.hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir]);
+    }
+    if (!downloadMap.listeners[src]) {
+        downloadMap.listeners[src] = {};
+    }
+    if (!downloadMap.listeners[src][downloadDir]) {
+        downloadMap.listeners[src][downloadDir] = [];
+    }
+    return new Promise((resolve) => {
+        downloadMap.listeners[src][downloadDir].push(() => {
+            const srcMap = downloadMap.hasBeenDownloadedMap[src];
+            if (!(srcMap === null || srcMap === void 0 ? void 0 : srcMap[downloadDir])) {
+                throw new Error('Expected file for ' + src + 'to be available in ' + downloadDir);
+            }
+            resolve(srcMap[downloadDir]);
+        });
+    });
+};
+const notifyAssetIsDownloaded = ({ src, downloadDir, to, downloadMap, }) => {
+    if (!downloadMap.listeners[src]) {
+        downloadMap.listeners[src] = {};
+    }
+    if (!downloadMap.listeners[src][downloadDir]) {
+        downloadMap.listeners[src][downloadDir] = [];
+    }
+    if (!downloadMap.isDownloadingMap[src]) {
+        downloadMap.isDownloadingMap[src] = {};
+    }
+    downloadMap.isDownloadingMap[src][downloadDir] = false;
+    if (!downloadMap.hasBeenDownloadedMap[src]) {
+        downloadMap.hasBeenDownloadedMap[src] = {};
+    }
+    downloadMap.hasBeenDownloadedMap[src][downloadDir] = to;
+    downloadMap.listeners[src][downloadDir].forEach((fn) => fn());
+};
+const validateMimeType = (mimeType, src) => {
+    if (!mimeType.includes('/')) {
+        const errMessage = [
+            'A data URL was passed but did not have the correct format so that Remotion could convert it for the video to be rendered.',
+            'The format of the data URL must be `data:[mime-type];[encoding],[data]`.',
+            'The `mime-type` parameter must be a valid mime type.',
+            'The data that was received is (truncated to 100 characters):',
+            src.substr(0, 100),
+        ].join(' ');
+        throw new TypeError(errMessage);
+    }
+};
+function validateBufferEncoding(potentialEncoding, dataUrl) {
+    const asserted = potentialEncoding;
+    const validEncodings = [
+        'ascii',
+        'base64',
+        'base64url',
+        'binary',
+        'hex',
+        'latin1',
+        'ucs-2',
+        'ucs2',
+        'utf-8',
+        'utf16le',
+        'utf8',
+    ];
+    if (!validEncodings.find((en) => asserted === en)) {
+        const errMessage = [
+            'A data URL was passed but did not have the correct format so that Remotion could convert it for the video to be rendered.',
+            'The format of the data URL must be `data:[mime-type];[encoding],[data]`.',
+            'The `encoding` parameter must be one of the following:',
+            `${validEncodings.join(' ')}.`,
+            'The data that was received is (truncated to 100 characters):',
+            dataUrl.substr(0, 100),
+        ].join(' ');
+        throw new TypeError(errMessage);
+    }
+}
+const downloadAsset = async ({ src, downloadMap, indent, logLevel, shouldAnalyzeAudioImmediately, binariesDirectory, cancelSignalForAudioAnalysis, audioStreamIndex, }) => {
+    var _a, _b, _c;
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    const { downloadDir } = downloadMap;
+    if ((_a = downloadMap.hasBeenDownloadedMap[src]) === null || _a === void 0 ? void 0 : _a[downloadDir]) {
+        const claimedDownloadLocation = (_b = downloadMap.hasBeenDownloadedMap[src]) === null || _b === void 0 ? void 0 : _b[downloadDir];
+        // The OS might have deleted the file since even though we marked it as downloaded. In that case we reset the state and download it again
+        if (node_fs_1.default.existsSync(claimedDownloadLocation)) {
+            return claimedDownloadLocation;
+        }
+        downloadMap.hasBeenDownloadedMap[src][downloadDir] = null;
+        if (!downloadMap.isDownloadingMap[src]) {
+            downloadMap.isDownloadingMap[src] = {};
+        }
+        downloadMap.isDownloadingMap[src][downloadDir] = false;
+    }
+    if ((_c = downloadMap.isDownloadingMap[src]) === null || _c === void 0 ? void 0 : _c[downloadDir]) {
+        return waitForAssetToBeDownloaded({ downloadMap, src, downloadDir });
+    }
+    if (!downloadMap.isDownloadingMap[src]) {
+        downloadMap.isDownloadingMap[src] = {};
+    }
+    downloadMap.isDownloadingMap[src][downloadDir] = true;
+    downloadMap.emitter.dispatchDownload(src);
+    if (src.startsWith('data:')) {
+        const [assetDetails, assetData] = src.substring('data:'.length).split(',');
+        if (!assetDetails.includes(';')) {
+            const errMessage = [
+                'A data URL was passed but did not have the correct format so that Remotion could convert it for the video to be rendered.',
+                'The format of the data URL must be `data:[mime-type];[encoding],[data]`.',
+                'The data that was received is (truncated to 100 characters):',
+                src.substring(0, 100),
+            ].join(' ');
+            throw new TypeError(errMessage);
+        }
+        const [mimeType, encoding] = assetDetails.split(';');
+        validateMimeType(mimeType, src);
+        validateBufferEncoding(encoding, src);
+        const output = (0, exports.getSanitizedFilenameForAssetUrl)({
+            contentDisposition: null,
+            downloadDir,
+            src,
+            contentType: mimeType,
+        });
+        (0, ensure_output_directory_1.ensureOutputDirectory)(output);
+        const buff = Buffer.from(assetData, encoding);
+        await node_fs_1.default.promises.writeFile(output, buff);
+        notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to: output });
+        return output;
+    }
+    const { to } = await (0, download_file_1.downloadFile)({
+        url: src,
+        onProgress: (progress) => {
+            downloadMap.emitter.dispatchDownloadProgress(src, progress.percent, progress.downloaded, progress.totalSize);
+        },
+        to: (contentDisposition, contentType) => (0, exports.getSanitizedFilenameForAssetUrl)({
+            contentDisposition,
+            downloadDir,
+            src,
+            contentType,
+        }),
+        indent,
+        logLevel,
+    });
+    notifyAssetIsDownloaded({ src, downloadMap, downloadDir, to });
+    if (shouldAnalyzeAudioImmediately) {
+        await (0, get_audio_channels_1.getAudioChannelsAndDuration)({
+            binariesDirectory,
+            downloadMap,
+            src: to,
+            indent,
+            logLevel,
+            cancelSignal: cancelSignalForAudioAnalysis,
+            audioStreamIndex,
+        });
+    }
+    return to;
+};
+exports.downloadAsset = downloadAsset;
+const markAllAssetsAsDownloaded = (downloadMap) => {
+    Object.keys(downloadMap.hasBeenDownloadedMap).forEach((key) => {
+        delete downloadMap.hasBeenDownloadedMap[key];
+    });
+    Object.keys(downloadMap.isDownloadingMap).forEach((key) => {
+        delete downloadMap.isDownloadingMap[key];
+    });
+};
+exports.markAllAssetsAsDownloaded = markAllAssetsAsDownloaded;
+const getFilename = ({ contentDisposition, src, contentType, }) => {
+    const filenameProbe = 'filename=';
+    if (contentDisposition === null || contentDisposition === void 0 ? void 0 : contentDisposition.includes(filenameProbe)) {
+        const start = contentDisposition.indexOf(filenameProbe);
+        const onlyFromFileName = contentDisposition.substring(start + filenameProbe.length);
+        const hasSemi = onlyFromFileName.indexOf(';');
+        if (hasSemi === -1) {
+            return { pathname: onlyFromFileName.trim(), search: '' };
+        }
+        return {
+            search: '',
+            pathname: onlyFromFileName.substring(0, hasSemi).trim(),
+        };
+    }
+    const { pathname, search } = new URL(src);
+    const ext = (0, node_path_1.extname)(pathname);
+    // Has no file extension, check if we can derive it from contentType
+    if (!ext && contentType) {
+        const matchedExt = (0, mime_types_1.getExt)(contentType);
+        return {
+            pathname: `${pathname}.${matchedExt}`,
+            search,
+        };
+    }
+    return { pathname, search };
+};
+const getSanitizedFilenameForAssetUrl = ({ src, downloadDir, contentDisposition, contentType, }) => {
+    if ((0, compress_assets_1.isAssetCompressed)(src)) {
+        return src;
+    }
+    const { pathname, search } = getFilename({
+        contentDisposition,
+        contentType,
+        src,
+    });
+    const split = pathname.split('.');
+    const fileExtension = split.length > 1 && split[split.length - 1]
+        ? `.${split[split.length - 1]}`
+        : '';
+    const hashedFileName = String((0, no_react_1.random)(`${src}${pathname}${search}`)).replace('0.', '');
+    const filename = hashedFileName + fileExtension;
+    return node_path_1.default.join(downloadDir, (0, sanitize_filepath_1.sanitizeFilePath)(filename));
+};
+exports.getSanitizedFilenameForAssetUrl = getSanitizedFilenameForAssetUrl;
+const downloadAndMapAssetsToFileUrl = async ({ renderAsset, onDownload, downloadMap, logLevel, indent, binariesDirectory, cancelSignalForAudioAnalysis, shouldAnalyzeAudioImmediately, }) => {
+    const cleanup = (0, exports.attachDownloadListenerToEmitter)(downloadMap, onDownload);
+    const newSrc = await (0, exports.downloadAsset)({
+        src: renderAsset.src,
+        downloadMap,
+        indent,
+        logLevel,
+        shouldAnalyzeAudioImmediately,
+        binariesDirectory,
+        cancelSignalForAudioAnalysis,
+        audioStreamIndex: renderAsset.audioStreamIndex,
+    });
+    cleanup();
+    return {
+        ...renderAsset,
+        src: newSrc,
+    };
+};
+exports.downloadAndMapAssetsToFileUrl = downloadAndMapAssetsToFileUrl;
+const attachDownloadListenerToEmitter = (downloadMap, onDownload) => {
+    const cleanup = [];
+    if (!onDownload) {
+        return () => undefined;
+    }
+    if (downloadMap.downloadListeners.includes(onDownload)) {
+        return () => undefined;
+    }
+    downloadMap.downloadListeners.push(onDownload);
+    cleanup.push(() => {
+        downloadMap.downloadListeners = downloadMap.downloadListeners.filter((l) => l !== onDownload);
+        return Promise.resolve();
+    });
+    const cleanupDownloadListener = downloadMap.emitter.addEventListener('download', ({ detail: { src: initialSrc } }) => {
+        const progress = onDownload(initialSrc);
+        const cleanupProgressListener = downloadMap.emitter.addEventListener('progress', ({ detail: { downloaded, percent, src: progressSrc, totalSize } }) => {
+            if (initialSrc === progressSrc) {
+                progress === null || progress === void 0 ? void 0 : progress({ downloaded, percent, totalSize });
+            }
+        });
+        cleanup.push(() => {
+            cleanupProgressListener();
+            return Promise.resolve();
+        });
+    });
+    cleanup.push(() => {
+        cleanupDownloadListener();
+        return Promise.resolve();
+    });
+    return () => {
+        cleanup.forEach((c) => c());
+    };
+};
+exports.attachDownloadListenerToEmitter = attachDownloadListenerToEmitter;

package/package/dist/assets/download-file.d.ts

@@ -0,0 +1,18 @@
+import type { LogLevel } from '../log-level';
+type Response = {
+    sizeInBytes: number;
+    to: string;
+};
+type Options = {
+    url: string;
+    to: (contentDisposition: string | null, contentType: string | null) => string;
+    onProgress: ((progress: {
+        percent: number | null;
+        downloaded: number;
+        totalSize: number | null;
+    }) => void) | undefined;
+    logLevel: LogLevel;
+    indent: boolean;
+};
+export declare const downloadFile: (options: Options, retries?: number, attempt?: number) => Promise<Response>;
+export {};

package/package/dist/assets/download-file.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = void 0;
+const node_fs_1 = require("node:fs");
+const ensure_output_directory_1 = require("../ensure-output-directory");
+const logger_1 = require("../logger");
+const read_file_1 = require("./read-file");
+const incorrectContentLengthToken = 'Download finished with';
+const downloadFileWithoutRetries = ({ onProgress, url, to: toFn }) => {
+    return new Promise((resolve, reject) => {
+        let rejected = false;
+        let resolved = false;
+        let timeout;
+        const resolveAndFlag = (val) => {
+            resolved = true;
+            resolve(val);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        };
+        const rejectAndFlag = (err) => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            reject(err);
+            rejected = true;
+        };
+        const refreshTimeout = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            timeout = setTimeout(() => {
+                if (resolved) {
+                    return;
+                }
+                rejectAndFlag(new Error(`Tried to download file ${url}, but the server sent no data for 20 seconds`));
+            }, 20000);
+        };
+        refreshTimeout();
+        let finishEventSent = false;
+        let closeConnection = () => undefined;
+        (0, read_file_1.readFile)(url)
+            .then(({ response, request }) => {
+            var _a, _b;
+            closeConnection = () => {
+                request.destroy();
+                response.destroy();
+            };
+            const contentDisposition = (_a = response.headers['content-disposition']) !== null && _a !== void 0 ? _a : null;
+            const contentType = (_b = response.headers['content-type']) !== null && _b !== void 0 ? _b : null;
+            const to = toFn(contentDisposition, contentType);
+            (0, ensure_output_directory_1.ensureOutputDirectory)(to);
+            const sizeHeader = response.headers['content-length'];
+            const totalSize = typeof sizeHeader === 'undefined' ? null : Number(sizeHeader);
+            const writeStream = (0, node_fs_1.createWriteStream)(to);
+            let downloaded = 0;
+            // Listen to 'close' event instead of more
+            // concise method to avoid this problem
+            // https://github.com/remotion-dev/remotion/issues/384#issuecomment-844398183
+            writeStream.on('close', () => {
+                if (rejected) {
+                    return;
+                }
+                if (!finishEventSent) {
+                    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                        downloaded,
+                        percent: 1,
+                        totalSize: downloaded,
+                    });
+                }
+                refreshTimeout();
+                return resolveAndFlag({ sizeInBytes: downloaded, to });
+            });
+            writeStream.on('error', (err) => rejectAndFlag(err));
+            response.on('error', (err) => {
+                closeConnection();
+                rejectAndFlag(err);
+            });
+            response.pipe(writeStream).on('error', (err) => rejectAndFlag(err));
+            response.on('data', (d) => {
+                refreshTimeout();
+                downloaded += d.length;
+                refreshTimeout();
+                const percent = totalSize === null ? null : downloaded / totalSize;
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    downloaded,
+                    percent,
+                    totalSize,
+                });
+                if (percent === 1) {
+                    finishEventSent = true;
+                }
+            });
+            response.on('close', () => {
+                if (totalSize !== null && downloaded !== totalSize) {
+                    rejectAndFlag(new Error(`${incorrectContentLengthToken} ${downloaded} bytes, but expected ${totalSize} bytes from 'Content-Length'.`));
+                }
+                writeStream.close();
+                closeConnection();
+            });
+        })
+            .catch((err) => {
+            rejectAndFlag(err);
+        });
+    });
+};
+const downloadFile = async (options, retries = 2, attempt = 1) => {
+    try {
+        const res = await downloadFileWithoutRetries(options);
+        return res;
+    }
+    catch (err) {
+        const { message } = err;
+        if (message === 'aborted' ||
+            message.includes('ECONNRESET') ||
+            message.includes(incorrectContentLengthToken) ||
+            // Try again if hitting internal errors
+            message.includes('503') ||
+            message.includes('502') ||
+            message.includes('504') ||
+            message.includes('500')) {
+            if (retries === 0) {
+                throw err;
+            }
+            logger_1.Log.warn({ indent: options.indent, logLevel: options.logLevel }, `Downloading ${options.url} failed (will retry): ${message}`);
+            const backoffInSeconds = (attempt + 1) ** 2;
+            await new Promise((resolve) => {
+                setTimeout(() => resolve(), backoffInSeconds * 1000);
+            });
+            return (0, exports.downloadFile)(options, retries - 1, attempt + 1);
+        }
+        throw err;
+    }
+};
+exports.downloadFile = downloadFile;

package/package/dist/assets/download-map.d.ts

@@ -0,0 +1,55 @@
+import { OffthreadVideoServerEmitter } from '../offthread-video-server';
+import type { FrameAndAssets } from '../render-frames';
+import type { RenderMediaOnDownload } from './download-and-map-assets-to-file';
+import { type InlineAudioMixing } from './inline-audio-mixing';
+export type AudioChannelsAndDurationResultCache = {
+    channels: number;
+    duration: number | null;
+    startTime: number | null;
+};
+export type DownloadMap = {
+    id: string;
+    emitter: OffthreadVideoServerEmitter;
+    downloadListeners: RenderMediaOnDownload[];
+    isDownloadingMap: {
+        [src: string]: {
+            [downloadDir: string]: boolean;
+        } | undefined;
+    };
+    hasBeenDownloadedMap: {
+        [src: string]: {
+            [downloadDir: string]: string | null;
+        } | undefined;
+    };
+    listeners: {
+        [key: string]: {
+            [downloadDir: string]: (() => void)[];
+        };
+    };
+    durationOfAssetCache: Record<string, AudioChannelsAndDurationResultCache>;
+    downloadDir: string;
+    preEncode: string;
+    audioMixing: string;
+    complexFilter: string;
+    audioPreprocessing: string;
+    stitchFrames: string;
+    assetDir: string;
+    compositingDir: string;
+    preventCleanup: () => void;
+    allowCleanup: () => void;
+    isPreventedFromCleanup: () => boolean;
+    inlineAudioMixing: InlineAudioMixing;
+};
+export type RenderAssetInfo = {
+    assets: FrameAndAssets[];
+    imageSequenceName: string;
+    firstFrameIndex: number;
+    downloadMap: DownloadMap;
+    chunkLengthInSeconds: number;
+    trimLeftOffset: number;
+    trimRightOffset: number;
+    forSeamlessAacConcatenation: boolean;
+};
+export declare const makeAndReturn: (dir: string, name: string) => string;
+export declare const makeDownloadMap: () => DownloadMap;
+export declare const cleanDownloadMap: (downloadMap: DownloadMap) => void;

package/package/dist/assets/download-map.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanDownloadMap = exports.makeDownloadMap = exports.makeAndReturn = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const version_1 = require("remotion/version");
+const delete_directory_1 = require("../delete-directory");
+const offthread_video_server_1 = require("../offthread-video-server");
+const tmp_dir_1 = require("../tmp-dir");
+const inline_audio_mixing_1 = require("./inline-audio-mixing");
+const makeAndReturn = (dir, name) => {
+    const p = node_path_1.default.join(dir, name);
+    (0, node_fs_1.mkdirSync)(p);
+    return p;
+};
+exports.makeAndReturn = makeAndReturn;
+const makeDownloadMap = () => {
+    const dir = (0, tmp_dir_1.tmpDir)(`remotion-v${version_1.VERSION}-assets`);
+    let prevented = false;
+    return {
+        isDownloadingMap: {},
+        hasBeenDownloadedMap: {},
+        listeners: {},
+        durationOfAssetCache: {},
+        id: String(Math.random()),
+        assetDir: dir,
+        downloadListeners: [],
+        downloadDir: (0, exports.makeAndReturn)(dir, 'remotion-assets-dir'),
+        complexFilter: (0, exports.makeAndReturn)(dir, 'remotion-complex-filter'),
+        preEncode: (0, exports.makeAndReturn)(dir, 'pre-encode'),
+        audioMixing: (0, exports.makeAndReturn)(dir, 'remotion-audio-mixing'),
+        audioPreprocessing: (0, exports.makeAndReturn)(dir, 'remotion-audio-preprocessing'),
+        stitchFrames: (0, exports.makeAndReturn)(dir, 'remotion-stitch-temp-dir'),
+        compositingDir: (0, exports.makeAndReturn)(dir, 'remotion-compositing-temp-dir'),
+        emitter: new offthread_video_server_1.OffthreadVideoServerEmitter(),
+        preventCleanup: () => {
+            prevented = true;
+        },
+        allowCleanup: () => {
+            prevented = false;
+        },
+        isPreventedFromCleanup: () => {
+            return prevented;
+        },
+        inlineAudioMixing: (0, inline_audio_mixing_1.makeInlineAudioMixing)(dir),
+    };
+};
+exports.makeDownloadMap = makeDownloadMap;
+const cleanDownloadMap = (downloadMap) => {
+    if (downloadMap.isPreventedFromCleanup()) {
+        return;
+    }
+    (0, delete_directory_1.deleteDirectory)(downloadMap.downloadDir);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.complexFilter);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.compositingDir);
+    downloadMap.inlineAudioMixing.cleanup();
+    // Assets dir must be last since the others are contained
+    (0, delete_directory_1.deleteDirectory)(downloadMap.assetDir);
+};
+exports.cleanDownloadMap = cleanDownloadMap;

package/package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -0,0 +1,12 @@
+import type { AssetVolume } from './types';
+type FfmpegEval = 'once' | 'frame';
+type FfmpegVolumeExpression = {
+    eval: FfmpegEval;
+    value: string;
+};
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, }: {
+    volume: AssetVolume;
+    trimLeft: number;
+    fps: number;
+}) => FfmpegVolumeExpression;
+export {};