@remotion/renderer 4.0.356 → 4.0.358

package/ensure-browser.mjs

@@ -2751,6 +2751,23 @@ var verboseTag = (str) => {
   return isColorSupported() ? chalk.bgBlack(` ${str} `) : `[${str}]`;
 };
 var Log = {
+  formatLogs: (logLevel, options, args) => {
+    return [
+      options.indent ? INDENT_TOKEN : null,
+      options.tag ? verboseTag(options.tag) : null
+    ].filter(truthy).concat(args.map((a) => {
+      if (logLevel === "warn") {
+        return chalk.yellow(a);
+      }
+      if (logLevel === "error") {
+        return chalk.red(a);
+      }
+      if (logLevel === "verbose" || logLevel === "trace") {
+        return chalk.gray(a);
+      }
+      return a;
+    }));
+  },
   trace: (options, ...args) => {
     writeInRepro("trace", ...args);
     if (isEqualOrBelowLogLevel(options.logLevel, "trace")) {
@@ -2758,10 +2775,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.gray(a))));
+      return console.log(...Log.formatLogs("trace", options, args));
     }
   },
   verbose: (options, ...args) => {
@@ -2771,10 +2785,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.gray(a))));
+      return console.log(...Log.formatLogs("verbose", options, args));
     }
   },
   info: (options, ...args) => {
@@ -2784,7 +2795,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.log(...[options.indent ? INDENT_TOKEN : null].filter(truthy).concat(args ?? []));
+      return console.log(...Log.formatLogs("info", options, args));
     }
   },
   warn: (options, ...args) => {
@@ -2794,7 +2805,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.warn(...[options.indent ? chalk.yellow(INDENT_TOKEN) : null].filter(truthy).concat(args.map((a) => chalk.yellow(a))));
+      return console.warn(...Log.formatLogs("warn", options, args));
     }
   },
   error: (options, ...args) => {
@@ -2804,10 +2815,7 @@ var Log = {
         return process.stdout.write(`
 `);
       }
-      return console.error(...[
-        options.indent ? INDENT_TOKEN : null,
-        options.tag ? verboseTag(options.tag) : null
-      ].filter(truthy).concat(args.map((a) => chalk.red(a))));
+      return console.error(...Log.formatLogs("error", options, args));
     }
   }
 };

package/package/dist/assets/apply-tone-frequency.d.ts

@@ -0,0 +1,11 @@
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+export declare const applyToneFrequencyUsingFfmpeg: ({ input, output, toneFrequency, indent, logLevel, binariesDirectory, cancelSignal, }: {
+    input: string;
+    output: string;
+    toneFrequency: number;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+}) => Promise<void>;

package/package/dist/assets/apply-tone-frequency.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyToneFrequencyUsingFfmpeg = void 0;
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const logger_1 = require("../logger");
+const sample_rate_1 = require("../sample-rate");
+const applyToneFrequencyUsingFfmpeg = async ({ input, output, toneFrequency, indent, logLevel, binariesDirectory, cancelSignal, }) => {
+    const filter = `asetrate=${sample_rate_1.DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${sample_rate_1.DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`;
+    const args = [
+        '-hide_banner',
+        '-i',
+        input,
+        ['-ac', '2'],
+        '-filter:a',
+        filter,
+        ['-c:a', 'pcm_s16le'],
+        ['-ar', String(sample_rate_1.DEFAULT_SAMPLE_RATE)],
+        '-y',
+        output,
+    ].flat(2);
+    logger_1.Log.verbose({ indent, logLevel }, 'Changing tone frequency using FFmpeg:', JSON.stringify(args.join(' ')), 'Filter:', filter);
+    const startTimestamp = Date.now();
+    const task = (0, call_ffmpeg_1.callFf)({
+        bin: 'ffmpeg',
+        args,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+    });
+    await task;
+    logger_1.Log.verbose({ indent, logLevel }, 'Changed tone frequency using FFmpeg', `${Date.now() - startTimestamp}ms`);
+};
+exports.applyToneFrequencyUsingFfmpeg = applyToneFrequencyUsingFfmpeg;

package/package/dist/assets/calculate-asset-positions.d.ts

@@ -0,0 +1,3 @@
+import type { AudioOrVideoAsset } from 'remotion/no-react';
+import type { Assets } from './types';
+export declare const calculateAssetPositions: (frames: AudioOrVideoAsset[][]) => Assets;

