@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/assets/ffmpeg-volume-expression.js

@@ -0,0 +1,96 @@
+"use strict";
+// Example is here https://ffmpeg.org/ffmpeg-filters.html#volume
+// Allowed syntax is here: https://ffmpeg.org/ffmpeg-utils.html#Expression-Evaluation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ffmpegVolumeExpression = void 0;
+// If once, ffmpeg evaluates volume expression once.
+// If frame, it evaluates it for each frame
+const round_volume_to_avoid_stack_overflow_1 = require("./round-volume-to-avoid-stack-overflow");
+// In FFMPEG expressions, the current time is represented by 't'
+// the `n` for the timestamp variable is buggy
+const FFMPEG_TIME_VARIABLE = 't';
+const ffmpegIfOrElse = (condition, then, elseDo) => {
+    return `if(${condition},${then},${elseDo})`;
+};
+const ffmpegIsOneOfFrames = ({ frames, trimLeft, fps, }) => {
+    const consecutiveArrays = [];
+    for (let i = 0; i < frames.length; i++) {
+        const previousFrame = frames[i - 1];
+        const frame = frames[i];
+        if (previousFrame === undefined || frame !== previousFrame + 1) {
+            consecutiveArrays.push([]);
+        }
+        consecutiveArrays[consecutiveArrays.length - 1].push(frame);
+    }
+    return consecutiveArrays
+        .map((f) => {
+        const firstFrame = f[0];
+        const lastFrame = f[f.length - 1];
+        const before = (firstFrame - 0.5) / fps;
+        const after = (lastFrame + 0.5) / fps;
+        return `between(${FFMPEG_TIME_VARIABLE},${(before + trimLeft).toFixed(4)},${(after + trimLeft).toFixed(4)})`;
+    })
+        .join('+');
+};
+const ffmpegBuildVolumeExpression = ({ arr, delay, fps, }) => {
+    if (arr.length === 0) {
+        throw new Error('Volume array expression should never have length 0');
+    }
+    if (arr.length === 1) {
+        return String(arr[0][0]);
+    }
+    const [first, ...rest] = arr;
+    const [volume, frames] = first;
+    return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression({ arr: rest, delay, fps }));
+};
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, }) => {
+    // If it's a static volume, we return it and tell
+    // FFMPEG it only has to evaluate it once
+    if (typeof volume === 'number') {
+        return {
+            eval: 'once',
+            value: String(volume),
+        };
+    }
+    if ([...new Set(volume)].length === 1) {
+        return (0, exports.ffmpegVolumeExpression)({
+            volume: volume[0],
+            fps,
+            trimLeft,
+        });
+    }
+    // A 1 sec video with frames 0-29 would mean that
+    // frame 29 corresponds to timestamp 0.966666...
+    // but the audio is actually 1 sec long. For that reason we pad the last
+    // timestamp.
+    const paddedVolume = [...volume, volume[volume.length - 1]];
+    // Otherwise, we construct an FFMPEG expression. First step:
+    // Make a map of all possible volumes
+    // {possibleVolume1} => [frame1, frame2]
+    // {possibleVolume2} => [frame3, frame4]
+    const volumeMap = {};
+    paddedVolume.forEach((baseVolume, frame) => {
+        // Adjust volume based on how many other tracks have not yet finished
+        const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(baseVolume);
+        if (!volumeMap[actualVolume]) {
+            volumeMap[actualVolume] = [];
+        }
+        volumeMap[actualVolume].push(frame);
+    });
+    // Sort the map so that the most common volume is last
+    // this is going to be the else statement so the expression is short
+    const volumeArray = Object.keys(volumeMap)
+        .map((key) => [Number(key), volumeMap[key]])
+        .sort((a, b) => a[1].length - b[1].length);
+    // Construct and tell FFMPEG it has to evaluate expression on each frame
+    const expression = ffmpegBuildVolumeExpression({
+        arr: volumeArray,
+        delay: trimLeft,
+        fps,
+    });
+    return {
+        eval: 'frame',
+        value: `'${expression}'`,
+    };
+};
+exports.ffmpegVolumeExpression = ffmpegVolumeExpression;

package/package/dist/assets/flatten-volume-array.d.ts

