@remotion/renderer 3.3.41 → 3.3.43

package/client.d.ts

@@ -0,0 +1 @@
+export * from './dist/client';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client');

package/dist/audio-codec.d.ts

@@ -0,0 +1,27 @@
+import type { Codec } from './codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export declare type AudioCodec = typeof validAudioCodecs[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["aac", "pcm-16"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare const audioCodecNames: readonly ["pcm_s16le", "aac", "libmp3lame", "libopus"];
+export declare type FfmpegAudioCodecName = typeof audioCodecNames[number];
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [k in 'compressed' | 'lossless']: typeof supportedAudioCodecs[key][number] | null;
+    };
+};
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: Codec;
+    preferLossless: boolean;
+}) => AudioCodec | null;

package/dist/audio-codec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.audioCodecNames = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+exports.audioCodecNames = [
+    'pcm_s16le',
+    'aac',
+    'libmp3lame',
+    'libopus',
+];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        // V4.0: Make pcm the default
+        compressed: 'aac',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/client.d.ts

@@ -1,10 +1,178 @@
 export declare const BrowserSafeApis: {
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
     getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
     getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
     isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
-    proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: readonly [];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["pcm-16", "aac"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {};
+        };
+    };
+    defaultAudioCodecs: {
+        h264: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        h265: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        vp8: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        vp9: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        mp3: {
+            compressed: "mp3" | "pcm-16" | null;
+            lossless: "mp3" | "pcm-16" | null;
+        };
+        aac: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        wav: {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        prores: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        "h264-mkv": {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        gif: {
+            compressed: null;
+            lossless: null;
+        };
+    };
 };

package/dist/client.js

@@ -1,19 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrowserSafeApis = void 0;
+const audio_codec_1 = require("./audio-codec");
 const codec_1 = require("./codec");
 const crf_1 = require("./crf");
+const file_extensions_1 = require("./file-extensions");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const is_audio_codec_1 = require("./is-audio-codec");
 const pixel_format_1 = require("./pixel-format");
-const prores_profile_1 = require("./prores-profile");
 exports.BrowserSafeApis = {
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
     validCodecs: codec_1.validCodecs,
     getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
     getValidCrfRanges: crf_1.getValidCrfRanges,
     isAudioCodec: is_audio_codec_1.isAudioCodec,
-    proResProfileOptions: prores_profile_1.proResProfileOptions,
     validPixelFormats: pixel_format_1.validPixelFormats,
     DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    supportedAudioCodecs: file_extensions_1.supportedAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    defaultAudioCodecs: audio_codec_1.defaultAudioCodecs,
 };

package/dist/combine-videos.d.ts

@@ -1,3 +1,4 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
 import type { FfmpegExecutable } from './ffmpeg-executable';
 declare type Options = {
@@ -11,6 +12,7 @@ declare type Options = {
     numberOfGifLoops: number | null;
     remotionRoot: string;
     ffmpegExecutable: FfmpegExecutable;
+    audioCodec: AudioCodec | null;
 };
 export declare const combineVideos: (options: Options) => Promise<void>;
 export {};

package/dist/combine-videos.js

@@ -8,17 +8,18 @@ exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const path_1 = require("path");
+const audio_codec_1 = require("./audio-codec");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
-const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const truthy_1 = require("./truthy");
 const combineVideos = async (options) => {
     var _a;
-    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, } = options;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, audioCodec, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
     try {
         const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
@@ -37,8 +38,10 @@ const combineVideos = async (options) => {
                     : '-1',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-c:v',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : codec === 'gif' ? 'gif' : 'copy',
-            '-c:a',
-            (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            resolvedAudioCodec ? '-c:a' : null,
+            resolvedAudioCodec
+                ? (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec)
+                : null,
             // Set max bitrate up to 512kbps, will choose lower if that's too much
             '-b:a',
             '512K',

package/dist/file-extensions.d.ts

@@ -0,0 +1,25 @@
+import type { Codec } from './codec';
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["pcm-16", "aac"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'webm';
+export declare const defaultFileExtensionMap: {
+    [key in Codec]: {
+        default: FileExtension;
+        forAudioCodec: {
+            [k in typeof supportedAudioCodecs[key][number]]: {
+                possible: FileExtension[];
+                default: FileExtension;
+            };
+        };
+    };
+};

package/dist/file-extensions.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileExtensionMap = exports.supportedAudioCodecs = void 0;
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['pcm-16', 'aac'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+exports.defaultFileExtensionMap = {
+    'h264-mkv': {
+        default: 'mkv',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    aac: {
+        default: 'aac',
+        forAudioCodec: {
+            aac: {
+                possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
+                default: 'aac',
+            },
+            'pcm-16': {
+                possible: ['wav'],
+                default: 'wav',
+            },
+        },
+    },
+    gif: {
+        default: 'gif',
+        forAudioCodec: {},
+    },
+    h264: {
+        default: 'mp4',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            aac: { possible: ['mp4', 'mkv'], default: 'mp4' },
+        },
+    },
+    h265: {
+        default: 'mp4',
+        forAudioCodec: {
+            aac: { possible: ['mp4', 'mkv', 'hevc'], default: 'mp4' },
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    mp3: {
+        default: 'mp3',
+        forAudioCodec: {
+            mp3: { possible: ['mp3'], default: 'mp3' },
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+    prores: {
+        default: 'mov',
+        forAudioCodec: {
+            aac: { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+            'pcm-16': { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+        },
+    },
+    vp8: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    vp9: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    wav: {
+        default: 'wav',
+        forAudioCodec: {
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+};

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,6 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
-export declare const getFileExtensionFromCodec: (codec: Codec) => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+import type { FileExtension } from './file-extensions';
+export declare const getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;

package/dist/get-extension-from-codec.js

@@ -1,35 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileExtensionFromCodec = void 0;
+exports.defaultCodecsForFileExtension = exports.makeFileExtensionMap = exports.getFileExtensionFromCodec = void 0;
 const codec_1 = require("./codec");
-const getFileExtensionFromCodec = (codec) => {
+const file_extensions_1 = require("./file-extensions");
+const getFileExtensionFromCodec = (codec, audioCodec) => {
     if (!codec_1.validCodecs.includes(codec)) {
         throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`);
     }
-    switch (codec) {
-        case 'aac':
-            return 'aac';
-        case 'h264':
-            return 'mp4';
-        // The chunks will be rendered as mkv, but the final output will still be MP4
-        case 'h264-mkv':
-            return 'mkv';
-        case 'h265':
-            return 'mp4';
-        case 'mp3':
-            return 'mp3';
-        case 'prores':
-            return 'mov';
-        case 'vp8':
-            return 'webm';
-        case 'vp9':
-            return 'webm';
-        case 'gif':
-            return 'gif';
-        case 'wav':
-            return 'wav';
-        default:
-            throw new Error("Don't know which file extension to use for codec " + codec);
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    if (audioCodec === null) {
+        return map.default;
     }
+    const typedAudioCodec = audioCodec;
+    if (!(typedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+    }
+    return map.forAudioCodec[audioCodec]
+        .default;
 };
 exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
+const makeFileExtensionMap = () => {
+    const map = {};
+    Object.keys(file_extensions_1.defaultFileExtensionMap).forEach((_codec) => {
+        const codec = _codec;
+        const fileExtMap = file_extensions_1.defaultFileExtensionMap[codec];
+        const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
+        const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
+        const allPossibleExtensions = [
+            fileExtMap.default,
+            ...possibleExtensionsForAudioCodec.flat(1),
+        ];
+        for (const extension of allPossibleExtensions) {
+            if (!map[extension]) {
+                map[extension] = [];
+            }
+            if (!map[extension].includes(codec)) {
+                map[extension].push(codec);
+            }
+        }
+    });
+    return map;
+};
+exports.makeFileExtensionMap = makeFileExtensionMap;
+exports.defaultCodecsForFileExtension = {
+    '3gp': 'aac',
+    aac: 'aac',
+    gif: 'gif',
+    hevc: 'h265',
+    m4a: 'aac',
+    m4b: 'aac',
+    mkv: 'h264-mkv',
+    mov: 'prores',
+    mp3: 'mp3',
+    mp4: 'h264',
+    mpeg: 'aac',
+    mpg: 'aac',
+    mxf: 'prores',
+    wav: 'wav',
+    webm: 'vp8',
+};

package/dist/guess-extension-for-media.d.ts

@@ -2,4 +2,4 @@ export declare const guessExtensionForVideo: ({ src, remotionRoot, ffprobeBinary
     src: string;
     remotionRoot: string;
     ffprobeBinary: string | null;
-}) => Promise<"mp3" | "wav" | "webm" | "mp4">;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;