package/package/dist/assets/calculate-asset-positions.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAssetPositions = void 0;
+const filter_asset_types_1 = require("../filter-asset-types");
+const resolve_asset_src_1 = require("../resolve-asset-src");
+const flatten_volume_array_1 = require("./flatten-volume-array");
+const types_1 = require("./types");
+const areEqual = (a, b) => {
+    return a.id === b.id;
+};
+const findFrom = (target, renderAsset) => {
+    const index = target.findIndex((a) => areEqual(a, renderAsset));
+    if (index === -1) {
+        return false;
+    }
+    target.splice(index, 1);
+    return true;
+};
+const copyAndDeduplicateAssets = (renderAssets) => {
+    const onlyAudioAndVideo = (0, filter_asset_types_1.onlyAudioAndVideoAssets)(renderAssets);
+    const deduplicated = [];
+    for (const renderAsset of onlyAudioAndVideo) {
+        if (!deduplicated.find((d) => d.id === renderAsset.id)) {
+            deduplicated.push(renderAsset);
+        }
+    }
+    return deduplicated;
+};
+const calculateAssetPositions = (frames) => {
+    var _a, _b;
+    const assets = [];
+    const flattened = frames.flat(1);
+    for (let frame = 0; frame < frames.length; frame++) {
+        const prev = copyAndDeduplicateAssets((_a = frames[frame - 1]) !== null && _a !== void 0 ? _a : []);
+        const current = copyAndDeduplicateAssets(frames[frame]);
+        const next = copyAndDeduplicateAssets((_b = frames[frame + 1]) !== null && _b !== void 0 ? _b : []);
+        for (const asset of current) {
+            if (!findFrom(prev, asset)) {
+                assets.push({
+                    src: (0, resolve_asset_src_1.resolveAssetSrc)((0, types_1.uncompressMediaAsset)(flattened, asset).src),
+                    type: asset.type,
+                    duration: null,
+                    id: asset.id,
+                    startInVideo: frame,
+                    trimLeft: asset.mediaFrame,
+                    volume: [],
+                    playbackRate: asset.playbackRate,
+                    toneFrequency: asset.toneFrequency,
+                    audioStartFrame: asset.audioStartFrame,
+                    audioStreamIndex: asset.audioStreamIndex,
+                });
+            }
+            const found = assets.find((a) => a.duration === null && areEqual(a, asset));
+            if (!found)
+                throw new Error('something wrong');
+            if (!findFrom(next, asset)) {
+                // Duration calculation:
+                // start 0, range 0-59:
+                // 59 - 0 + 1 ==> 60 frames duration
+                found.duration = frame - found.startInVideo + 1;
+            }
+            found.volume = [...found.volume, asset.volume];
+        }
+    }
+    for (const asset of assets) {
+        if (asset.duration === null) {
+            throw new Error('duration is unexpectedly null');
+        }
+    }
+    return assets.map((a) => (0, flatten_volume_array_1.convertAssetToFlattenedVolume)(a));
+};
+exports.calculateAssetPositions = calculateAssetPositions;

package/package/dist/assets/calculate-atempo.d.ts

@@ -0,0 +1 @@
+export declare const calculateATempo: (playbackRate: number) => string | null;

package/package/dist/assets/calculate-atempo.js

@@ -0,0 +1,16 @@
+"use strict";
+// Solving this problem of FFMPEG:
+// https://trac.ffmpeg.org/wiki/How%20to%20speed%20up%20/%20slow%20down%20a%20video
+// "The atempo filter is limited to using values between 0.5 and 2.0 (so it can slow it down to no less than half the original speed, and speed up to no more than double the input). If you need to, you can get around this limitation by stringing multiple atempo filters together. The following with quadruple the audio speed:"
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateATempo = void 0;
+const calculateATempo = (playbackRate) => {
+    if (playbackRate === 1) {
+        return null;
+    }
+    if (playbackRate >= 0.5 && playbackRate <= 2) {
+        return `atempo=${playbackRate.toFixed(5)}`;
+    }
+    return `${(0, exports.calculateATempo)(Math.sqrt(playbackRate))},${(0, exports.calculateATempo)(Math.sqrt(playbackRate))}`;
+};
+exports.calculateATempo = calculateATempo;