@@ -0,0 +1,3 @@
+import type { AssetVolume, MediaAsset } from './types';
+export declare const flattenVolumeArray: (volume: AssetVolume) => AssetVolume;
+export declare const convertAssetToFlattenedVolume: (asset: MediaAsset) => MediaAsset;

package/package/dist/assets/flatten-volume-array.js

@@ -0,0 +1,26 @@
+"use strict";
+// An input is an array with volume levels for each frame, like
+// [1, 1, 1, 1, 1, ...].
+// If all elements are the same, we flatten it to `1`, otherwise we leave it as an array.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAssetToFlattenedVolume = exports.flattenVolumeArray = void 0;
+const flattenVolumeArray = (volume) => {
+    if (typeof volume === 'number') {
+        return volume;
+    }
+    if (volume.length === 0) {
+        throw new TypeError('Volume array must have at least 1 number');
+    }
+    if (new Set(volume).size === 1) {
+        return volume[0];
+    }
+    return volume;
+};
+exports.flattenVolumeArray = flattenVolumeArray;
+const convertAssetToFlattenedVolume = (asset) => {
+    return {
+        ...asset,
+        volume: (0, exports.flattenVolumeArray)(asset.volume),
+    };
+};
+exports.convertAssetToFlattenedVolume = convertAssetToFlattenedVolume;

package/package/dist/assets/get-audio-channels.d.ts

@@ -0,0 +1,20 @@
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+import type { AudioChannelsAndDurationResultCache, DownloadMap } from './download-map';
+export declare const getAudioChannelsAndDurationWithoutCache: ({ src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }: {
+    src: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    audioStreamIndex: number | undefined;
+}) => Promise<AudioChannelsAndDurationResultCache>;
+export declare const getAudioChannelsAndDuration: ({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }: {
+    downloadMap: DownloadMap;
+    src: string;
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    audioStreamIndex: number | undefined;
+}) => Promise<AudioChannelsAndDurationResultCache>;

