@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/options/timeout.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delayRenderTimeoutInMillisecondsOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const TimeoutSettings_1 = require("../browser/TimeoutSettings");
+let currentTimeout = TimeoutSettings_1.DEFAULT_TIMEOUT;
+const validate = (value) => {
+    if (typeof value !== 'number') {
+        throw new Error('--timeout flag / setDelayRenderTimeoutInMilliseconds() must be a number, but got ' +
+            JSON.stringify(value));
+    }
+};
+const cliFlag = 'timeout';
+exports.delayRenderTimeoutInMillisecondsOption = {
+    name: 'delayRender() timeout',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["A number describing how long the render may take to resolve all", ' ', (0, jsx_runtime_1.jsx)("a", { href: "https://remotion.dev/docs/delay-render", children: (0, jsx_runtime_1.jsx)("code", { children: "delayRender()" }) }), ' ', "calls ", (0, jsx_runtime_1.jsx)("a", { href: "https://remotion.dev/docs/timeout", children: "before it times out" }), ". Default: ", (0, jsx_runtime_1.jsx)("code", { children: "30000" })] })),
+    ssrName: 'timeoutInMilliseconds',
+    docLink: 'https://www.remotion.dev/docs/timeout',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentTimeout !== null) {
+            validate(currentTimeout);
+            return {
+                source: 'config',
+                value: currentTimeout,
+            };
+        }
+        return {
+            source: 'default',
+            value: TimeoutSettings_1.DEFAULT_TIMEOUT,
+        };
+    },
+    setConfig: (value) => {
+        validate(value);
+        currentTimeout = value;
+    },
+};

package/package/dist/options/video-bitrate.d.ts

@@ -0,0 +1,15 @@
+export declare const videoBitrateOption: {
+    name: string;
+    cliFlag: "video-bitrate";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (bitrate: string | null) => void;
+};

