@remotion/renderer 4.0.267 → 4.0.268

package/dist/esm/pure.mjs

@@ -0,0 +1,528 @@
+// src/is-audio-codec.ts
+var isAudioCodec = (codec) => {
+  return codec === "mp3" || codec === "aac" || codec === "wav";
+};
+
+// src/codec-supports-media.ts
+var support = {
+  "h264-mkv": {
+    audio: true,
+    video: true
+  },
+  aac: {
+    audio: true,
+    video: false
+  },
+  gif: {
+    video: true,
+    audio: false
+  },
+  h264: {
+    video: true,
+    audio: true
+  },
+  "h264-ts": {
+    video: true,
+    audio: true
+  },
+  h265: {
+    video: true,
+    audio: true
+  },
+  mp3: {
+    audio: true,
+    video: false
+  },
+  prores: {
+    audio: true,
+    video: true
+  },
+  vp8: {
+    audio: true,
+    video: true
+  },
+  vp9: {
+    audio: true,
+    video: true
+  },
+  wav: {
+    audio: true,
+    video: false
+  }
+};
+var codecSupportsMedia = (codec) => {
+  return support[codec];
+};
+
+// src/get-duration-from-frame-range.ts
+var getFramesToRender = (frameRange, everyNthFrame) => {
+  if (everyNthFrame === 0) {
+    throw new Error("everyNthFrame cannot be 0");
+  }
+  return new Array(frameRange[1] - frameRange[0] + 1).fill(true).map((_, index) => {
+    return index + frameRange[0];
+  }).filter((index) => {
+    return index % everyNthFrame === 0;
+  });
+};
+
+// src/codec.ts
+var validCodecs = [
+  "h264",
+  "h265",
+  "vp8",
+  "vp9",
+  "mp3",
+  "aac",
+  "wav",
+  "prores",
+  "h264-mkv",
+  "h264-ts",
+  "gif"
+];
+
+// src/file-extensions.ts
+var defaultFileExtensionMap = {
+  "h264-mkv": {
+    default: "mkv",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv"], default: "mkv" },
+      mp3: { possible: ["mkv"], default: "mkv" }
+    }
+  },
+  "h264-ts": {
+    default: "ts",
+    forAudioCodec: {
+      "pcm-16": { possible: ["ts"], default: "ts" },
+      aac: { possible: ["ts"], default: "ts" }
+    }
+  },
+  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", "mov"], default: "mkv" },
+      aac: { possible: ["mp4", "mkv", "mov"], default: "mp4" },
+      mp3: { possible: ["mp4", "mkv", "mov"], 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" }
+    }
+  }
+};
+
+// src/get-extension-from-codec.ts
+var getFileExtensionFromCodec = (codec, audioCodec) => {
+  if (!validCodecs.includes(codec)) {
+    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${codec}`);
+  }
+  const map = 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;
+};
+
+// src/path-normalize.ts
+var SLASH = 47;
+var DOT = 46;
+var assertPath = (path) => {
+  const t = typeof path;
+  if (t !== "string") {
+    throw new TypeError(`Expected a string, got a ${t}`);
+  }
+};
+var posixNormalize = (path, allowAboveRoot) => {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0;i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += "/" + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+};
+var decode = (s) => {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+};
+var pathNormalize = (p) => {
+  assertPath(p);
+  let path = p;
+  if (path.length === 0) {
+    return ".";
+  }
+  const isAbsolute = path.charCodeAt(0) === SLASH;
+  const trailingSeparator = path.charCodeAt(path.length - 1) === SLASH;
+  path = decode(path);
+  path = posixNormalize(path, !isAbsolute);
+  if (path.length === 0 && !isAbsolute) {
+    path = ".";
+  }
+  if (path.length > 0 && trailingSeparator) {
+    path += "/";
+  }
+  if (isAbsolute) {
+    return "/" + path;
+  }
+  return path;
+};
+
+// src/get-extension-of-filename.ts
+var getExtensionOfFilename = (filename) => {
+  if (filename === null) {
+    return null;
+  }
+  const filenameArr = pathNormalize(filename).split(".");
+  const hasExtension = filenameArr.length >= 2;
+  const filenameArrLength = filenameArr.length;
+  const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+  return extension;
+};
+
+// src/options/separate-audio.tsx
+var DEFAULT = null;
+var cliFlag = "separate-audio-to";
+var separateAudioOption = {
+  cliFlag,
+  description: () => `If set, the audio will not be included in the main output but rendered as a separate file at the location you pass. It is recommended to use an absolute path. If a relative path is passed, it is relative to the Remotion Root.`,
+  docLink: "https://remotion.dev/docs/renderer/render-media",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag]) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag]
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT
+    };
+  },
+  name: "Separate audio to",
+  setConfig: () => {
+    throw new Error("Not implemented");
+  },
+  ssrName: "separateAudioTo",
+  type: "string"
+};
+
+// src/options/audio-codec.tsx
+var validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
+var supportedAudioCodecs = {
+  h264: ["aac", "pcm-16", "mp3"],
+  "h264-mkv": ["pcm-16", "mp3"],
+  "h264-ts": ["pcm-16", "aac"],
+  aac: ["aac", "pcm-16"],
+  avi: [],
+  gif: [],
+  h265: ["aac", "pcm-16"],
+  mp3: ["mp3", "pcm-16"],
+  prores: ["aac", "pcm-16"],
+  vp8: ["opus", "pcm-16"],
+  vp9: ["opus", "pcm-16"],
+  wav: ["pcm-16"]
+};
+var _satisfies = supportedAudioCodecs;
+if (_satisfies) {
+}
+var cliFlag2 = "audio-codec";
+var ssrName = "audioCodec";
+var defaultAudioCodecs = {
+  "h264-mkv": {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  },
+  "h264-ts": {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  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",
+    compressed: "pcm-16"
+  },
+  vp8: {
+    lossless: "pcm-16",
+    compressed: "opus"
+  },
+  vp9: {
+    lossless: "pcm-16",
+    compressed: "opus"
+  },
+  wav: {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  }
+};
+var extensionMap = {
+  aac: "aac",
+  mp3: "mp3",
+  opus: "opus",
+  "pcm-16": "wav"
+};
+var resolveAudioCodec = ({
+  codec,
+  setting,
+  preferLossless,
+  separateAudioTo
+}) => {
+  let derivedFromSeparateAudioToExtension = null;
+  if (separateAudioTo) {
+    const extension = separateAudioTo.split(".").pop();
+    for (const [key, value] of Object.entries(extensionMap)) {
+      if (value === extension) {
+        derivedFromSeparateAudioToExtension = key;
+        if (!supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
+          throw new Error(`The codec is ${codec} but the audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${supportedAudioCodecs[codec].join(", ")}`);
+        }
+      }
+    }
+  }
+  if (preferLossless) {
+    const selected = getDefaultAudioCodec({ codec, preferLossless });
+    if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
+      throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+    }
+    return selected;
+  }
+  if (setting === null) {
+    if (derivedFromSeparateAudioToExtension) {
+      return derivedFromSeparateAudioToExtension;
+    }
+    return getDefaultAudioCodec({ codec, preferLossless });
+  }
+  if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
+    throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+  }
+  return setting;
+};
+var getDefaultAudioCodec = ({
+  codec,
+  preferLossless
+}) => {
+  return defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+};
+var _audioCodec = null;
+var audioCodecOption = {
+  cliFlag: cliFlag2,
+  setConfig: (audioCodec) => {
+    if (audioCodec === null) {
+      _audioCodec = null;
+      return;
+    }
+    if (!validAudioCodecs.includes(audioCodec)) {
+      throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${audioCodec}`);
+    }
+    _audioCodec = audioCodec;
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag2]) {
+      const codec = commandLine[cliFlag2];
+      if (!validAudioCodecs.includes(commandLine[cliFlag2])) {
+        throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${codec}`);
+      }
+      return {
+        source: "cli",
+        value: commandLine[cliFlag2]
+      };
+    }
+    if (_audioCodec !== null) {
+      return {
+        source: "config",
+        value: _audioCodec
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
+  docLink: "https://www.remotion.dev/docs/encoding/#audio-codec",
+  name: "Audio Codec",
+  ssrName,
+  type: "aac"
+};
+
+// src/validate-output-filename.ts
+var validateOutputFilename = ({
+  codec,
+  audioCodecSetting,
+  extension,
+  preferLossless,
+  separateAudioTo
+}) => {
+  if (!defaultFileExtensionMap[codec]) {
+    throw new TypeError(`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(defaultFileExtensionMap).join(", ")}`);
+  }
+  const map = defaultFileExtensionMap[codec];
+  const resolvedAudioCodec = resolveAudioCodec({
+    codec,
+    preferLossless,
+    setting: audioCodecSetting,
+    separateAudioTo
+  });
+  if (resolvedAudioCodec === null) {
+    if (extension !== map.default) {
+      throw new TypeError(`When using the ${codec} codec, the output filename must end in .${map.default}.`);
+    }
+    return;
+  }
+  if (!(resolvedAudioCodec in map.forAudioCodec)) {
+    throw new Error(`Audio codec ${resolvedAudioCodec} is not supported for codec ${codec}`);
+  }
+  const acceptableExtensions = map.forAudioCodec[resolvedAudioCodec].possible;
+  if (!acceptableExtensions.includes(extension) && !separateAudioTo) {
+    throw new TypeError(`When using the ${codec} codec with the ${resolvedAudioCodec} audio codec, the output filename must end in one of the following: ${acceptableExtensions.join(", ")}.`);
+  }
+};
+
+// src/pure.ts
+var NoReactAPIs = {
+  getExtensionOfFilename,
+  getFileExtensionFromCodec,
+  validateOutputFilename,
+  getFramesToRender,
+  codecSupportsMedia,
+  isAudioCodec
+};
+export {
+  NoReactAPIs
+};

package/dist/get-browser-instance.d.ts

@@ -1,11 +1,12 @@
 import type { BrowserExecutable } from './browser-executable';
+import type { BrowserLog } from './browser-log';
 import type { HeadlessBrowser } from './browser/Browser';
 import type { Page } from './browser/BrowserPage';
 import type { LogLevel } from './log-level';
 import type { ChromiumOptions } from './open-browser';
 import type { ChromeMode } from './options/chrome-mode';
 import type { OnBrowserDownload } from './options/on-browser-download';
-export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, }: {
+export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, onBrowserLog, }: {
     passedInInstance: HeadlessBrowser | undefined;
     browserExecutable: BrowserExecutable | null;
     chromiumOptions: ChromiumOptions;
@@ -15,6 +16,7 @@ export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable
     onBrowserDownload: OnBrowserDownload;
     chromeMode: ChromeMode;
     pageIndex: number;
+    onBrowserLog: null | ((log: BrowserLog) => void);
 }) => Promise<{
     cleanupPage: () => Promise<void>;
     page: Page;

package/dist/get-browser-instance.js

@@ -4,13 +4,14 @@ exports.getPageAndCleanupFn = void 0;
 const browser_1 = require("./browser");
 const logger_1 = require("./logger");
 const open_browser_1 = require("./open-browser");
-const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, }) => {
+const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, onBrowserLog, }) => {
     if (passedInInstance) {
         const page = await passedInInstance.newPage({
             context: () => null,
             logLevel,
             indent,
             pageIndex,
+            onBrowserLog,
         });
         return {
             page,
@@ -42,6 +43,7 @@ const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromi
         logLevel,
         indent,
         pageIndex,
+        onBrowserLog,
     });
     return {
         page: browserPage,

package/dist/get-compositions.js

@@ -14,16 +14,7 @@ const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
 const wrap_with_error_handling_1 = require("./wrap-with-error-handling");
-const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCustomSchema, onBrowserLog, page, proxyPort, serveUrl, timeoutInMilliseconds, indent, logLevel, }) => {
-    if (onBrowserLog) {
-        page.on('console', (log) => {
-            onBrowserLog({
-                stackTrace: log.stackTrace(),
-                text: log.text,
-                type: log.type,
-            });
-        });
-    }
+const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCustomSchema, page, proxyPort, serveUrl, timeoutInMilliseconds, indent, logLevel, }) => {
     (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
     await (0, set_props_and_env_1.setPropsAndEnv)({
         serializedInputPropsWithCustomSchema,
@@ -69,7 +60,7 @@ const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCust
     });
     const res = result;
     return res.map((r) => {
-        const { width, durationInFrames, fps, height, id, defaultCodec } = r;
+        const { width, durationInFrames, fps, height, id, defaultCodec, defaultOutName, } = r;
         return {
             id,
             width,
@@ -79,6 +70,7 @@ const innerGetCompositions = async ({ envVariables, serializedInputPropsWithCust
             props: no_react_1.NoReactInternals.deserializeJSONWithCustomFields(r.serializedResolvedPropsWithCustomSchema),
             defaultProps: no_react_1.NoReactInternals.deserializeJSONWithCustomFields(r.serializedDefaultPropsWithCustomSchema),
             defaultCodec,
+            defaultOutName,
         };
     });
 };
@@ -93,6 +85,7 @@ const internalGetCompositionsRaw = async ({ browserExecutable, chromiumOptions,
         onBrowserDownload,
         chromeMode,
         pageIndex: 0,
+        onBrowserLog,
     });
     const cleanup = [cleanupPage];
     return new Promise((resolve, reject) => {
@@ -123,7 +116,6 @@ const internalGetCompositionsRaw = async ({ browserExecutable, chromiumOptions,
             return innerGetCompositions({
                 envVariables,
                 serializedInputPropsWithCustomSchema,
-                onBrowserLog,
                 page,
                 proxyPort: offthreadPort,
                 serveUrl,

package/dist/make-page.d.ts

@@ -12,7 +12,7 @@ export declare const makePage: ({ context, initialFrame, browserReplacer, logLev
     logLevel: LogLevel;
     indent: boolean;
     pagesArray: Page[];
-    onBrowserLog: ((log: BrowserLog) => void) | undefined | null;
+    onBrowserLog: ((log: BrowserLog) => void) | null;
     scale: number;
     timeoutInMilliseconds: number;
     composition: Omit<VideoConfig, "defaultProps" | "props">;

package/dist/make-page.js

@@ -6,23 +6,13 @@ const set_props_and_env_1 = require("./set-props-and-env");
 const makePage = async ({ context, initialFrame, browserReplacer, logLevel, indent, pagesArray, onBrowserLog, scale, timeoutInMilliseconds, composition, proxyPort, serveUrl, muted, envVariables, serializedInputPropsWithCustomSchema, imageFormat, serializedResolvedPropsWithCustomSchema, pageIndex, }) => {
     const page = await browserReplacer
         .getBrowser()
-        .newPage({ context, logLevel, indent, pageIndex });
+        .newPage({ context, logLevel, indent, pageIndex, onBrowserLog });
     pagesArray.push(page);
     await page.setViewport({
         width: composition.width,
         height: composition.height,
         deviceScaleFactor: scale,
     });
-    const logCallback = (log) => {
-        onBrowserLog === null || onBrowserLog === void 0 ? void 0 : onBrowserLog({
-            stackTrace: log.stackTrace(),
-            text: log.text,
-            type: log.type,
-        });
-    };
-    if (onBrowserLog) {
-        page.on('console', logCallback);
-    }
     await (0, set_props_and_env_1.setPropsAndEnv)({
         serializedInputPropsWithCustomSchema,
         envVariables,
@@ -40,7 +30,7 @@ const makePage = async ({ context, initialFrame, browserReplacer, logLevel, inde
     });
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         // eslint-disable-next-line max-params
-        pageFunction: (id, props, durationInFrames, fps, height, width, defaultCodec) => {
+        pageFunction: (id, props, durationInFrames, fps, height, width, defaultCodec, defaultOutName) => {
             window.remotion_setBundleMode({
                 type: 'composition',
                 compositionName: id,
@@ -50,6 +40,7 @@ const makePage = async ({ context, initialFrame, browserReplacer, logLevel, inde
                 compositionHeight: height,
                 compositionWidth: width,
                 compositionDefaultCodec: defaultCodec,
+                compositionDefaultOutName: defaultOutName,
             });
         },
         args: [
@@ -60,12 +51,12 @@ const makePage = async ({ context, initialFrame, browserReplacer, logLevel, inde
             composition.height,
             composition.width,
             composition.defaultCodec,
+            composition.defaultOutName,
         ],
         frame: null,
         page,
         timeoutInMilliseconds,
     });
-    page.off('console', logCallback);
     return page;
 };
 exports.makePage = makePage;