package/package/dist/assets/get-audio-channels.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioChannelsAndDuration = exports.getAudioChannelsAndDurationWithoutCache = void 0;
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const getAudioChannelsAndDurationWithoutCache = async ({ src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) => {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', audioStreamIndex ? `a:${audioStreamIndex}` : 'a:0'],
+        [
+            '-show_entries',
+            'stream=channels:stream=start_time:format=duration:format=format_name',
+        ],
+        ['-of', 'default=nw=1'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    try {
+        const task = await (0, call_ffmpeg_1.callFf)({
+            bin: 'ffprobe',
+            args,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignal,
+        });
+        const channels = task.stdout.match(/channels=([0-9]+)/);
+        const duration = task.stdout.match(/duration=([0-9.]+)/);
+        const startTime = task.stdout.match(/start_time=([0-9.]+)/);
+        const container = task.stdout.match(/format_name=([a-zA-Z0-9.]+)/);
+        const isMP3 = container ? container[1] === 'mp3' : false;
+        const result = {
+            channels: channels ? parseInt(channels[1], 10) : 0,
+            duration: duration ? parseFloat(duration[1]) : null,
+            // We ignore the start time for MP3 because that is an inherent encoder thing
+            // not in the sense that we want
+            startTime: startTime ? (isMP3 ? 0 : parseFloat(startTime[1])) : null,
+        };
+        return result;
+    }
+    catch (err) {
+        if (err.message.includes('This file cannot be read by `ffprobe`. Is it a valid multimedia file?')) {
+            throw new Error('This file cannot be read by `ffprobe`. Is it a valid multimedia file?');
+        }
+        throw err;
+    }
+};
+exports.getAudioChannelsAndDurationWithoutCache = getAudioChannelsAndDurationWithoutCache;
+async function getAudioChannelsAndDurationUnlimited({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) {
+    const cacheKey = audioStreamIndex ? `${src}-${audioStreamIndex}` : src;
+    if (downloadMap.durationOfAssetCache[cacheKey]) {
+        return downloadMap.durationOfAssetCache[cacheKey];
+    }
+    const result = await (0, exports.getAudioChannelsAndDurationWithoutCache)({
+        src,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        audioStreamIndex,
+    });
+    downloadMap.durationOfAssetCache[cacheKey] = result;
+    return result;
+}
+const getAudioChannelsAndDuration = ({ downloadMap, src, indent, logLevel, binariesDirectory, cancelSignal, audioStreamIndex, }) => {
+    return limit(() => getAudioChannelsAndDurationUnlimited({
+        downloadMap,
+        src,
+        indent,
+        logLevel,
+        binariesDirectory,
+        cancelSignal,
+        audioStreamIndex,
+    }));
+};
+exports.getAudioChannelsAndDuration = getAudioChannelsAndDuration;

package/package/dist/assets/inline-audio-mixing.d.ts

@@ -0,0 +1,22 @@
+import type { InlineAudioAsset } from 'remotion/no-react';
+import type { LogLevel } from '../log-level';
+import type { CancelSignal } from '../make-cancel-signal';
+export declare const makeInlineAudioMixing: (dir: string) => {
+    cleanup: () => void;
+    addAsset: ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }: {
+        asset: InlineAudioAsset;
+        fps: number;
+        totalNumberOfFrames: number;
+        firstFrame: number;
+        trimLeftOffset: number;
+        trimRightOffset: number;
+    }) => void;
+    getListOfAssets: () => string[];
+    finish: ({ binariesDirectory, indent, logLevel, cancelSignal, }: {
+        indent: boolean;
+        logLevel: LogLevel;
+        binariesDirectory: string | null;
+        cancelSignal: CancelSignal | undefined;
+    }) => Promise<void>;
+};
+export type InlineAudioMixing = ReturnType<typeof makeInlineAudioMixing>;

package/package/dist/assets/inline-audio-mixing.js

@@ -0,0 +1,189 @@
+"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.makeInlineAudioMixing = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const delete_directory_1 = require("../delete-directory");
+const sample_rate_1 = require("../sample-rate");
+const apply_tone_frequency_1 = require("./apply-tone-frequency");
+const download_map_1 = require("./download-map");
+const numberTo32BiIntLittleEndian = (num) => {
+    return new Uint8Array([
+        num & 0xff,
+        (num >> 8) & 0xff,
+        (num >> 16) & 0xff,
+        (num >> 24) & 0xff,
+    ]);
+};
+const numberTo16BitLittleEndian = (num) => {
+    return new Uint8Array([num & 0xff, (num >> 8) & 0xff]);
+};
+const BIT_DEPTH = 16;
+const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
+const NUMBER_OF_CHANNELS = 2;
+const makeInlineAudioMixing = (dir) => {
+    const folderToAdd = (0, download_map_1.makeAndReturn)(dir, 'remotion-inline-audio-mixing');
+    // asset id -> file descriptor
+    const openFiles = {};
+    const writtenHeaders = {};
+    const toneFrequencies = {};
+    const cleanup = () => {
+        for (const fd of Object.values(openFiles)) {
+            try {
+                node_fs_1.default.closeSync(fd);
+            }
+            catch (_a) { }
+        }
+        (0, delete_directory_1.deleteDirectory)(folderToAdd);
+    };
+    const getListOfAssets = () => {
+        return Object.keys(openFiles);
+    };
+    const getFilePath = (asset) => {
+        return node_path_1.default.join(folderToAdd, `${asset.id}.wav`);
+    };
+    const ensureAsset = ({ asset, fps, totalNumberOfFrames, trimLeftOffset, trimRightOffset, }) => {
+        const filePath = getFilePath(asset);
+        if (!openFiles[filePath]) {
+            openFiles[filePath] = node_fs_1.default.openSync(filePath, 'w');
+        }
+        if (writtenHeaders[filePath]) {
+            return;
+        }
+        writtenHeaders[filePath] = true;
+        const expectedDataSize = Math.round((totalNumberOfFrames / fps - trimLeftOffset + trimRightOffset) *
+            NUMBER_OF_CHANNELS *
+            sample_rate_1.DEFAULT_SAMPLE_RATE *
+            BYTES_PER_SAMPLE);
+        const expectedSize = 40 + expectedDataSize;
+        const fd = openFiles[filePath];
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([0x52, 0x49, 0x46, 0x46]), 0, 4, 0); // "RIFF"
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedSize)), 0, 4, 4); // Remaining size
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([0x57, 0x41, 0x56, 0x45]), 0, 4, 8); // "WAVE"
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([0x66, 0x6d, 0x74, 0x20]), 0, 4, 12); // "fmt "
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([BIT_DEPTH, 0x00, 0x00, 0x00]), 0, 4, 16); // fmt chunk size = 16
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([0x01, 0x00]), 0, 2, 20); // Audio format (PCM) = 1, set 3 if float32 would be true
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([NUMBER_OF_CHANNELS, 0x00]), 0, 2, 22); // Number of channels
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sample_rate_1.DEFAULT_SAMPLE_RATE)), 0, 4, 24); // Sample rate
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(sample_rate_1.DEFAULT_SAMPLE_RATE * NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 4, 28); // Byte rate
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo16BitLittleEndian(NUMBER_OF_CHANNELS * BYTES_PER_SAMPLE)), 0, 2, 32); // Block align
+        (0, node_fs_1.writeSync)(fd, numberTo16BitLittleEndian(BIT_DEPTH), 0, 2, 34); // Bits per sample
+        (0, node_fs_1.writeSync)(fd, new Uint8Array([0x64, 0x61, 0x74, 0x61]), 0, 4, 36); // "data"
+        (0, node_fs_1.writeSync)(fd, new Uint8Array(numberTo32BiIntLittleEndian(expectedDataSize)), 0, 4, 40); // Remaining size
+    };
+    const finish = async ({ binariesDirectory, indent, logLevel, cancelSignal, }) => {
+        for (const fd of Object.keys(openFiles)) {
+            const frequency = toneFrequencies[fd];
+            if (frequency !== 1) {
+                const tmpFile = fd.replace(/.wav$/, '-tmp.wav');
+                await (0, apply_tone_frequency_1.applyToneFrequencyUsingFfmpeg)({
+                    input: fd,
+                    output: tmpFile,
+                    toneFrequency: frequency,
+                    indent,
+                    logLevel,
+                    binariesDirectory,
+                    cancelSignal,
+                });
+                node_fs_1.default.renameSync(tmpFile, fd);
+            }
+        }
+    };
+    const addAsset = ({ asset, fps, totalNumberOfFrames, firstFrame, trimLeftOffset, trimRightOffset, }) => {
+        ensureAsset({
+            asset,
+            fps,
+            totalNumberOfFrames,
+            trimLeftOffset,
+            trimRightOffset,
+        });
+        const filePath = getFilePath(asset);
+        if (toneFrequencies[filePath] !== undefined &&
+            toneFrequencies[filePath] !== asset.toneFrequency) {
+            throw new Error(`toneFrequency must be the same across the entire audio, got ${asset.toneFrequency}, but before it was ${toneFrequencies[filePath]}`);
+        }
+        const fileDescriptor = openFiles[filePath];
+        toneFrequencies[filePath] = asset.toneFrequency;
+        let arr = new Int16Array(asset.audio);
+        const isFirst = asset.frame === firstFrame;
+        const isLast = asset.frame === totalNumberOfFrames + firstFrame - 1;
+        const samplesToShaveFromStart = trimLeftOffset * sample_rate_1.DEFAULT_SAMPLE_RATE;
+        const samplesToShaveFromEnd = trimRightOffset * sample_rate_1.DEFAULT_SAMPLE_RATE;
+        if (Math.abs(Math.round(samplesToShaveFromEnd) - samplesToShaveFromEnd) >
+            0.0000001) {
+            throw new Error(`samplesToShaveFromEnd should be approximately an integer, is${samplesToShaveFromEnd}`);
+        }
+        if (Math.abs(Math.round(samplesToShaveFromStart) - samplesToShaveFromStart) >
+            0.0000001) {
+            throw new Error(`samplesToShaveFromStart should be approximately an integer, is ${samplesToShaveFromStart}`);
+        }
+        if (isFirst) {
+            arr = arr.slice(Math.round(samplesToShaveFromStart) * NUMBER_OF_CHANNELS);
+        }
+        if (isLast) {
+            arr = arr.slice(0, arr.length + Math.round(samplesToShaveFromEnd) * NUMBER_OF_CHANNELS);
+        }
+        const positionInSeconds = (asset.frame - firstFrame) / fps - (isFirst ? 0 : trimLeftOffset);
+        // Always rounding down to ensure there are no gaps when the samples don't align
+        // In @remotion/media, we also round down the sample start timestamp and round up the end timestamp
+        // This might lead to overlapping, hopefully aligning perfectly!
+        // Test case: https://github.com/remotion-dev/remotion/issues/5758
+        const position = Math.floor(positionInSeconds * sample_rate_1.DEFAULT_SAMPLE_RATE) *
+            NUMBER_OF_CHANNELS *
+            BYTES_PER_SAMPLE;
+        (0, node_fs_1.writeSync)(
+        // fs
+        fileDescriptor, 
+        // data
+        arr, 
+        // offset of data
+        0, 
+        // length
+        arr.byteLength, 
+        // position
+        44 + position);
+    };
+    return {
+        cleanup,
+        addAsset,
+        getListOfAssets,
+        finish,
+    };
+};
+exports.makeInlineAudioMixing = makeInlineAudioMixing;

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