package/package/dist/options/video-bitrate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.videoBitrateOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let videoBitrate = null;
+const cliFlag = 'video-bitrate';
+exports.videoBitrateOption = {
+    name: 'Video Bitrate',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Specify the target bitrate for the generated video. The syntax for FFmpeg", "'", "s", (0, jsx_runtime_1.jsx)("code", { children: "-b:v" }), " parameter should be used. FFmpeg may encode the video in a way that will not result in the exact video bitrate specified. Example values: ", (0, jsx_runtime_1.jsx)("code", { children: "512K" }), " for 512 kbps, ", (0, jsx_runtime_1.jsx)("code", { children: "1M" }), " for 1 Mbps."] })),
+    ssrName: 'videoBitrate',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#videobitrate',
+    type: '',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (videoBitrate !== null) {
+            return {
+                source: 'config',
+                value: videoBitrate,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (bitrate) => {
+        videoBitrate = bitrate;
+    },
+};

package/package/dist/options/video-cache-size.d.ts

@@ -0,0 +1,19 @@
+export declare const getMediaCacheSizeInBytes: () => number | null;
+export declare const mediaCacheSizeInBytesOption: {
+    name: string;
+    cliFlag: "media-cache-size-in-bytes";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "mediaCacheSizeInBytes";
+    docLink: string;
+    type: number | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: number;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (size: number | null) => void;
+};

package/package/dist/options/video-cache-size.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaCacheSizeInBytesOption = exports.getMediaCacheSizeInBytes = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let mediaCacheSizeInBytes = null;
+const getMediaCacheSizeInBytes = () => {
+    return mediaCacheSizeInBytes;
+};
+exports.getMediaCacheSizeInBytes = getMediaCacheSizeInBytes;
+const cliFlag = 'media-cache-size-in-bytes';
+exports.mediaCacheSizeInBytesOption = {
+    name: '@remotion/media cache size',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Specify the maximum size of the cache that ", (0, jsx_runtime_1.jsx)("code", { children: "<Video>" }), " and", ' ', (0, jsx_runtime_1.jsx)("code", { children: "<Audio>" }), " from ", (0, jsx_runtime_1.jsx)("code", { children: "@remotion/media" }), " may use combined, in bytes. ", (0, jsx_runtime_1.jsx)("br", {}), "The default is half of the available system memory when the render starts."] })),
+    ssrName: 'mediaCacheSizeInBytes',
+    docLink: 'https://www.remotion.dev/docs/media/video#setting-the-cache-size',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (mediaCacheSizeInBytes !== null) {
+            return {
+                source: 'config',
+                value: mediaCacheSizeInBytes,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (size) => {
+        mediaCacheSizeInBytes = size !== null && size !== void 0 ? size : null;
+    },
+};

package/package/dist/options/video-codec.d.ts

@@ -0,0 +1,23 @@
+import type { Codec, CodecOrUndefined } from '../codec';
+export declare const getOutputCodecOrUndefined: () => CodecOrUndefined;
+export declare const videoCodecOption: {
+    name: string;
+    cliFlag: "codec";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: Codec;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }, { compositionCodec, configFile, downloadName, outName, uiCodec, }: {
+        outName: string | null;
+        downloadName: string | null;
+        configFile: Codec | null;
+        uiCodec: Codec | null;
+        compositionCodec: Codec | null;
+    }) => {
+        value: Codec;
+        source: string;
+    };
+    setConfig: (newCodec: CodecOrUndefined) => void;
+};

package/package/dist/options/video-codec.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.videoCodecOption = exports.getOutputCodecOrUndefined = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const codec_1 = require("../codec");
+const get_extension_from_codec_1 = require("../get-extension-from-codec");
+const get_extension_of_filename_1 = require("../get-extension-of-filename");
+let codec;
+const setCodec = (newCodec) => {
+    if (newCodec === undefined) {
+        codec = undefined;
+        return;
+    }
+    if (!codec_1.validCodecs.includes(newCodec)) {
+        throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${newCodec}`);
+    }
+    codec = newCodec;
+};
+const getOutputCodecOrUndefined = () => {
+    return codec;
+};
+exports.getOutputCodecOrUndefined = getOutputCodecOrUndefined;
+const deriveCodecsFromFilename = (extension) => {
+    var _a, _b;
+    if (extension === null) {
+        return { possible: [], default: null };
+    }
+    return {
+        default: (_a = get_extension_from_codec_1.defaultCodecsForFileExtension[extension]) !== null && _a !== void 0 ? _a : null,
+        possible: (_b = (0, get_extension_from_codec_1.makeFileExtensionMap)()[extension]) !== null && _b !== void 0 ? _b : [],
+    };
+};
+const cliFlag = 'codec';
+exports.videoCodecOption = {
+    name: 'Codec',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: "H264 works well in most cases, but sometimes it's worth going for a different codec. WebM achieves higher compression but is slower to render. WebM, GIF and ProRes support transparency." })),
+    ssrName: 'codec',
+    docLink: 'https://www.remotion.dev/docs/encoding/#choosing-a-codec',
+    type: '',
+    getValue: ({ commandLine }, { compositionCodec, configFile, downloadName, outName, uiCodec, }) => {
+        if (uiCodec) {
+            return { value: uiCodec, source: 'via UI' };
+        }
+        const downloadNameExtension = (0, get_extension_of_filename_1.getExtensionOfFilename)(downloadName);
+        const outNameExtension = (0, get_extension_of_filename_1.getExtensionOfFilename)(outName);
+        const derivedDownloadCodecs = deriveCodecsFromFilename(downloadNameExtension);
+        const derivedOutNameCodecs = deriveCodecsFromFilename(outNameExtension);
+        if (derivedDownloadCodecs.possible.length > 0 &&
+            derivedOutNameCodecs.possible.length > 0 &&
+            derivedDownloadCodecs.possible.join('') !==
+                derivedOutNameCodecs.possible.join('')) {
+            throw new TypeError(`The download name is ${downloadName} but the output name is ${outName}. The file extensions must match`);
+        }
+        const cliArgument = commandLine[cliFlag];
+        if (cliArgument) {
+            if (derivedDownloadCodecs.possible.length > 0 &&
+                derivedDownloadCodecs.possible.indexOf(cliArgument) === -1) {
+                throw new TypeError(`The download name is ${downloadName} but --codec=${cliArgument} was passed. The download name implies a codec of ${derivedDownloadCodecs.possible.join(' or ')} which does not align with the --codec flag.`);
+            }
+            if (derivedOutNameCodecs.possible.length > 0 &&
+                derivedOutNameCodecs.possible.indexOf(cliArgument) === -1) {
+                throw new TypeError(`The out name is ${outName} but --codec=${cliArgument} was passed. The out name implies a codec of ${derivedOutNameCodecs.possible.join(' or ')} which does not align with the --codec flag.`);
+            }
+            return { value: cliArgument, source: 'from --codec flag' };
+        }
+        if (derivedDownloadCodecs.possible.length > 0) {
+            return {
+                value: derivedDownloadCodecs.default,
+                source: 'derived from download name',
+            };
+        }
+        if (derivedOutNameCodecs.possible.length > 0) {
+            if (compositionCodec &&
+                derivedOutNameCodecs.possible.includes(compositionCodec)) {
+                return {
+                    value: compositionCodec,
+                    source: 'derived from out name + compositionCodec from calculateMetadata',
+                };
+            }
+            if (configFile && derivedOutNameCodecs.possible.includes(configFile)) {
+                return {
+                    value: configFile,
+                    source: 'derived from out name + config file',
+                };
+            }
+            return {
+                value: derivedOutNameCodecs.default,
+                source: 'derived from out name',
+            };
+        }
+        if (compositionCodec) {
+            return { value: compositionCodec, source: 'via calculateMetadata' };
+        }
+        if (configFile) {
+            return {
+                value: configFile,
+                source: 'Config file',
+            };
+        }
+        return { value: codec_1.DEFAULT_CODEC, source: 'default' };
+    },
+    setConfig: setCodec,
+};

package/package/dist/options/webhook-custom-data.d.ts

@@ -0,0 +1,10 @@
+export declare const webhookCustomDataOption: {
+    name: string;
+    cliFlag: "webhook-custom-data";
+    description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+    ssrName: "customData";
+    docLink: string;
+    type: Record<string, unknown> | null;
+    getValue: () => never;
+    setConfig: () => never;
+};

package/package/dist/options/webhook-custom-data.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookCustomDataOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'webhook-custom-data';
+exports.webhookCustomDataOption = {
+    name: 'Webhook custom data',
+    cliFlag,
+    description: (type) => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Pass up to 1,024 bytes of a JSON-serializable object to the webhook. This data will be included in the webhook payload.", ' ', type === 'cli'
+                ? 'Alternatively, pass a file path pointing to a JSON file'
+                : null] })),
+    ssrName: 'customData',
+    docLink: 'https://www.remotion.dev/docs/lambda/webhooks',
+    type: {},
+    getValue: () => {
+        throw new Error('Option resolution not implemented');
+    },
+    setConfig: () => {
+        throw new Error('Not implemented');
+    },
+};

package/package/dist/options/x264-preset.d.ts

@@ -0,0 +1,25 @@
+import type { Codec } from '../codec';
+export declare const x264PresetOptions: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
+export type X264Preset = (typeof x264PresetOptions)[number];
+export declare const validateSelectedCodecAndPresetCombination: ({ codec, x264Preset, }: {
+    codec: Codec;
+    x264Preset: X264Preset | null;
+}) => void;
+export declare const x264Option: {
+    name: string;
+    cliFlag: "x264-preset";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "x264Preset";
+    docLink: string;
+    type: X264Preset | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: X264Preset;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (profile: X264Preset | null) => void;
+};

package/package/dist/options/x264-preset.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.x264Option = exports.validateSelectedCodecAndPresetCombination = exports.x264PresetOptions = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+exports.x264PresetOptions = [
+    'ultrafast',
+    'superfast',
+    'veryfast',
+    'faster',
+    'fast',
+    'medium',
+    'slow',
+    'slower',
+    'veryslow',
+    'placebo',
+];
+let preset = null;
+const validateSelectedCodecAndPresetCombination = ({ codec, x264Preset, }) => {
+    if (x264Preset !== null &&
+        codec !== 'h264' &&
+        codec !== 'h264-mkv' &&
+        codec !== 'h264-ts') {
+        throw new TypeError(`You have set a x264 preset but the codec is "${codec}". Set the codec to "h264" or remove the Preset profile.`);
+    }
+    if (x264Preset !== null &&
+        !exports.x264PresetOptions.includes(x264Preset)) {
+        throw new TypeError(`The Preset profile "${x264Preset}" is not valid. Valid options are ${exports.x264PresetOptions
+            .map((p) => `"${p}"`)
+            .join(', ')}`);
+    }
+};
+exports.validateSelectedCodecAndPresetCombination = validateSelectedCodecAndPresetCombination;
+const cliFlag = 'x264-preset';
+const DEFAULT_PRESET = 'medium';
+exports.x264Option = {
+    name: 'x264 Preset',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["Sets a x264 preset profile. Only applies to videos rendered with", ' ', (0, jsx_runtime_1.jsx)("code", { children: "h264" }), " codec.", (0, jsx_runtime_1.jsx)("br", {}), "Possible values: ", (0, jsx_runtime_1.jsx)("code", { children: "superfast" }), ", ", (0, jsx_runtime_1.jsx)("code", { children: "veryfast" }), ",", ' ', (0, jsx_runtime_1.jsx)("code", { children: "faster" }), ", ", (0, jsx_runtime_1.jsx)("code", { children: "fast" }), ", ", (0, jsx_runtime_1.jsx)("code", { children: "medium" }), ",", ' ', (0, jsx_runtime_1.jsx)("code", { children: "slow" }), ", ", (0, jsx_runtime_1.jsx)("code", { children: "slower" }), ", ", (0, jsx_runtime_1.jsx)("code", { children: "veryslow" }), ",", ' ', (0, jsx_runtime_1.jsx)("code", { children: "placebo" }), ".", (0, jsx_runtime_1.jsx)("br", {}), "Default: ", (0, jsx_runtime_1.jsx)("code", { children: DEFAULT_PRESET })] })),
+    ssrName: 'x264Preset',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media',
+    type: 'fast',
+    getValue: ({ commandLine }) => {
+        const value = commandLine[cliFlag];
+        if (typeof value !== 'undefined') {
+            return { value: value, source: 'cli' };
+        }
+        if (preset !== null) {
+            return { value: preset, source: 'config' };
+        }
+        return { value: null, source: 'default' };
+    },
+    setConfig: (profile) => {
+        preset = profile;
+    },
+};

package/package/dist/overwrite.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_OVERWRITE = true;

package/package/dist/overwrite.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OVERWRITE = void 0;
+exports.DEFAULT_OVERWRITE = true;

package/package/dist/p-limit.d.ts

@@ -0,0 +1 @@
+export declare const pLimit: (concurrency: number) => <Arguments extends unknown[], ReturnType>(fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType, ...args: Arguments) => Promise<ReturnType>;

package/package/dist/p-limit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = void 0;
+const pLimit = (concurrency) => {
+    const queue = [];
+    let activeCount = 0;
+    const next = () => {
+        var _a;
+        activeCount--;
+        if (queue.length > 0) {
+            (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+        }
+    };
+    const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        // eslint-disable-next-line require-await
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch (_a) { }
+        next();
+    };
+    const enqueue = (fn, resolve, ...args) => {
+        queue.push(() => run(fn, resolve, ...args));
+        (async () => {
+            var _a;
+            // This function needs to wait until the next microtask before comparing
+            // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+            // when the run function is dequeued and called. The comparison in the if-statement
+            // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.length > 0) {
+                (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+            }
+        })();
+    };
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount,
+        },
+        pendingCount: {
+            get: () => queue.length,
+        },
+        clearQueue: {
+            value: () => {
+                queue.length = 0;
+            },
+        },
+    });
+    return generator;
+};
+exports.pLimit = pLimit;

package/package/dist/parse-browser-error-stack.d.ts

@@ -0,0 +1,7 @@
+export type UnsymbolicatedStackFrame = {
+    functionName: string | null;
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+};
+export declare const parseStack: (stack: string[]) => UnsymbolicatedStackFrame[];

package/package/dist/parse-browser-error-stack.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStack = void 0;
+const regexValidFrame_Chrome = /^\s*(at|in)\s.+(:\d+)/;
+const regexValidFrame_FireFox = /(^|@)\S+:\d+|.+line\s+\d+\s+>\s+(eval|Function).+/;
+const regexExtractLocation = /\(?(.+?)(?::(\d+))?(?::(\d+))?\)?$/;
+function extractLocation(token) {
+    const execed = regexExtractLocation.exec(token);
+    if (!execed) {
+        throw new Error('Could not match in extractLocation');
+    }
+    return execed.slice(1).map((v) => {
+        const p = Number(v);
+        if (!isNaN(p)) {
+            return p;
+        }
+        return v;
+    });
+}
+const makeStackFrame = ({ functionName, fileName, lineNumber, columnNumber, }) => {
+    if (functionName && functionName.indexOf('Object.') === 0) {
+        functionName = functionName.slice('Object.'.length);
+    }
+    if (
+    // Chrome has a bug with inferring function.name:
+    // https://github.com/facebook/create-react-app/issues/2097
+    // Let's ignore a meaningless name we get for top-level modules.
+    functionName === 'friendlySyntaxErrorLabel' ||
+        functionName === 'exports.__esModule' ||
+        functionName === '<anonymous>' ||
+        !functionName) {
+        functionName = null;
+    }
+    return {
+        columnNumber,
+        fileName,
+        functionName,
+        lineNumber,
+    };
+};
+const parseStack = (stack) => {
+    const frames = stack
+        .filter((e) => regexValidFrame_Chrome.test(e) || regexValidFrame_FireFox.test(e))
+        .map((e) => {
+        if (regexValidFrame_FireFox.test(e)) {
+            // Strip eval, we don't care about it
+            let isEval = false;
+            if (/ > (eval|Function)/.test(e)) {
+                e = e.replace(/ line (\d+)(?: > eval line \d+)* > (eval|Function):\d+:\d+/g, ':$1');
+                isEval = true;
+            }
+            const _data = e.split(/[@]/g);
+            const _last = _data.pop();
+            if (!_last) {
+                throw new Error('could not get last');
+            }
+            const [_fileName, _lineNumber, _columnNumber] = extractLocation(_last);
+            return makeStackFrame({
+                functionName: _data.join('@') || (isEval ? 'eval' : null),
+                fileName: _fileName,
+                lineNumber: _lineNumber,
+                columnNumber: _columnNumber,
+            });
+        }
+        // Strip eval, we don't care about it
+        if (e.indexOf('(eval ') !== -1) {
+            e = e.replace(/(\(eval at [^()]*)|(\),.*$)/g, '');
+        }
+        if (e.indexOf('(at ') !== -1) {
+            e = e.replace(/\(at /, '(');
+        }
+        const data = e.trim().split(/\s+/g).slice(1);
+        const last = data.pop();
+        if (!last) {
+            throw new Error('could not get last');
+        }
+        const [fileName, lineNumber, columnNumber] = extractLocation(last);
+        return makeStackFrame({
+            functionName: data.join(' ') || null,
+            fileName,
+            lineNumber,
+            columnNumber,
+        });
+    });
+    return frames;
+};
+exports.parseStack = parseStack;

package/package/dist/parse-ffmpeg-progress.d.ts

@@ -0,0 +1 @@
+export declare const parseFfmpegProgress: (input: string, fps: number) => number | undefined;

package/package/dist/parse-ffmpeg-progress.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFfmpegProgress = void 0;
+const parseFfmpegProgress = (input, fps) => {
+    const match = input.match(/frame=(\s+)?([0-9]+)\s/);
+    if (match) {
+        return Number(match[2]);
+    }
+    const match2 = input.match(/time=(\d+):(\d+):(\d+).(\d+)\s/);
+    if (match2) {
+        const [, hours, minutes, seconds, hundreds] = match2;
+        return ((Number(hundreds) / 100) * fps +
+            Number(seconds) * fps +
+            Number(minutes) * fps * 60 +
+            Number(hours) * fps * 60 * 60);
+    }
+};
+exports.parseFfmpegProgress = parseFfmpegProgress;

package/package/dist/path-normalize.d.ts

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