package/package/dist/assets/convert-assets-to-file-urls.d.ts

@@ -0,0 +1,13 @@
+import type { AudioOrVideoAsset } from 'remotion/no-react';
+import type { LogLevel } from '../log-level';
+import type { FrameAndAssets } from '../render-frames';
+import type { RenderMediaOnDownload } from './download-and-map-assets-to-file';
+import type { DownloadMap } from './download-map';
+export declare const convertAssetsToFileUrls: ({ assets, onDownload, downloadMap, indent, logLevel, binariesDirectory, }: {
+    assets: FrameAndAssets[];
+    onDownload: RenderMediaOnDownload;
+    downloadMap: DownloadMap;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+}) => Promise<AudioOrVideoAsset[][]>;

package/package/dist/assets/convert-assets-to-file-urls.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAssetsToFileUrls = void 0;
+const download_and_map_assets_to_file_1 = require("./download-and-map-assets-to-file");
+const chunk = (input, size) => {
+    return input.reduce((arr, item, idx) => {
+        return idx % size === 0
+            ? [...arr, [item]]
+            : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
+    }, []);
+};
+const convertAssetsToFileUrls = async ({ assets, onDownload, downloadMap, indent, logLevel, binariesDirectory, }) => {
+    const chunks = chunk(assets, 1000);
+    const results = [];
+    for (const ch of chunks) {
+        const assetPromises = ch.map((frame) => {
+            const frameAssetPromises = frame.audioAndVideoAssets.map((a) => {
+                return (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
+                    renderAsset: a,
+                    onDownload,
+                    downloadMap,
+                    indent,
+                    logLevel,
+                    binariesDirectory,
+                    cancelSignalForAudioAnalysis: undefined,
+                    shouldAnalyzeAudioImmediately: true,
+                });
+            });
+            return Promise.all(frameAssetPromises);
+        });
+        const result = await Promise.all(assetPromises);
+        results.push(result);
+    }
+    return results.flat(1);
+};
+exports.convertAssetsToFileUrls = convertAssetsToFileUrls;

package/package/dist/assets/download-and-map-assets-to-file.d.ts

@@ -0,0 +1,37 @@
+import type { AudioOrVideoAsset } from 'remotion/no-react';
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+import type { DownloadMap } from './download-map';
+export type RenderMediaOnDownload = (src: string) => ((progress: {
+    percent: number | null;
+    downloaded: number;
+    totalSize: number | null;
+}) => void) | undefined | void;
+export declare const downloadAsset: ({ src, downloadMap, indent, logLevel, shouldAnalyzeAudioImmediately, binariesDirectory, cancelSignalForAudioAnalysis, audioStreamIndex, }: {
+    src: string;
+    downloadMap: DownloadMap;
+    indent: boolean;
+    logLevel: LogLevel;
+    shouldAnalyzeAudioImmediately: boolean;
+    binariesDirectory: string | null;
+    cancelSignalForAudioAnalysis: CancelSignal | undefined;
+    audioStreamIndex: number | undefined;
+}) => Promise<string>;
+export declare const markAllAssetsAsDownloaded: (downloadMap: DownloadMap) => void;
+export declare const getSanitizedFilenameForAssetUrl: ({ src, downloadDir, contentDisposition, contentType, }: {
+    src: string;
+    downloadDir: string;
+    contentDisposition: string | null;
+    contentType: string | null;
+}) => string;
+export declare const downloadAndMapAssetsToFileUrl: ({ renderAsset, onDownload, downloadMap, logLevel, indent, binariesDirectory, cancelSignalForAudioAnalysis, shouldAnalyzeAudioImmediately, }: {
+    renderAsset: AudioOrVideoAsset;
+    onDownload: RenderMediaOnDownload | null;
+    downloadMap: DownloadMap;
+    logLevel: LogLevel;
+    indent: boolean;
+    shouldAnalyzeAudioImmediately: boolean;
+    binariesDirectory: string | null;
+    cancelSignalForAudioAnalysis: CancelSignal | undefined;
+}) => Promise<AudioOrVideoAsset>;
+export declare const attachDownloadListenerToEmitter: (downloadMap: DownloadMap, onDownload: RenderMediaOnDownload | null) => () => void;

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 {};