@@ -0,0 +1,7 @@
+import http from 'node:http';
+type NodeRequestAndResponse = {
+    request: http.ClientRequest;
+    response: http.IncomingMessage;
+};
+export declare const readFile: (url: string, redirectsSoFar?: number) => Promise<NodeRequestAndResponse>;
+export {};

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

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = void 0;
+const https_1 = __importDefault(require("https"));
+const node_http_1 = __importDefault(require("node:http"));
+const redirect_status_codes_1 = require("../redirect-status-codes");
+const truthy_1 = require("../truthy");
+const getClient = (url) => {
+    if (url.startsWith('https://')) {
+        return https_1.default.get;
+    }
+    if (url.startsWith('http://')) {
+        return node_http_1.default.get;
+    }
+    throw new Error(`Can only download URLs starting with http:// or https://, got "${url}"`);
+};
+const readFileWithoutRedirect = (url) => {
+    return new Promise((resolve, reject) => {
+        const client = getClient(url);
+        const req = client(url, 
+        // Bun 1.1.16 does not support the `headers` option
+        typeof Bun === 'undefined'
+            ? {
+                headers: {
+                    'user-agent': 'Mozilla/5.0 (@remotion/renderer - https://remotion.dev)',
+                },
+            }
+            : {}, (res) => {
+            resolve({ request: req, response: res });
+        });
+        req.on('error', (err) => {
+            req.destroy();
+            return reject(err);
+        });
+    });
+};
+const readFile = async (url, redirectsSoFar = 0) => {
+    if (redirectsSoFar > 10) {
+        throw new Error(`Too many redirects while downloading ${url}`);
+    }
+    const { request, response } = await readFileWithoutRedirect(url);
+    if (redirect_status_codes_1.redirectStatusCodes.includes(response.statusCode)) {
+        if (!response.headers.location) {
+            throw new Error(`Received a status code ${response.statusCode} but no "Location" header while calling ${response.headers.location}`);
+        }
+        const { origin } = new URL(url);
+        const redirectUrl = new URL(response.headers.location, origin).toString();
+        request.destroy();
+        response.destroy();
+        return (0, exports.readFile)(redirectUrl, redirectsSoFar + 1);
+    }
+    if (response.statusCode >= 400) {
+        const body = await tryToObtainBody(response);
+        request.destroy();
+        response.destroy();
+        throw new Error([
+            `Received a status code of ${response.statusCode} while downloading file ${url}.`,
+            body ? `The response body was:` : null,
+            body ? `---` : null,
+            body ? body : null,
+            body ? `---` : null,
+        ]
+            .filter(truthy_1.truthy)
+            .join('\n'));
+    }
+    return { request, response };
+};
+exports.readFile = readFile;
+const tryToObtainBody = async (file) => {
+    const success = new Promise((resolve) => {
+        let data = '';
+        file.on('data', (chunk) => {
+            data += chunk;
+        });
+        file.on('end', () => {
+            resolve(data);
+        });
+        // OK even when getting an error, this is just a best effort
+        file.on('error', () => resolve(data));
+    });
+    let timeout = null;
+    const body = await Promise.race([
+        success,
+        new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                resolve(null);
+            }, 5000);
+        }),
+    ]);
+    if (timeout) {
+        clearTimeout(timeout);
+    }
+    return body;
+};

package/package/dist/assets/round-volume-to-avoid-stack-overflow.d.ts

@@ -0,0 +1 @@
+export declare const roundVolumeToAvoidStackOverflow: (volume: number) => number;

package/package/dist/assets/round-volume-to-avoid-stack-overflow.js

@@ -0,0 +1,17 @@
+"use strict";
+// FFMPEG allows expressions to have a maximum depth of 100.
+// As defined here: https://github.com/FFmpeg/FFmpeg/blob/2014b0135293c41d261757bfa1aaba51653bab8e/libavutil/eval.c#L706
+// With one depth added by the if/else statement,
+// this means we can have a maximum of 99 different volumes.
+// Therefore we round the volumes (which can only be between 0 and 1)
+// so that there are only 99 possible values.
+// We then subtract 1 again because FFMPEG is not precise and queries out of range
+// values, for which we have to provide a default
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundVolumeToAvoidStackOverflow = void 0;
+const MAX_FFMPEG_STACK_DEPTH = 98;
+const roundVolumeToAvoidStackOverflow = (volume) => {
+    return Number((Math.round(volume * (MAX_FFMPEG_STACK_DEPTH - 1)) /
+        (MAX_FFMPEG_STACK_DEPTH - 1)).toFixed(3));
+};
+exports.roundVolumeToAvoidStackOverflow = roundVolumeToAvoidStackOverflow;

package/package/dist/assets/sanitize-filename.d.ts

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

package/package/dist/assets/sanitize-filename.js

@@ -0,0 +1,58 @@
+"use strict";
+// Inlined from https://github.com/parshap/node-sanitize-filename/blob/master/index.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeFilename = void 0;
+const truncate_utf8_bytes_1 = require("./truncate-utf8-bytes");
+/**
+ * Replaces characters in strings that are illegal/unsafe for filenames.
+ * Unsafe characters are either removed or replaced by a substitute set
+ * in the optional `options` object.
+ *
+ * Illegal Characters on Various Operating Systems
+ * / ? < > \ : * | "
+ * https://kb.acronis.com/content/39790
+ *
+ * Unicode Control codes
+ * C0 0x00-0x1f & C1 (0x80-0x9f)
+ * http://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ *
+ * Reserved filenames on Unix-based systems (".", "..")
+ * Reserved filenames in Windows ("CON", "PRN", "AUX", "NUL", "COM1",
+ * "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+ * "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", and
+ * "LPT9") case-insesitively and with or without filename extensions.
+ *
+ * Capped at 255 characters in length.
+ * http://unix.stackexchange.com/questions/32795/what-is-the-maximum-allowed-filename-and-folder-size-with-ecryptfs
+ *
+ * @param  {String} input   Original filename
+ * @param  {Object} options {replacement: String | Function }
+ * @return {String}         Sanitized filename
+ */
+const illegalRe = /[/?<>\\:*|"]/g;
+// eslint-disable-next-line no-control-regex
+const controlRe = /[\x00-\x1f\x80-\x9f]/g;
+const reservedRe = /^\.+$/;
+const windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+const windowsTrailingRe = /[. ]+$/;
+function sanitize(input, replacement) {
+    if (typeof input !== 'string') {
+        throw new Error('Input must be string');
+    }
+    const sanitized = input
+        .replace(illegalRe, replacement)
+        .replace(controlRe, replacement)
+        .replace(reservedRe, replacement)
+        .replace(windowsReservedRe, replacement)
+        .replace(windowsTrailingRe, replacement);
+    return (0, truncate_utf8_bytes_1.truncateUtf8Bytes)(sanitized, 255);
+}
+const sanitizeFilename = (input) => {
+    const replacement = '';
+    const output = sanitize(input, replacement);
+    if (replacement === '') {
+        return output;
+    }
+    return sanitize(output, '');
+};
+exports.sanitizeFilename = sanitizeFilename;

package/package/dist/assets/sanitize-filepath.d.ts

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

package/package/dist/assets/sanitize-filepath.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeFilePath = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const sanitize_filename_1 = require("./sanitize-filename");
+const pathSeparators = /[/\\]/;
+const sanitizeFilePath = (pathToSanitize) => {
+    return pathToSanitize
+        .split(pathSeparators)
+        .map((s) => (0, sanitize_filename_1.sanitizeFilename)(s))
+        .join(node_path_1.default.sep);
+};
+exports.sanitizeFilePath = sanitizeFilePath;

package/package/dist/assets/truncate-utf8-bytes.d.ts

@@ -0,0 +1 @@
+export declare function truncateUtf8Bytes(string: string, byteLength: number): string;