@remotion/serverless-client 4.0.261

package/dist/esm/index.mjs

@@ -0,0 +1,3467 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../renderer/dist/chalk/is-color-supported.js
+var require_is_color_supported = __commonJS((exports) => {
+  var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isColorSupported = undefined;
+  var tty = __importStar(__require("tty"));
+  var isColorSupported = () => {
+    var _a;
+    const env = process.env || {};
+    const isForceDisabled = "NO_COLOR" in env;
+    if (isForceDisabled) {
+      return false;
+    }
+    const isForced = "FORCE_COLOR" in env;
+    if (isForced) {
+      return true;
+    }
+    const isWindows = process.platform === "win32";
+    const isCompatibleTerminal = ((_a = tty === null || tty === undefined ? undefined : tty.isatty) === null || _a === undefined ? undefined : _a.call(tty, 1)) && env.TERM && env.TERM !== "dumb";
+    const isCI = "CI" in env && (("GITHUB_ACTIONS" in env) || ("GITLAB_CI" in env) || ("CIRCLECI" in env));
+    return isWindows || isCompatibleTerminal || isCI;
+  };
+  exports.isColorSupported = isColorSupported;
+});
+
+// ../renderer/dist/chalk/index.js
+var require_chalk = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.chalk = undefined;
+  var is_color_supported_1 = require_is_color_supported();
+  exports.chalk = (() => {
+    const colors = {
+      enabled: () => (0, is_color_supported_1.isColorSupported)(),
+      visible: true,
+      styles: {},
+      keys: {}
+    };
+    const ansi = (st) => {
+      const open = `\x1B[${st.codes[0]}m`;
+      const close = `\x1B[${st.codes[1]}m`;
+      const regex = new RegExp(`\\u001b\\[${st.codes[1]}m`, "g");
+      st.wrap = (input, newline) => {
+        if (input.includes(close))
+          input = input.replace(regex, close + open);
+        const output = open + input + close;
+        return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
+      };
+      return st;
+    };
+    const wrap = (sty, input, newline) => {
+      var _a;
+      return (_a = sty.wrap) === null || _a === undefined ? undefined : _a.call(sty, input, newline);
+    };
+    const style = (input, stack) => {
+      if (input === "" || input === null || input === undefined)
+        return "";
+      if (colors.enabled() === false)
+        return input;
+      if (colors.visible === false)
+        return "";
+      let str = String(input);
+      const nl = str.includes(`
+`);
+      let n = stack.length;
+      while (n-- > 0)
+        str = wrap(colors.styles[stack[n]], str, nl);
+      return str;
+    };
+    const define = (name, codes, type) => {
+      colors.styles[name] = ansi({ name, codes });
+      const keys = colors.keys[type] || (colors.keys[type] = []);
+      keys.push(name);
+      Reflect.defineProperty(colors, name, {
+        configurable: true,
+        enumerable: true,
+        set(value) {
+          var _a;
+          (_a = colors.alias) === null || _a === undefined || _a.call(colors, name, value);
+        },
+        get() {
+          const color = (input) => style(input, color.stack);
+          Reflect.setPrototypeOf(color, colors);
+          color.stack = this.stack ? this.stack.concat(name) : [name];
+          return color;
+        }
+      });
+    };
+    define("reset", [0, 0], "modifier");
+    define("bold", [1, 22], "modifier");
+    define("dim", [2, 22], "modifier");
+    define("italic", [3, 23], "modifier");
+    define("underline", [4, 24], "modifier");
+    define("inverse", [7, 27], "modifier");
+    define("hidden", [8, 28], "modifier");
+    define("strikethrough", [9, 29], "modifier");
+    define("black", [30, 39], "color");
+    define("red", [31, 39], "color");
+    define("green", [32, 39], "color");
+    define("yellow", [33, 39], "color");
+    define("blue", [34, 39], "color");
+    define("magenta", [35, 39], "color");
+    define("cyan", [36, 39], "color");
+    define("white", [37, 39], "color");
+    define("gray", [90, 39], "color");
+    define("grey", [90, 39], "color");
+    define("bgBlack", [40, 49], "bg");
+    define("bgRed", [41, 49], "bg");
+    define("bgGreen", [42, 49], "bg");
+    define("bgYellow", [43, 49], "bg");
+    define("bgBlue", [44, 49], "bg");
+    define("bgMagenta", [45, 49], "bg");
+    define("bgWhite", [47, 49], "bg");
+    define("blackBright", [90, 39], "bright");
+    define("redBright", [91, 39], "bright");
+    define("greenBright", [92, 39], "bright");
+    define("yellowBright", [93, 39], "bright");
+    define("blueBright", [94, 39], "bright");
+    define("magentaBright", [95, 39], "bright");
+    define("whiteBright", [97, 39], "bright");
+    define("bgBlackBright", [100, 49], "bgBright");
+    define("bgRedBright", [101, 49], "bgBright");
+    define("bgGreenBright", [102, 49], "bgBright");
+    define("bgYellowBright", [103, 49], "bgBright");
+    define("bgBlueBright", [104, 49], "bgBright");
+    define("bgMagentaBright", [105, 49], "bgBright");
+    define("bgWhiteBright", [107, 49], "bgBright");
+    colors.alias = (name, color) => {
+      const fn = colors[color];
+      if (typeof fn !== "function") {
+        throw new TypeError("Expected alias to be the name of an existing color (string) or a function");
+      }
+      if (!fn.stack) {
+        Reflect.defineProperty(fn, "name", { value: name });
+        colors.styles[name] = fn;
+        fn.stack = [name];
+      }
+      Reflect.defineProperty(colors, name, {
+        configurable: true,
+        enumerable: true,
+        set(value) {
+          var _a;
+          (_a = colors.alias) === null || _a === undefined || _a.call(colors, name, value);
+        },
+        get() {
+          const col = (input) => style(input, col.stack);
+          Reflect.setPrototypeOf(col, colors);
+          col.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
+          return col;
+        }
+      });
+    };
+    return colors;
+  })();
+});
+
+// ../renderer/dist/log-level.js
+var require_log_level = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isEqualOrBelowLogLevel = exports.isValidLogLevel = exports.logLevels = undefined;
+  exports.logLevels = ["trace", "verbose", "info", "warn", "error"];
+  var getNumberForLogLevel = (level) => {
+    return exports.logLevels.indexOf(level);
+  };
+  var isValidLogLevel = (level) => {
+    return getNumberForLogLevel(level) > -1;
+  };
+  exports.isValidLogLevel = isValidLogLevel;
+  var isEqualOrBelowLogLevel = (currentLevel, level) => {
+    return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+  };
+  exports.isEqualOrBelowLogLevel = isEqualOrBelowLogLevel;
+});
+
+// ../core/dist/cjs/version.js
+var require_version = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.VERSION = undefined;
+  exports.VERSION = "4.0.261";
+});
+
+// ../renderer/dist/find-closest-package-json.js
+var require_find_closest_package_json = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.findRemotionRoot = exports.findClosestPackageJson = undefined;
+  var node_fs_1 = __importDefault(__require("node:fs"));
+  var node_path_1 = __importDefault(__require("node:path"));
+  var recursionLimit = 5;
+  var findClosestPackageJson = () => {
+    let currentDir = process.cwd();
+    let possiblePackageJson = "";
+    for (let i = 0;i < recursionLimit; i++) {
+      possiblePackageJson = node_path_1.default.join(currentDir, "package.json");
+      const exists = node_fs_1.default.existsSync(possiblePackageJson);
+      if (exists) {
+        return possiblePackageJson;
+      }
+      currentDir = node_path_1.default.dirname(currentDir);
+    }
+    return null;
+  };
+  exports.findClosestPackageJson = findClosestPackageJson;
+  var findRemotionRoot = () => {
+    const closestPackageJson = (0, exports.findClosestPackageJson)();
+    if (closestPackageJson === null) {
+      return process.cwd();
+    }
+    return node_path_1.default.dirname(closestPackageJson);
+  };
+  exports.findRemotionRoot = findRemotionRoot;
+});
+
+// ../renderer/dist/is-serve-url.js
+var require_is_serve_url = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isServeUrl = undefined;
+  var isServeUrl = (potentialUrl) => {
+    if (typeof potentialUrl === "undefined") {
+      throw new Error("serveUrl is undefined");
+    }
+    if (potentialUrl.startsWith("www.") || potentialUrl.includes("amazonaws.com")) {
+      return true;
+    }
+    return potentialUrl.startsWith("https://") || potentialUrl.startsWith("http://");
+  };
+  exports.isServeUrl = isServeUrl;
+});
+
+// ../renderer/dist/repro.js
+var require_repro = __commonJS((exports) => {
+  var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isReproEnabled = exports.disableRepro = exports.enableRepro = exports.writeInRepro = exports.getReproWriter = undefined;
+  var node_child_process_1 = __require("node:child_process");
+  var node_fs_1 = __importStar(__require("node:fs"));
+  var node_os_1 = __importDefault(__require("node:os"));
+  var node_path_1 = __importDefault(__require("node:path"));
+  var version_1 = require_version();
+  var chalk_1 = require_chalk();
+  var find_closest_package_json_1 = require_find_closest_package_json();
+  var is_serve_url_1 = require_is_serve_url();
+  var logger_1 = require_logger();
+  var REPRO_DIR = ".remotionrepro";
+  var LOG_FILE_NAME = "logs.txt";
+  var INPUT_DIR = "bundle";
+  var OUTPUT_DIR = "output";
+  var LINE_SPLIT = `
+`;
+  var getZipFileName = (name) => `remotion-repro-${name}-${Date.now()}.zip`;
+  var readyDirSync = (dir) => {
+    let items;
+    try {
+      items = node_fs_1.default.readdirSync(dir);
+    } catch (_a) {
+      return node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    items.forEach((item) => {
+      item = node_path_1.default.join(dir, item);
+      node_fs_1.default.rmSync(item, { recursive: true, force: true });
+    });
+  };
+  var zipFolder = ({ sourceFolder, targetZip, indent, logLevel }) => {
+    const platform = node_os_1.default.platform();
+    try {
+      logger_1.Log.info({ indent, logLevel }, "+ Creating reproduction ZIP");
+      if (platform === "win32") {
+        (0, node_child_process_1.execSync)(`powershell.exe Compress-Archive -Path "${sourceFolder}" -DestinationPath "${targetZip}"`);
+      } else {
+        (0, node_child_process_1.execSync)(`zip -r "${targetZip}" "${sourceFolder}"`);
+      }
+      (0, node_fs_1.rmSync)(sourceFolder, { recursive: true });
+      logger_1.Log.info({ indent, logLevel }, `${chalk_1.chalk.blue(`+ Repro: ${targetZip}`)}`);
+    } catch (error) {
+      logger_1.Log.error({ indent, logLevel }, `Failed to zip repro folder, The repro folder is ${sourceFolder}. You can try manually zip it.`);
+      logger_1.Log.error({ indent, logLevel }, error);
+    }
+  };
+  var reproWriter = (name) => {
+    const root = (0, find_closest_package_json_1.findRemotionRoot)();
+    const reproFolder = node_path_1.default.join(root, REPRO_DIR);
+    const logPath = node_path_1.default.join(reproFolder, LOG_FILE_NAME);
+    const zipFile = node_path_1.default.join(root, getZipFileName(name));
+    readyDirSync(reproFolder);
+    const reproLogWriteStream = node_fs_1.default.createWriteStream(logPath, { flags: "a" });
+    const serializeArgs = (args) => JSON.stringify(args);
+    const writeLine = (level, ...args) => {
+      if (!args.length)
+        return;
+      const startTime = new Date().toISOString();
+      const line = `[${startTime}] ${level} ${serializeArgs(args)}`;
+      reproLogWriteStream.write(line + LINE_SPLIT);
+    };
+    const start = ({ serveUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema }) => {
+      const isServe = (0, is_serve_url_1.isServeUrl)(serveUrl);
+      if (!isServe) {
+        const inputDir = node_path_1.default.resolve(reproFolder, INPUT_DIR);
+        readyDirSync(inputDir);
+        node_fs_1.default.cpSync(serveUrl, inputDir, { recursive: true });
+      }
+      const serializedProps = node_path_1.default.resolve(reproFolder, "input-props.json");
+      node_fs_1.default.writeFileSync(serializedProps, serializedInputPropsWithCustomSchema);
+      const serializedResolvedProps = node_path_1.default.resolve(reproFolder, "resolved-props.json");
+      node_fs_1.default.writeFileSync(serializedResolvedProps, serializedResolvedPropsWithCustomSchema);
+      writeLine("info", [`Args: ${JSON.stringify(process.argv)}`]);
+      writeLine("info", [`Node/Bun version: ${process.version}`]);
+      writeLine("info", [`OS: ${process.platform}-${process.arch}`]);
+      writeLine("info", [`Serve URL: ${serveUrl}`]);
+      writeLine("info", [`Remotion version: ${version_1.VERSION}`]);
+    };
+    const onRenderSucceed = ({ indent, logLevel, output }) => {
+      return new Promise((resolve, reject) => {
+        try {
+          if (output) {
+            const outputDir = node_path_1.default.resolve(reproFolder, OUTPUT_DIR);
+            readyDirSync(outputDir);
+            const fileName = node_path_1.default.basename(output);
+            const targetPath = node_path_1.default.join(outputDir, fileName);
+            node_fs_1.default.copyFileSync(output, targetPath);
+          }
+          (0, exports.disableRepro)();
+          reproLogWriteStream.end(() => {
+            reproLogWriteStream.close(() => {
+              zipFolder({
+                sourceFolder: reproFolder,
+                targetZip: zipFile,
+                indent,
+                logLevel
+              });
+              resolve();
+            });
+          });
+        } catch (error) {
+          logger_1.Log.error({ indent: false, logLevel }, `repro render success error:`);
+          logger_1.Log.error({ indent: false, logLevel }, error);
+          reject(error);
+        }
+      });
+    };
+    return {
+      start,
+      writeLine,
+      onRenderSucceed
+    };
+  };
+  var reproWriteInstance = null;
+  var getReproWriter = () => {
+    if (!reproWriteInstance) {
+      throw new Error("reproWriteInstance is not initialized");
+    }
+    return reproWriteInstance;
+  };
+  exports.getReproWriter = getReproWriter;
+  var writeInRepro = (level, ...args) => {
+    if ((0, exports.isReproEnabled)()) {
+      (0, exports.getReproWriter)().writeLine(level, ...args);
+    }
+  };
+  exports.writeInRepro = writeInRepro;
+  var shouldRepro = false;
+  var enableRepro = ({ serveUrl, compositionName, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema }) => {
+    shouldRepro = true;
+    reproWriteInstance = reproWriter(compositionName);
+    (0, exports.getReproWriter)().start({
+      serveUrl,
+      serializedInputPropsWithCustomSchema,
+      serializedResolvedPropsWithCustomSchema
+    });
+  };
+  exports.enableRepro = enableRepro;
+  var disableRepro = () => {
+    shouldRepro = false;
+  };
+  exports.disableRepro = disableRepro;
+  var isReproEnabled = () => shouldRepro;
+  exports.isReproEnabled = isReproEnabled;
+});
+
+// ../renderer/dist/truthy.js
+var require_truthy = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.truthy = truthy2;
+  function truthy2(value) {
+    return Boolean(value);
+  }
+});
+
+// ../renderer/dist/logger.js
+var require_logger = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Log = exports.secondverboseTag = exports.verboseTag = exports.INDENT_TOKEN = undefined;
+  var chalk_1 = require_chalk();
+  var is_color_supported_1 = require_is_color_supported();
+  var log_level_1 = require_log_level();
+  var repro_1 = require_repro();
+  var truthy_1 = require_truthy();
+  exports.INDENT_TOKEN = chalk_1.chalk.gray("│");
+  var verboseTag = (str) => {
+    return (0, is_color_supported_1.isColorSupported)() ? chalk_1.chalk.bgBlack(` ${str} `) : `[${str}]`;
+  };
+  exports.verboseTag = verboseTag;
+  var secondverboseTag = (str) => {
+    return (0, is_color_supported_1.isColorSupported)() ? chalk_1.chalk.bgWhite(` ${str} `) : `[${str}]`;
+  };
+  exports.secondverboseTag = secondverboseTag;
+  exports.Log = {
+    trace: (options, ...args) => {
+      (0, repro_1.writeInRepro)("trace", ...args);
+      if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, "trace")) {
+        if (args.length === 0) {
+          return process.stdout.write(`
+`);
+        }
+        return console.log(...[
+          options.indent ? exports.INDENT_TOKEN : null,
+          options.tag ? (0, exports.verboseTag)(options.tag) : null
+        ].filter(truthy_1.truthy).concat(args.map((a) => chalk_1.chalk.gray(a))));
+      }
+    },
+    verbose: (options, ...args) => {
+      (0, repro_1.writeInRepro)("verbose", ...args);
+      if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, "verbose")) {
+        if (args.length === 0) {
+          return process.stdout.write(`
+`);
+        }
+        return console.log(...[
+          options.indent ? exports.INDENT_TOKEN : null,
+          options.tag ? (0, exports.verboseTag)(options.tag) : null
+        ].filter(truthy_1.truthy).concat(args.map((a) => chalk_1.chalk.gray(a))));
+      }
+    },
+    info: (options, ...args) => {
+      (0, repro_1.writeInRepro)("info", ...args);
+      if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, "info")) {
+        if (args.length === 0) {
+          return process.stdout.write(`
+`);
+        }
+        return console.log(...[options.indent ? exports.INDENT_TOKEN : null].filter(truthy_1.truthy).concat(args !== null && args !== undefined ? args : []));
+      }
+    },
+    warn: (options, ...args) => {
+      (0, repro_1.writeInRepro)("warn", ...args);
+      if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, "warn")) {
+        if (args.length === 0) {
+          return process.stdout.write(`
+`);
+        }
+        return console.warn(...[options.indent ? chalk_1.chalk.yellow(exports.INDENT_TOKEN) : null].filter(truthy_1.truthy).concat(args.map((a) => chalk_1.chalk.yellow(a))));
+      }
+    },
+    error: (options, ...args) => {
+      (0, repro_1.writeInRepro)("error", ...args);
+      if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, "error")) {
+        if (args.length === 0) {
+          return process.stdout.write(`
+`);
+        }
+        return console.error(...[
+          options.indent ? exports.INDENT_TOKEN : null,
+          options.tag ? (0, exports.verboseTag)(options.tag) : null
+        ].filter(truthy_1.truthy).concat(args.map((a) => chalk_1.chalk.red(a))));
+      }
+    }
+  };
+});
+
+// ../renderer/dist/print-useful-error-message.js
+var require_print_useful_error_message = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.printUsefulErrorMessage = undefined;
+  var logger_1 = require_logger();
+  var truthy_1 = require_truthy();
+  var alreadyPrintedCache = [];
+  var printUsefulErrorMessage = (err, logLevel, indent) => {
+    var _a, _b;
+    const errorStack = err.stack;
+    if (errorStack && alreadyPrintedCache.includes(errorStack)) {
+      return;
+    }
+    if (errorStack) {
+      alreadyPrintedCache.push(errorStack);
+      alreadyPrintedCache = alreadyPrintedCache.slice(-10);
+    }
+    if (err.message.includes("Could not play video with")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/media-playback-error");
+    }
+    if (err.message.includes("A delayRender()") && err.message.includes("was called but not cleared after")) {
+      logger_1.Log.info({ indent, logLevel });
+      if (err.message.includes("/proxy")) {
+        logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/troubleshooting/delay-render-proxy");
+      }
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/timeout");
+    }
+    if (err.message.includes("Target closed")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/target-closed");
+    }
+    if (err.message.includes("Timed out evaluating")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/troubleshooting/timed-out-page-function");
+    }
+    if (err.message.includes("ENAMETOOLONG")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue at https://remotion.dev/docs/enametoolong");
+    }
+    if (err.message.includes("Member must have value less than or equal to 3008")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error indicates that you have a AWS account on the free tier or have been limited by your organization. Often times this can be solved by adding a credit card. See also: https://repost.aws/questions/QUKruWYNDYTSmP17jCnIz6IQ/questions/QUKruWYNDYTSmP17jCnIz6IQ/unable-to-set-lambda-memory-over-3008mb");
+    }
+    if ((_a = err.stack) === null || _a === undefined ? undefined : _a.includes("TooManyRequestsException: Rate Exceeded.")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error indicates that your Lambda concurrency limit is too low. See: https://www.remotion.dev/docs/lambda/troubleshooting/rate-limit");
+    }
+    if (err.message.includes("Error creating WebGL context")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.warn({
+        indent,
+        logLevel
+      }, '\uD83D\uDCA1 You might need to set the OpenGL renderer to "angle-egl", "angle" (or "swangle" if rendering on lambda). Learn why at https://www.remotion.dev/docs/three');
+      logger_1.Log.warn({
+        indent,
+        logLevel
+      }, "\uD83D\uDCA1 Check how it's done at https://www.remotion.dev/docs/chromium-flags#--gl");
+    }
+    if (err.message.includes("The bucket does not allow ACLs")) {
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Fix for this issue: https://remotion.dev/docs/lambda/troubleshooting/bucket-disallows-acl");
+    }
+    if (err.message.includes("Minified React error #306")) {
+      const componentName = (_b = err.message.match(/<\w+>/)) === null || _b === undefined ? undefined : _b[0];
+      logger_1.Log.info({ indent, logLevel }, [
+        "\uD83D\uDCA1 This error indicates that the component",
+        componentName ? `(${componentName})` : null,
+        "you are trying to render is not imported correctly."
+      ].filter(truthy_1.truthy).join(" "));
+      logger_1.Log.info({ indent, logLevel });
+      logger_1.Log.info({ indent, logLevel }, "   Check the root file and ensure that the component is not undefined.");
+      logger_1.Log.info({ indent, logLevel }, "   Oftentimes, this happens if the component is missing the `export` keyword");
+      logger_1.Log.info({ indent, logLevel }, "   or if the component was renamed and the import statement not properly adjusted.");
+    }
+    if (err.message.includes("GLIBC_")) {
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Remotion requires at least Libc 2.35.");
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 Get help for this issue: https://github.com/remotion-dev/remotion/issues/2439");
+    }
+    if (err.message.includes("EBADF")) {
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error might be fixed by changing your Node version:");
+      logger_1.Log.info({ indent, logLevel }, "   https://github.com/remotion-dev/remotion/issues/2452");
+    }
+    if (err.message.includes("routines::unsupported")) {
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error might happen if using Cloud Run with credentials that have a newline at the end or are otherwise badly encoded.");
+      logger_1.Log.info({ indent, logLevel }, "   https://github.com/remotion-dev/remotion/issues/3864");
+    }
+    if (err.message.includes("Failed to fetch")) {
+      logger_1.Log.info({ indent, logLevel }, "\uD83D\uDCA1 On Lambda, one reason this could happen is that Chrome is rejecting an asset to be loaded when it is running low on disk space.");
+      logger_1.Log.info({ indent, logLevel }, "Try increasing the disk size of your Lambda function.");
+    }
+  };
+  exports.printUsefulErrorMessage = printUsefulErrorMessage;
+});
+
+// ../renderer/dist/wrap-with-error-handling.js
+var require_wrap_with_error_handling = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.wrapWithErrorHandling = undefined;
+  var print_useful_error_message_1 = require_print_useful_error_message();
+  var wrapWithErrorHandling = (fn) => {
+    return async (...args) => {
+      try {
+        return await fn(...args);
+      } catch (err) {
+        const { indent } = args[0];
+        const { logLevel } = args[0];
+        (0, print_useful_error_message_1.printUsefulErrorMessage)(err, logLevel, indent);
+        throw err;
+      }
+    };
+  };
+  exports.wrapWithErrorHandling = wrapWithErrorHandling;
+});
+
+// ../renderer/dist/error-handling.js
+var require_error_handling = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.wrapWithErrorHandling = undefined;
+  var wrap_with_error_handling_1 = require_wrap_with_error_handling();
+  Object.defineProperty(exports, "wrapWithErrorHandling", { enumerable: true, get: function() {
+    return wrap_with_error_handling_1.wrapWithErrorHandling;
+  } });
+});
+
+// ../streaming/dist/make-stream-payload-message.js
+var require_make_stream_payload_message = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.makeStreamPayloadMessage = exports.magicWordStr = undefined;
+  exports.magicWordStr = "remotion_buffer:";
+  var makeStreamPayloadMessage = ({ status, body, nonce }) => {
+    const nonceArr = new TextEncoder().encode(nonce);
+    const magicWordArr = new TextEncoder().encode(exports.magicWordStr);
+    const separatorArr = new TextEncoder().encode(":");
+    const bodyLengthArr = new TextEncoder().encode(body.length.toString());
+    const statusArr = new TextEncoder().encode(String(status));
+    const totalLength = nonceArr.length + magicWordArr.length + separatorArr.length * 3 + bodyLengthArr.length + statusArr.length + body.length;
+    const concat = new Uint8Array(totalLength);
+    let offset = 0;
+    const appendToConcat = (data) => {
+      concat.set(data, offset);
+      offset += data.length;
+    };
+    appendToConcat(magicWordArr);
+    appendToConcat(nonceArr);
+    appendToConcat(separatorArr);
+    appendToConcat(bodyLengthArr);
+    appendToConcat(separatorArr);
+    appendToConcat(statusArr);
+    appendToConcat(separatorArr);
+    appendToConcat(body);
+    return concat;
+  };
+  exports.makeStreamPayloadMessage = makeStreamPayloadMessage;
+});
+
+// ../streaming/dist/make-streamer.js
+var require_make_streamer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.makeStreamPayloadMessage = exports.makeStreamer = exports.streamingKey = undefined;
+  exports.streamingKey = "remotion_buffer:";
+  var makeStreamer = (onMessage) => {
+    const separator = new Uint8Array(exports.streamingKey.length);
+    for (let i = 0;i < exports.streamingKey.length; i++) {
+      separator[i] = exports.streamingKey.charCodeAt(i);
+    }
+    let unprocessedBuffers = [];
+    let outputBuffer = new Uint8Array(0);
+    let missingData = null;
+    const findSeparatorIndex = () => {
+      let searchIndex = 0;
+      while (true) {
+        const separatorIndex = outputBuffer.indexOf(separator[0], searchIndex);
+        if (separatorIndex === -1) {
+          return -1;
+        }
+        if (outputBuffer.subarray(separatorIndex, separatorIndex + separator.length).toString() !== separator.toString()) {
+          searchIndex = separatorIndex + 1;
+          continue;
+        }
+        return separatorIndex;
+      }
+    };
+    const processInput = () => {
+      let separatorIndex = findSeparatorIndex();
+      if (separatorIndex === -1) {
+        return;
+      }
+      separatorIndex += separator.length;
+      let nonceString = "";
+      let lengthString = "";
+      let statusString = "";
+      while (true) {
+        if (separatorIndex > outputBuffer.length - 1) {
+          return;
+        }
+        const nextDigit = outputBuffer[separatorIndex];
+        separatorIndex++;
+        if (nextDigit === 58) {
+          break;
+        }
+        nonceString += String.fromCharCode(nextDigit);
+      }
+      while (true) {
+        if (separatorIndex > outputBuffer.length - 1) {
+          return;
+        }
+        const nextDigit = outputBuffer[separatorIndex];
+        separatorIndex++;
+        if (nextDigit === 58) {
+          break;
+        }
+        lengthString += String.fromCharCode(nextDigit);
+      }
+      while (true) {
+        if (separatorIndex > outputBuffer.length - 1) {
+          return;
+        }
+        const nextDigit = outputBuffer[separatorIndex];
+        if (nextDigit === 58) {
+          break;
+        }
+        separatorIndex++;
+        statusString += String.fromCharCode(nextDigit);
+      }
+      const length = Number(lengthString);
+      const status = Number(statusString);
+      const dataLength = outputBuffer.length - separatorIndex - 1;
+      if (dataLength < length) {
+        missingData = {
+          dataMissing: length - dataLength
+        };
+        return;
+      }
+      const data = outputBuffer.subarray(separatorIndex + 1, separatorIndex + 1 + Number(lengthString));
+      onMessage(status === 1 ? "error" : "success", nonceString, data);
+      missingData = null;
+      outputBuffer = outputBuffer.subarray(separatorIndex + Number(lengthString) + 1);
+      processInput();
+    };
+    const onData = (data) => {
+      unprocessedBuffers.push(data);
+      if (missingData) {
+        missingData.dataMissing -= data.length;
+      }
+      if (missingData && missingData.dataMissing > 0) {
+        return;
+      }
+      const newBuffer = new Uint8Array(outputBuffer.length + unprocessedBuffers.reduce((acc, val) => acc + val.length, 0));
+      newBuffer.set(outputBuffer, 0);
+      let offset = outputBuffer.length;
+      for (const buf of unprocessedBuffers) {
+        newBuffer.set(buf, offset);
+        offset += buf.length;
+      }
+      outputBuffer = newBuffer;
+      unprocessedBuffers = [];
+      processInput();
+    };
+    return {
+      onData,
+      getOutputBuffer: () => outputBuffer,
+      clear: () => {
+        unprocessedBuffers = [];
+        outputBuffer = new Uint8Array(0);
+      }
+    };
+  };
+  exports.makeStreamer = makeStreamer;
+  var makeStreamPayloadMessage = ({ status, body, nonce }) => {
+    const nonceArr = new TextEncoder().encode(nonce);
+    const magicWordArr = new TextEncoder().encode(exports.streamingKey);
+    const separatorArr = new TextEncoder().encode(":");
+    const bodyLengthArr = new TextEncoder().encode(body.length.toString());
+    const statusArr = new TextEncoder().encode(String(status));
+    const totalLength = nonceArr.length + magicWordArr.length + separatorArr.length * 3 + bodyLengthArr.length + statusArr.length + body.length;
+    const concat = new Uint8Array(totalLength);
+    let offset = 0;
+    const appendToConcat = (data) => {
+      concat.set(data, offset);
+      offset += data.length;
+    };
+    appendToConcat(magicWordArr);
+    appendToConcat(nonceArr);
+    appendToConcat(separatorArr);
+    appendToConcat(bodyLengthArr);
+    appendToConcat(separatorArr);
+    appendToConcat(statusArr);
+    appendToConcat(separatorArr);
+    appendToConcat(body);
+    return concat;
+  };
+  exports.makeStreamPayloadMessage = makeStreamPayloadMessage;
+});
+
+// ../streaming/dist/index.js
+var require_dist = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.makeStreamer = exports.makeStreamPayloadMessage = undefined;
+  var make_stream_payload_message_1 = require_make_stream_payload_message();
+  Object.defineProperty(exports, "makeStreamPayloadMessage", { enumerable: true, get: function() {
+    return make_stream_payload_message_1.makeStreamPayloadMessage;
+  } });
+  var make_streamer_1 = require_make_streamer();
+  Object.defineProperty(exports, "makeStreamer", { enumerable: true, get: function() {
+    return make_streamer_1.makeStreamer;
+  } });
+});
+
+// ../renderer/dist/is-audio-codec.js
+var require_is_audio_codec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isAudioCodec = undefined;
+  var isAudioCodec = (codec) => {
+    return codec === "mp3" || codec === "aac" || codec === "wav";
+  };
+  exports.isAudioCodec = isAudioCodec;
+});
+
+// ../renderer/dist/crf.js
+var require_crf = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.validateQualitySettings = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = undefined;
+  var is_audio_codec_1 = require_is_audio_codec();
+  var defaultCrfMap = {
+    h264: 18,
+    h265: 23,
+    vp8: 9,
+    vp9: 28,
+    prores: null,
+    gif: null,
+    "h264-mkv": 18,
+    "h264-ts": 18,
+    aac: null,
+    mp3: null,
+    wav: null
+  };
+  var getDefaultCrfForCodec = (codec) => {
+    const val = defaultCrfMap[codec];
+    if (val === undefined) {
+      throw new TypeError(`Got unexpected codec "${codec}"`);
+    }
+    return val;
+  };
+  exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
+  var crfRanges = {
+    h264: [1, 51],
+    h265: [0, 51],
+    vp8: [4, 63],
+    vp9: [0, 63],
+    prores: [0, 0],
+    gif: [0, 0],
+    "h264-mkv": [1, 51],
+    "h264-ts": [1, 51],
+    aac: [0, 0],
+    mp3: [0, 0],
+    wav: [0, 0]
+  };
+  var getValidCrfRanges = (codec) => {
+    const val = crfRanges[codec];
+    if (val === undefined) {
+      throw new TypeError(`Got unexpected codec "${codec}"`);
+    }
+    return val;
+  };
+  exports.getValidCrfRanges = getValidCrfRanges;
+  var validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration }) => {
+    if (crf && videoBitrate) {
+      throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
+    }
+    if (crf && hardwareAcceleration === "required") {
+      throw new Error('"crf" option is not supported with hardware acceleration');
+    }
+    if (encodingMaxRate && !encodingBufferSize) {
+      throw new Error('"encodingMaxRate" can not be set without also setting "encodingBufferSize".');
+    }
+    const bufSizeArray = encodingBufferSize ? ["-bufsize", encodingBufferSize] : [];
+    const maxRateArray = encodingMaxRate ? ["-maxrate", encodingMaxRate] : [];
+    if (videoBitrate) {
+      if (codec === "prores") {
+        console.warn("ProRes does not support videoBitrate. Ignoring.");
+        return [];
+      }
+      if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        console.warn(`${codec} does not support videoBitrate. Ignoring.`);
+        return [];
+      }
+      return ["-b:v", videoBitrate, ...bufSizeArray, ...maxRateArray];
+    }
+    if (crf === null || typeof crf === "undefined") {
+      const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+      if (actualCrf === null) {
+        return [...bufSizeArray, ...maxRateArray];
+      }
+      return ["-crf", String(actualCrf), ...bufSizeArray, ...maxRateArray];
+    }
+    if (typeof crf !== "number") {
+      throw new TypeError("Expected CRF to be a number, but is " + JSON.stringify(crf));
+    }
+    const range = (0, exports.getValidCrfRanges)(codec);
+    if (crf === 0 && (codec === "h264" || codec === "h264-mkv" || codec === "h264-ts")) {
+      throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably do not want. Set CRF to a higher value to fix this error.");
+    }
+    if (crf < range[0] || crf > range[1]) {
+      if (range[0] === 0 && range[1] === 0) {
+        throw new TypeError(`The "${codec}" codec does not support the --crf option.`);
+      }
+      throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
+    }
+    if (codec === "prores") {
+      console.warn('ProRes does not support the "crf" option. Ignoring.');
+      return [];
+    }
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+      console.warn(`${codec} does not support the "crf" option. Ignoring.`);
+      return [];
+    }
+    return ["-crf", String(crf), ...bufSizeArray, ...maxRateArray];
+  };
+  exports.validateQualitySettings = validateQualitySettings;
+});
+
+// ../renderer/dist/codec-supports-media.js
+var require_codec_supports_media = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.codecSupportsVideoBitrate = exports.codecSupportsCrf = exports.codecSupportsMedia = undefined;
+  var crf_1 = require_crf();
+  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];
+  };
+  exports.codecSupportsMedia = codecSupportsMedia;
+  var codecSupportsVideoBitrateMap = {
+    "h264-mkv": true,
+    "h264-ts": true,
+    aac: false,
+    gif: false,
+    h264: true,
+    h265: true,
+    mp3: false,
+    prores: false,
+    vp8: true,
+    vp9: true,
+    wav: false
+  };
+  var codecSupportsCrf = (codec) => {
+    const range = (0, crf_1.getValidCrfRanges)(codec);
+    return range[0] !== range[1];
+  };
+  exports.codecSupportsCrf = codecSupportsCrf;
+  var codecSupportsVideoBitrate = (codec) => {
+    return codecSupportsVideoBitrateMap[codec];
+  };
+  exports.codecSupportsVideoBitrate = codecSupportsVideoBitrate;
+});
+
+// ../renderer/dist/get-duration-from-frame-range.js
+var require_get_duration_from_frame_range = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getFramesToRender = undefined;
+  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;
+    });
+  };
+  exports.getFramesToRender = getFramesToRender;
+});
+
+// ../renderer/dist/codec.js
+var require_codec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DEFAULT_CODEC = exports.validCodecs = undefined;
+  exports.validCodecs = [
+    "h264",
+    "h265",
+    "vp8",
+    "vp9",
+    "mp3",
+    "aac",
+    "wav",
+    "prores",
+    "h264-mkv",
+    "h264-ts",
+    "gif"
+  ];
+  exports.DEFAULT_CODEC = "h264";
+});
+
+// ../renderer/dist/file-extensions.js
+var require_file_extensions = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.defaultFileExtensionMap = undefined;
+  exports.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" }
+      }
+    }
+  };
+});
+
+// ../renderer/dist/get-extension-from-codec.js
+var require_get_extension_from_codec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.defaultCodecsForFileExtension = exports.makeFileExtensionMap = exports.getFileExtensionFromCodec = undefined;
+  var codec_1 = require_codec();
+  var file_extensions_1 = require_file_extensions();
+  var 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}`);
+    }
+    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;
+  var 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",
+    ts: "h264-ts"
+  };
+});
+
+// ../renderer/dist/path-normalize.js
+var require_path_normalize = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.pathNormalize = undefined;
+  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 (_a) {
+      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;
+  };
+  exports.pathNormalize = pathNormalize;
+});
+
+// ../renderer/dist/get-extension-of-filename.js
+var require_get_extension_of_filename = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getExtensionOfFilename = undefined;
+  var path_normalize_1 = require_path_normalize();
+  var getExtensionOfFilename = (filename) => {
+    if (filename === null) {
+      return null;
+    }
+    const filenameArr = (0, path_normalize_1.pathNormalize)(filename).split(".");
+    const hasExtension = filenameArr.length >= 2;
+    const filenameArrLength = filenameArr.length;
+    const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+    return extension;
+  };
+  exports.getExtensionOfFilename = getExtensionOfFilename;
+});
+
+// ../renderer/dist/options/separate-audio.js
+var require_separate_audio = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.separateAudioOption = undefined;
+  var DEFAULT = null;
+  var cliFlag = "separate-audio-to";
+  exports.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"
+  };
+});
+
+// ../renderer/dist/options/audio-codec.js
+var require_audio_codec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.audioCodecOption = exports.getDefaultAudioCodec = exports.resolveAudioCodec = exports.getExtensionFromAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.supportedAudioCodecs = exports.validAudioCodecs = undefined;
+  var separate_audio_1 = require_separate_audio();
+  exports.validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
+  exports.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 = exports.supportedAudioCodecs;
+  if (_satisfies) {
+  }
+  var mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === "aac") {
+      return "libfdk_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;
+  var cliFlag = "audio-codec";
+  var ssrName = "audioCodec";
+  exports.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 getExtensionFromAudioCodec = (audioCodec) => {
+    if (extensionMap[audioCodec]) {
+      return extensionMap[audioCodec];
+    }
+    throw new Error(`Unsupported audio codec: ${audioCodec}`);
+  };
+  exports.getExtensionFromAudioCodec = getExtensionFromAudioCodec;
+  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 (!exports.supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
+            throw new Error(`The codec is ${codec} but the audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${exports.supportedAudioCodecs[codec].join(", ")}`);
+          }
+        }
+      }
+    }
+    if (preferLossless) {
+      const selected = (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+      if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
+        throw new Error(`The audio codec derived from --${separate_audio_1.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 (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+    }
+    if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
+      throw new Error(`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${exports.audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+    }
+    return setting;
+  };
+  exports.resolveAudioCodec = resolveAudioCodec;
+  var getDefaultAudioCodec = ({ codec, preferLossless }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+  };
+  exports.getDefaultAudioCodec = getDefaultAudioCodec;
+  var _audioCodec = null;
+  exports.audioCodecOption = {
+    cliFlag,
+    setConfig: (audioCodec) => {
+      if (audioCodec === null) {
+        _audioCodec = null;
+        return;
+      }
+      if (!exports.validAudioCodecs.includes(audioCodec)) {
+        throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(", ")}, but got ${audioCodec}`);
+      }
+      _audioCodec = audioCodec;
+    },
+    getValue: ({ commandLine }) => {
+      if (commandLine[cliFlag]) {
+        const codec = commandLine[cliFlag];
+        if (!exports.validAudioCodecs.includes(commandLine[cliFlag])) {
+          throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(", ")}, but got ${codec}`);
+        }
+        return {
+          source: "cli",
+          value: commandLine[cliFlag]
+        };
+      }
+      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"
+  };
+});
+
+// ../renderer/dist/validate-output-filename.js
+var require_validate_output_filename = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.validateOutputFilename = undefined;
+  var file_extensions_1 = require_file_extensions();
+  var audio_codec_1 = require_audio_codec();
+  var validateOutputFilename = ({ codec, audioCodecSetting, extension, preferLossless, separateAudioTo }) => {
+    if (!file_extensions_1.defaultFileExtensionMap[codec]) {
+      throw new TypeError(`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(file_extensions_1.defaultFileExtensionMap).join(", ")}`);
+    }
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    const resolvedAudioCodec = (0, audio_codec_1.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(", ")}.`);
+    }
+  };
+  exports.validateOutputFilename = validateOutputFilename;
+});
+
+// ../renderer/dist/pure.js
+var require_pure = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NoReactAPIs = undefined;
+  var codec_supports_media_1 = require_codec_supports_media();
+  var get_duration_from_frame_range_1 = require_get_duration_from_frame_range();
+  var get_extension_from_codec_1 = require_get_extension_from_codec();
+  var get_extension_of_filename_1 = require_get_extension_of_filename();
+  var is_audio_codec_1 = require_is_audio_codec();
+  var validate_output_filename_1 = require_validate_output_filename();
+  exports.NoReactAPIs = {
+    getExtensionOfFilename: get_extension_of_filename_1.getExtensionOfFilename,
+    getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
+    validateOutputFilename: validate_output_filename_1.validateOutputFilename,
+    getFramesToRender: get_duration_from_frame_range_1.getFramesToRender,
+    codecSupportsMedia: codec_supports_media_1.codecSupportsMedia,
+    isAudioCodec: is_audio_codec_1.isAudioCodec
+  };
+});
+
+// ../core/dist/esm/no-react.mjs
+function interpolateFunction(input, inputRange, outputRange, options) {
+  const { extrapolateLeft, extrapolateRight, easing } = options;
+  let result = input;
+  const [inputMin, inputMax] = inputRange;
+  const [outputMin, outputMax] = outputRange;
+  if (result < inputMin) {
+    if (extrapolateLeft === "identity") {
+      return result;
+    }
+    if (extrapolateLeft === "clamp") {
+      result = inputMin;
+    } else if (extrapolateLeft === "wrap") {
+      const range = inputMax - inputMin;
+      result = ((result - inputMin) % range + range) % range + inputMin;
+    } else if (extrapolateLeft === "extend") {
+    }
+  }
+  if (result > inputMax) {
+    if (extrapolateRight === "identity") {
+      return result;
+    }
+    if (extrapolateRight === "clamp") {
+      result = inputMax;
+    } else if (extrapolateRight === "wrap") {
+      const range = inputMax - inputMin;
+      result = ((result - inputMin) % range + range) % range + inputMin;
+    } else if (extrapolateRight === "extend") {
+    }
+  }
+  if (outputMin === outputMax) {
+    return outputMin;
+  }
+  result = (result - inputMin) / (inputMax - inputMin);
+  result = easing(result);
+  result = result * (outputMax - outputMin) + outputMin;
+  return result;
+}
+function findRange(input, inputRange) {
+  let i;
+  for (i = 1;i < inputRange.length - 1; ++i) {
+    if (inputRange[i] >= input) {
+      break;
+    }
+  }
+  return i - 1;
+}
+function checkValidInputRange(arr) {
+  for (let i = 1;i < arr.length; ++i) {
+    if (!(arr[i] > arr[i - 1])) {
+      throw new Error(`inputRange must be strictly monotonically increasing but got [${arr.join(",")}]`);
+    }
+  }
+}
+function checkInfiniteRange(name, arr) {
+  if (arr.length < 2) {
+    throw new Error(name + " must have at least 2 elements");
+  }
+  for (const element of arr) {
+    if (typeof element !== "number") {
+      throw new Error(`${name} must contain only numbers`);
+    }
+    if (!Number.isFinite(element)) {
+      throw new Error(`${name} must contain only finite numbers, but got [${arr.join(",")}]`);
+    }
+  }
+}
+function interpolate(input, inputRange, outputRange, options) {
+  if (typeof input === "undefined") {
+    throw new Error("input can not be undefined");
+  }
+  if (typeof inputRange === "undefined") {
+    throw new Error("inputRange can not be undefined");
+  }
+  if (typeof outputRange === "undefined") {
+    throw new Error("outputRange can not be undefined");
+  }
+  if (inputRange.length !== outputRange.length) {
+    throw new Error("inputRange (" + inputRange.length + ") and outputRange (" + outputRange.length + ") must have the same length");
+  }
+  checkInfiniteRange("inputRange", inputRange);
+  checkInfiniteRange("outputRange", outputRange);
+  checkValidInputRange(inputRange);
+  const easing = options?.easing ?? ((num) => num);
+  let extrapolateLeft = "extend";
+  if (options?.extrapolateLeft !== undefined) {
+    extrapolateLeft = options.extrapolateLeft;
+  }
+  let extrapolateRight = "extend";
+  if (options?.extrapolateRight !== undefined) {
+    extrapolateRight = options.extrapolateRight;
+  }
+  if (typeof input !== "number") {
+    throw new TypeError("Cannot interpolate an input which is not a number");
+  }
+  const range = findRange(input, inputRange);
+  return interpolateFunction(input, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
+    easing,
+    extrapolateLeft,
+    extrapolateRight
+  });
+}
+function mulberry32(a) {
+  let t = a + 1831565813;
+  t = Math.imul(t ^ t >>> 15, t | 1);
+  t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+  return ((t ^ t >>> 14) >>> 0) / 4294967296;
+}
+function hashCode(str) {
+  let i = 0;
+  let chr = 0;
+  let hash = 0;
+  for (i = 0;i < str.length; i++) {
+    chr = str.charCodeAt(i);
+    hash = (hash << 5) - hash + chr;
+    hash |= 0;
+  }
+  return hash;
+}
+var random = (seed, dummy) => {
+  if (dummy !== undefined) {
+    throw new TypeError("random() takes only one argument");
+  }
+  if (seed === null) {
+    return Math.random();
+  }
+  if (typeof seed === "string") {
+    return mulberry32(hashCode(seed));
+  }
+  if (typeof seed === "number") {
+    return mulberry32(seed * 10000000000);
+  }
+  throw new Error("random() argument must be a number or a string");
+};
+function truthy(value) {
+  return Boolean(value);
+}
+if (typeof window !== "undefined") {
+  window.remotion_renderReady = false;
+}
+if (typeof window !== "undefined") {
+  window.remotion_delayRenderTimeouts = {};
+}
+var DELAY_RENDER_CALLSTACK_TOKEN = "The delayRender was called:";
+var DELAY_RENDER_RETRIES_LEFT = "Retries left: ";
+var DELAY_RENDER_RETRY_TOKEN = "- Rendering the frame will be retried.";
+var DATE_TOKEN = "remotion-date:";
+var FILE_TOKEN = "remotion-file:";
+var serializeJSONWithDate = ({
+  data,
+  indent,
+  staticBase
+}) => {
+  let customDateUsed = false;
+  let customFileUsed = false;
+  let mapUsed = false;
+  let setUsed = false;
+  try {
+    const serializedString = JSON.stringify(data, function(key, value) {
+      const item = this[key];
+      if (item instanceof Date) {
+        customDateUsed = true;
+        return `${DATE_TOKEN}${item.toISOString()}`;
+      }
+      if (item instanceof Map) {
+        mapUsed = true;
+        return value;
+      }
+      if (item instanceof Set) {
+        setUsed = true;
+        return value;
+      }
+      if (typeof item === "string" && staticBase !== null && item.startsWith(staticBase)) {
+        customFileUsed = true;
+        return `${FILE_TOKEN}${item.replace(staticBase + "/", "")}`;
+      }
+      return value;
+    }, indent);
+    return { serializedString, customDateUsed, customFileUsed, mapUsed, setUsed };
+  } catch (err) {
+    throw new Error("Could not serialize the passed input props to JSON: " + err.message);
+  }
+};
+var deserializeJSONWithCustomFields = (data) => {
+  return JSON.parse(data, (_, value) => {
+    if (typeof value === "string" && value.startsWith(DATE_TOKEN)) {
+      return new Date(value.replace(DATE_TOKEN, ""));
+    }
+    if (typeof value === "string" && value.startsWith(FILE_TOKEN)) {
+      return `${window.remotion_staticBase}/${value.replace(FILE_TOKEN, "")}`;
+    }
+    return value;
+  });
+};
+var NUMBER = "[-+]?\\d*\\.?\\d+";
+var PERCENTAGE = NUMBER + "%";
+function call(...args) {
+  return "\\(\\s*(" + args.join(")\\s*,\\s*(") + ")\\s*\\)";
+}
+function getMatchers() {
+  const cachedMatchers = {
+    rgb: undefined,
+    rgba: undefined,
+    hsl: undefined,
+    hsla: undefined,
+    hex3: undefined,
+    hex4: undefined,
+    hex5: undefined,
+    hex6: undefined,
+    hex8: undefined
+  };
+  if (cachedMatchers.rgb === undefined) {
+    cachedMatchers.rgb = new RegExp("rgb" + call(NUMBER, NUMBER, NUMBER));
+    cachedMatchers.rgba = new RegExp("rgba" + call(NUMBER, NUMBER, NUMBER, NUMBER));
+    cachedMatchers.hsl = new RegExp("hsl" + call(NUMBER, PERCENTAGE, PERCENTAGE));
+    cachedMatchers.hsla = new RegExp("hsla" + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));
+    cachedMatchers.hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+    cachedMatchers.hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;
+    cachedMatchers.hex6 = /^#([0-9a-fA-F]{6})$/;
+    cachedMatchers.hex8 = /^#([0-9a-fA-F]{8})$/;
+  }
+  return cachedMatchers;
+}
+function hue2rgb(p, q, t) {
+  if (t < 0) {
+    t += 1;
+  }
+  if (t > 1) {
+    t -= 1;
+  }
+  if (t < 1 / 6) {
+    return p + (q - p) * 6 * t;
+  }
+  if (t < 1 / 2) {
+    return q;
+  }
+  if (t < 2 / 3) {
+    return p + (q - p) * (2 / 3 - t) * 6;
+  }
+  return p;
+}
+function hslToRgb(h, s, l) {
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const r = hue2rgb(p, q, h + 1 / 3);
+  const g = hue2rgb(p, q, h);
+  const b = hue2rgb(p, q, h - 1 / 3);
+  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
+}
+function parse255(str) {
+  const int = Number.parseInt(str, 10);
+  if (int < 0) {
+    return 0;
+  }
+  if (int > 255) {
+    return 255;
+  }
+  return int;
+}
+function parse360(str) {
+  const int = Number.parseFloat(str);
+  return (int % 360 + 360) % 360 / 360;
+}
+function parse1(str) {
+  const num = Number.parseFloat(str);
+  if (num < 0) {
+    return 0;
+  }
+  if (num > 1) {
+    return 255;
+  }
+  return Math.round(num * 255);
+}
+function parsePercentage(str) {
+  const int = Number.parseFloat(str);
+  if (int < 0) {
+    return 0;
+  }
+  if (int > 100) {
+    return 1;
+  }
+  return int / 100;
+}
+var colorNames = {
+  transparent: 0,
+  aliceblue: 4042850303,
+  antiquewhite: 4209760255,
+  aqua: 16777215,
+  aquamarine: 2147472639,
+  azure: 4043309055,
+  beige: 4126530815,
+  bisque: 4293182719,
+  black: 255,
+  blanchedalmond: 4293643775,
+  blue: 65535,
+  blueviolet: 2318131967,
+  brown: 2771004159,
+  burlywood: 3736635391,
+  burntsienna: 3934150143,
+  cadetblue: 1604231423,
+  chartreuse: 2147418367,
+  chocolate: 3530104575,
+  coral: 4286533887,
+  cornflowerblue: 1687547391,
+  cornsilk: 4294499583,
+  crimson: 3692313855,
+  cyan: 16777215,
+  darkblue: 35839,
+  darkcyan: 9145343,
+  darkgoldenrod: 3095792639,
+  darkgray: 2846468607,
+  darkgreen: 6553855,
+  darkgrey: 2846468607,
+  darkkhaki: 3182914559,
+  darkmagenta: 2332068863,
+  darkolivegreen: 1433087999,
+  darkorange: 4287365375,
+  darkorchid: 2570243327,
+  darkred: 2332033279,
+  darksalmon: 3918953215,
+  darkseagreen: 2411499519,
+  darkslateblue: 1211993087,
+  darkslategray: 793726975,
+  darkslategrey: 793726975,
+  darkturquoise: 13554175,
+  darkviolet: 2483082239,
+  deeppink: 4279538687,
+  deepskyblue: 12582911,
+  dimgray: 1768516095,
+  dimgrey: 1768516095,
+  dodgerblue: 512819199,
+  firebrick: 2988581631,
+  floralwhite: 4294635775,
+  forestgreen: 579543807,
+  fuchsia: 4278255615,
+  gainsboro: 3705462015,
+  ghostwhite: 4177068031,
+  gold: 4292280575,
+  goldenrod: 3668254975,
+  gray: 2155905279,
+  green: 8388863,
+  greenyellow: 2919182335,
+  grey: 2155905279,
+  honeydew: 4043305215,
+  hotpink: 4285117695,
+  indianred: 3445382399,
+  indigo: 1258324735,
+  ivory: 4294963455,
+  khaki: 4041641215,
+  lavender: 3873897215,
+  lavenderblush: 4293981695,
+  lawngreen: 2096890111,
+  lemonchiffon: 4294626815,
+  lightblue: 2916673279,
+  lightcoral: 4034953471,
+  lightcyan: 3774873599,
+  lightgoldenrodyellow: 4210742015,
+  lightgray: 3553874943,
+  lightgreen: 2431553791,
+  lightgrey: 3553874943,
+  lightpink: 4290167295,
+  lightsalmon: 4288707327,
+  lightseagreen: 548580095,
+  lightskyblue: 2278488831,
+  lightslategray: 2005441023,
+  lightslategrey: 2005441023,
+  lightsteelblue: 2965692159,
+  lightyellow: 4294959359,
+  lime: 16711935,
+  limegreen: 852308735,
+  linen: 4210091775,
+  magenta: 4278255615,
+  maroon: 2147483903,
+  mediumaquamarine: 1724754687,
+  mediumblue: 52735,
+  mediumorchid: 3126187007,
+  mediumpurple: 2473647103,
+  mediumseagreen: 1018393087,
+  mediumslateblue: 2070474495,
+  mediumspringgreen: 16423679,
+  mediumturquoise: 1221709055,
+  mediumvioletred: 3340076543,
+  midnightblue: 421097727,
+  mintcream: 4127193855,
+  mistyrose: 4293190143,
+  moccasin: 4293178879,
+  navajowhite: 4292783615,
+  navy: 33023,
+  oldlace: 4260751103,
+  olive: 2155872511,
+  olivedrab: 1804477439,
+  orange: 4289003775,
+  orangered: 4282712319,
+  orchid: 3664828159,
+  palegoldenrod: 4008225535,
+  palegreen: 2566625535,
+  paleturquoise: 2951671551,
+  palevioletred: 3681588223,
+  papayawhip: 4293907967,
+  peachpuff: 4292524543,
+  peru: 3448061951,
+  pink: 4290825215,
+  plum: 3718307327,
+  powderblue: 2967529215,
+  purple: 2147516671,
+  rebeccapurple: 1714657791,
+  red: 4278190335,
+  rosybrown: 3163525119,
+  royalblue: 1097458175,
+  saddlebrown: 2336560127,
+  salmon: 4202722047,
+  sandybrown: 4104413439,
+  seagreen: 780883967,
+  seashell: 4294307583,
+  sienna: 2689740287,
+  silver: 3233857791,
+  skyblue: 2278484991,
+  slateblue: 1784335871,
+  slategray: 1887473919,
+  slategrey: 1887473919,
+  snow: 4294638335,
+  springgreen: 16744447,
+  steelblue: 1182971135,
+  tan: 3535047935,
+  teal: 8421631,
+  thistle: 3636451583,
+  tomato: 4284696575,
+  turquoise: 1088475391,
+  violet: 4001558271,
+  wheat: 4125012991,
+  white: 4294967295,
+  whitesmoke: 4126537215,
+  yellow: 4294902015,
+  yellowgreen: 2597139199
+};
+function normalizeColor(color) {
+  const matchers = getMatchers();
+  let match;
+  if (matchers.hex6) {
+    if (match = matchers.hex6.exec(color)) {
+      return Number.parseInt(match[1] + "ff", 16) >>> 0;
+    }
+  }
+  if (colorNames[color] !== undefined) {
+    return colorNames[color];
+  }
+  if (matchers.rgb) {
+    if (match = matchers.rgb.exec(color)) {
+      return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | 255) >>> 0;
+    }
+  }
+  if (matchers.rgba) {
+    if (match = matchers.rgba.exec(color)) {
+      return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | parse1(match[4])) >>> 0;
+    }
+  }
+  if (matchers.hex3) {
+    if (match = matchers.hex3.exec(color)) {
+      return Number.parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + "ff", 16) >>> 0;
+    }
+  }
+  if (matchers.hex8) {
+    if (match = matchers.hex8.exec(color)) {
+      return Number.parseInt(match[1], 16) >>> 0;
+    }
+  }
+  if (matchers.hex4) {
+    if (match = matchers.hex4.exec(color)) {
+      return Number.parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + match[4] + match[4], 16) >>> 0;
+    }
+  }
+  if (matchers.hsl) {
+    if (match = matchers.hsl.exec(color)) {
+      return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | 255) >>> 0;
+    }
+  }
+  if (matchers.hsla) {
+    if (match = matchers.hsla.exec(color)) {
+      return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | parse1(match[4])) >>> 0;
+    }
+  }
+  throw new Error(`invalid color string ${color} provided`);
+}
+function processColor(color) {
+  const normalizedColor = normalizeColor(color);
+  return (normalizedColor << 24 | normalizedColor >>> 8) >>> 0;
+}
+var ENABLE_V5_BREAKING_CHANGES = false;
+var validateFrame = ({
+  allowFloats,
+  durationInFrames,
+  frame
+}) => {
+  if (typeof frame === "undefined") {
+    throw new TypeError(`Argument missing for parameter "frame"`);
+  }
+  if (typeof frame !== "number") {
+    throw new TypeError(`Argument passed for "frame" is not a number: ${frame}`);
+  }
+  if (!Number.isFinite(frame)) {
+    throw new RangeError(`Frame ${frame} is not finite`);
+  }
+  if (frame % 1 !== 0 && !allowFloats) {
+    throw new RangeError(`Argument for frame must be an integer, but got ${frame}`);
+  }
+  if (frame < 0 && frame < -durationInFrames) {
+    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the lowest frame that can be rendered is ${-durationInFrames}`);
+  }
+  if (frame > durationInFrames - 1) {
+    throw new RangeError(`Cannot use frame ${frame}: Duration of composition is ${durationInFrames}, therefore the highest frame that can be rendered is ${durationInFrames - 1}`);
+  }
+};
+var validateDefaultAndInputProps = (defaultProps, name, compositionId) => {
+  if (!defaultProps) {
+    return;
+  }
+  if (typeof defaultProps !== "object") {
+    throw new Error(`"${name}" must be an object, but you passed a value of type ${typeof defaultProps}`);
+  }
+  if (Array.isArray(defaultProps)) {
+    throw new Error(`"${name}" must be an object, an array was passed ${compositionId ? `for composition "${compositionId}"` : ""}`);
+  }
+};
+function validateDimension(amount, nameOfProp, location) {
+  if (typeof amount !== "number") {
+    throw new Error(`The "${nameOfProp}" prop ${location} must be a number, but you passed a value of type ${typeof amount}`);
+  }
+  if (isNaN(amount)) {
+    throw new TypeError(`The "${nameOfProp}" prop ${location} must not be NaN, but is NaN.`);
+  }
+  if (!Number.isFinite(amount)) {
+    throw new TypeError(`The "${nameOfProp}" prop ${location} must be finite, but is ${amount}.`);
+  }
+  if (amount % 1 !== 0) {
+    throw new TypeError(`The "${nameOfProp}" prop ${location} must be an integer, but is ${amount}.`);
+  }
+  if (amount <= 0) {
+    throw new TypeError(`The "${nameOfProp}" prop ${location} must be positive, but got ${amount}.`);
+  }
+}
+function validateDurationInFrames(durationInFrames, options) {
+  const { allowFloats, component } = options;
+  if (typeof durationInFrames === "undefined") {
+    throw new Error(`The "durationInFrames" prop ${component} is missing.`);
+  }
+  if (typeof durationInFrames !== "number") {
+    throw new Error(`The "durationInFrames" prop ${component} must be a number, but you passed a value of type ${typeof durationInFrames}`);
+  }
+  if (durationInFrames <= 0) {
+    throw new TypeError(`The "durationInFrames" prop ${component} must be positive, but got ${durationInFrames}.`);
+  }
+  if (!allowFloats && durationInFrames % 1 !== 0) {
+    throw new TypeError(`The "durationInFrames" prop ${component} must be an integer, but got ${durationInFrames}.`);
+  }
+  if (!Number.isFinite(durationInFrames)) {
+    throw new TypeError(`The "durationInFrames" prop ${component} must be finite, but got ${durationInFrames}.`);
+  }
+}
+function validateFps(fps, location, isGif) {
+  if (typeof fps !== "number") {
+    throw new Error(`"fps" must be a number, but you passed a value of type ${typeof fps} ${location}`);
+  }
+  if (!Number.isFinite(fps)) {
+    throw new Error(`"fps" must be a finite, but you passed ${fps} ${location}`);
+  }
+  if (isNaN(fps)) {
+    throw new Error(`"fps" must not be NaN, but got ${fps} ${location}`);
+  }
+  if (fps <= 0) {
+    throw new TypeError(`"fps" must be positive, but got ${fps} ${location}`);
+  }
+  if (isGif && fps > 50) {
+    throw new TypeError(`The FPS for a GIF cannot be higher than 50. Use the --every-nth-frame option to lower the FPS: https://remotion.dev/docs/render-as-gif`);
+  }
+}
+var getExpectedMediaFrameUncorrected = ({
+  frame,
+  playbackRate,
+  startFrom
+}) => {
+  return interpolate(frame, [-1, startFrom, startFrom + 1], [-1, startFrom, startFrom + playbackRate]);
+};
+var getAbsoluteSrc = (relativeSrc) => {
+  if (typeof window === "undefined") {
+    return relativeSrc;
+  }
+  return new URL(relativeSrc, window.origin).href;
+};
+var getOffthreadVideoSource = ({
+  src,
+  transparent,
+  currentTime,
+  toneMapped
+}) => {
+  return `http://localhost:${window.remotion_proxyPort}/proxy?src=${encodeURIComponent(getAbsoluteSrc(src))}&time=${encodeURIComponent(currentTime)}&transparent=${String(transparent)}&toneMapped=${String(toneMapped)}`;
+};
+var NoReactInternals = {
+  processColor,
+  truthy,
+  validateFps,
+  validateDimension,
+  validateDurationInFrames,
+  validateDefaultAndInputProps,
+  validateFrame,
+  serializeJSONWithDate,
+  bundleName: "bundle.js",
+  bundleMapName: "bundle.js.map",
+  deserializeJSONWithCustomFields,
+  DELAY_RENDER_CALLSTACK_TOKEN,
+  DELAY_RENDER_RETRY_TOKEN,
+  DELAY_RENDER_ATTEMPT_TOKEN: DELAY_RENDER_RETRIES_LEFT,
+  getOffthreadVideoSource,
+  getExpectedMediaFrameUncorrected,
+  ENABLE_V5_BREAKING_CHANGES,
+  MIN_NODE_VERSION: ENABLE_V5_BREAKING_CHANGES ? 18 : 16,
+  MIN_BUN_VERSION: ENABLE_V5_BREAKING_CHANGES ? "1.1.3" : "1.0.3",
+  colorNames,
+  DATE_TOKEN,
+  FILE_TOKEN
+};
+
+// src/constants.ts
+var COMMAND_NOT_FOUND = "Command not found";
+var expiryDays = {
+  "1-day": 1,
+  "3-days": 3,
+  "7-days": 7,
+  "30-days": 30
+};
+var ServerlessRoutines;
+((ServerlessRoutines2) => {
+  ServerlessRoutines2["info"] = "info";
+  ServerlessRoutines2["start"] = "start";
+  ServerlessRoutines2["launch"] = "launch";
+  ServerlessRoutines2["status"] = "status";
+  ServerlessRoutines2["renderer"] = "renderer";
+  ServerlessRoutines2["still"] = "still";
+  ServerlessRoutines2["compositions"] = "compositions";
+})(ServerlessRoutines ||= {});
+var serverlessCodecs = [
+  "h264",
+  "h265",
+  "vp8",
+  "vp9",
+  "mp3",
+  "aac",
+  "wav",
+  "gif",
+  "prores"
+];
+var rendersPrefix = (renderId) => `renders/${renderId}`;
+var outStillName = (renderId, imageFormat) => `${rendersPrefix(renderId)}/out.${imageFormat}`;
+var outName = (renderId, extension) => `${rendersPrefix(renderId)}/out.${extension}`;
+var customOutName = (renderId, bucketName, name) => {
+  if (typeof name === "string") {
+    return {
+      renderBucketName: bucketName,
+      key: `${rendersPrefix(renderId)}/${name}`,
+      customCredentials: null
+    };
+  }
+  return {
+    key: name.key,
+    renderBucketName: name.bucketName,
+    customCredentials: name.s3OutputProvider ?? null
+  };
+};
+var overallProgressKey = (renderId) => `${rendersPrefix(renderId)}/progress.json`;
+var artifactName = (renderId, name) => `${rendersPrefix(renderId)}/artifacts/${name}`;
+var CONCAT_FOLDER_TOKEN = "remotion-concat";
+var MAX_FUNCTIONS_PER_RENDER = 200;
+var MINIMUM_FRAMES_PER_FUNCTIONS = 4;
+var REMOTION_CONCATENATED_TOKEN = "remotion-concatenated-token";
+var REMOTION_FILELIST_TOKEN = "remotion-filelist";
+var RENDERER_PATH_TOKEN = "remotion-bucket";
+// src/serialize-artifact.ts
+var deserializeArtifact = (serializedArtifact) => {
+  if (serializedArtifact.binary) {
+    const content = new TextEncoder().encode(atob(serializedArtifact.stringContent));
+    return {
+      filename: serializedArtifact.filename,
+      content,
+      frame: serializedArtifact.frame
+    };
+  }
+  return {
+    filename: serializedArtifact.filename,
+    content: serializedArtifact.stringContent,
+    frame: serializedArtifact.frame
+  };
+};
+var serializeArtifact = (artifact) => {
+  if (artifact.content instanceof Uint8Array) {
+    const b64encoded = btoa(new TextDecoder("utf8").decode(artifact.content));
+    return {
+      filename: artifact.filename,
+      stringContent: b64encoded,
+      frame: artifact.frame,
+      binary: true
+    };
+  }
+  return {
+    filename: artifact.filename,
+    stringContent: artifact.content,
+    frame: artifact.frame,
+    binary: false
+  };
+};
+// src/validate-download-behavior.ts
+var validateDownloadBehavior = (downloadBehavior) => {
+  if (downloadBehavior === null || downloadBehavior === undefined) {
+    return null;
+  }
+  if (typeof downloadBehavior !== "object") {
+    throw new Error("downloadBehavior must be null or an object");
+  }
+  const behavior = downloadBehavior;
+  if (behavior.type !== "download" && behavior.type !== "play-in-browser") {
+    throw new Error('Download behavior must be either "download" or "play-in-browser"');
+  }
+  if (behavior.type === "download") {
+    if (typeof behavior.fileName !== "string" && behavior.fileName !== null) {
+      throw new Error('If "downloadBehavior.type" is "download", then fileName must be "null" or a string');
+    }
+  }
+};
+// src/validate-frames-per-function.ts
+var validateFramesPerFunction = ({
+  framesPerFunction,
+  durationInFrames
+}) => {
+  if (framesPerFunction === null) {
+    return;
+  }
+  if (framesPerFunction === undefined) {
+    return;
+  }
+  if (typeof framesPerFunction !== "number") {
+    throw new TypeError(`'framesPerLambda' needs to be a number, passed ${JSON.stringify(framesPerFunction)}`);
+  }
+  if (!Number.isFinite(framesPerFunction)) {
+    throw new TypeError(`'framesPerLambda' needs to be finite, passed ${framesPerFunction}`);
+  }
+  if (Number.isNaN(framesPerFunction)) {
+    throw new TypeError(`'framesPerLambda' needs to be NaN, passed ${framesPerFunction}`);
+  }
+  if (framesPerFunction % 1 !== 0) {
+    throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerFunction}`);
+  }
+  const effectiveMinimum = Math.min(MINIMUM_FRAMES_PER_FUNCTIONS, durationInFrames);
+  if (framesPerFunction < effectiveMinimum) {
+    throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerFunction}`);
+  }
+};
+
+// src/index.ts
+var import_error_handling = __toESM(require_error_handling(), 1);
+var import_streaming2 = __toESM(require_dist(), 1);
+
+// ../core/dist/esm/version.mjs
+var VERSION = "4.0.261";
+// src/min-max.ts
+var min = (arr) => {
+  if (arr.length === 0) {
+    throw new Error("Array of 0 length");
+  }
+  let smallest = arr[0];
+  for (let i = 0;i < arr.length; i++) {
+    const elem = arr[i];
+    if (elem < smallest) {
+      smallest = elem;
+    }
+  }
+  return smallest;
+};
+var max = (arr) => {
+  if (arr.length === 0) {
+    throw new Error("Array of 0 length");
+  }
+  let biggest = arr[0];
+  for (let i = 0;i < arr.length; i++) {
+    const elem = arr[i];
+    if (elem > biggest) {
+      biggest = elem;
+    }
+  }
+  return biggest;
+};
+
+// src/calculate-chunk-times.ts
+var getAbsoluteTime = (parsedTimings) => {
+  if (parsedTimings.length === 0) {
+    return 0;
+  }
+  const allEnds = parsedTimings.map((p) => p.rendered);
+  const allStarts = parsedTimings.map((p) => p.start);
+  const biggestEnd = max(allEnds);
+  const smallestStart = min(allStarts);
+  return Math.max(0, biggestEnd - smallestStart);
+};
+var calculateChunkTimes = ({
+  type,
+  timings
+}) => {
+  const parsedTimings = timings;
+  const absoluteTime = getAbsoluteTime(parsedTimings);
+  if (type === "combined-time-for-cost-calculation") {
+    const totalEncodingTimings = parsedTimings.map((p) => Math.max(0, p.rendered - p.start)).reduce((a, b) => a + b, 0);
+    return totalEncodingTimings + absoluteTime;
+  }
+  if (type === "absolute-time") {
+    return absoluteTime;
+  }
+  throw new Error("invalid time for calculate chunk times");
+};
+// src/make-bucket-name.ts
+var makeBucketName = (region, providerSpecifics) => {
+  return `${providerSpecifics.getBucketPrefix()}${region.replace(/-/g, "")}-${providerSpecifics.randomHash()}`;
+};
+
+// src/get-or-create-bucket.ts
+var internalGetOrCreateBucket = async (params) => {
+  const remotionBuckets = await params.providerSpecifics.getBuckets({
+    region: params.region,
+    forceBucketName: null,
+    forcePathStyle: params.forcePathStyle
+  });
+  if (remotionBuckets.length > 1) {
+    throw new Error(`You have multiple buckets (${remotionBuckets.map((b) => b.name)}) in your S3 region (${params.region}) starting with "${params.providerSpecifics.getBucketPrefix()}". Please see https://remotion.dev/docs/lambda/multiple-buckets.`);
+  }
+  const { enableFolderExpiry, region } = params;
+  if (remotionBuckets.length === 1) {
+    const existingBucketName = remotionBuckets[0].name;
+    await params.providerSpecifics.applyLifeCycle({
+      enableFolderExpiry: enableFolderExpiry ?? null,
+      bucketName: existingBucketName,
+      region,
+      customCredentials: params.customCredentials,
+      forcePathStyle: params.forcePathStyle
+    });
+    return { bucketName: remotionBuckets[0].name, alreadyExisted: true };
+  }
+  const bucketName = makeBucketName(params.region, params.providerSpecifics);
+  await params.providerSpecifics.createBucket({
+    bucketName,
+    region: params.region,
+    forcePathStyle: params.forcePathStyle,
+    skipPutAcl: params.skipPutAcl
+  });
+  await params.providerSpecifics.applyLifeCycle({
+    enableFolderExpiry: enableFolderExpiry ?? null,
+    bucketName,
+    region,
+    customCredentials: params.customCredentials,
+    forcePathStyle: params.forcePathStyle
+  });
+  return { bucketName, alreadyExisted: false };
+};
+
+// src/input-props-keys.ts
+var inputPropsKey = (hash) => {
+  return `input-props/${hash}.json`;
+};
+var resolvedPropsKey = (hash) => {
+  return `resolved-props/${hash}.json`;
+};
+
+// src/stream-to-string.ts
+function streamToString(stream) {
+  if (Buffer.isBuffer(stream)) {
+    return stream.toString("utf-8");
+  }
+  const chunks = [];
+  return new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    stream.on("error", (err) => reject(err));
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+
+// src/validate-webhook.ts
+var MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+var validateWebhook = (webhook) => {
+  if (typeof webhook === "undefined" || webhook === null) {
+    return;
+  }
+  if (webhook.customData) {
+    const size = JSON.stringify(webhook.customData).length;
+    if (size > MAX_WEBHOOK_CUSTOM_DATA_SIZE) {
+      throw new Error(`Webhook "customData" must be less than ${MAX_WEBHOOK_CUSTOM_DATA_SIZE} bytes. Current size: ${size} bytes.`);
+    }
+  }
+};
+
+// src/compress-props.ts
+var makeKey = (type, hash) => {
+  if (type === "input-props") {
+    return inputPropsKey(hash);
+  }
+  return resolvedPropsKey(hash);
+};
+var serializeOrThrow = (inputProps, propsType) => {
+  try {
+    const payload = NoReactInternals.serializeJSONWithDate({
+      indent: undefined,
+      staticBase: null,
+      data: inputProps
+    });
+    return payload.serializedString;
+  } catch {
+    throw new Error(`Error serializing ${propsType}. Check it has no circular references or reduce the size if the object is big.`);
+  }
+};
+var getNeedsToUpload = ({
+  type,
+  sizes,
+  providerSpecifics
+}) => {
+  const MARGIN = 5000 + MAX_WEBHOOK_CUSTOM_DATA_SIZE;
+  const MAX_INLINE_PAYLOAD_SIZE = (type === "still" ? providerSpecifics.getMaxStillInlinePayloadSize() : providerSpecifics.getMaxNonInlinePayloadSizePerFunction()) - MARGIN;
+  const sizesAlreadyUsed = sizes.reduce((a, b) => a + b);
+  if (sizesAlreadyUsed > MAX_INLINE_PAYLOAD_SIZE) {
+    console.warn(`Warning: The props are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(sizesAlreadyUsed / 1024)}KB) in size. Uploading them to ${providerSpecifics.serverStorageProductName()} to circumvent AWS Lambda payload size, which may lead to slowdown.`);
+    return true;
+  }
+  return false;
+};
+var compressInputProps = async ({
+  stringifiedInputProps,
+  region,
+  userSpecifiedBucketName,
+  propsType,
+  needsToUpload,
+  providerSpecifics,
+  forcePathStyle,
+  skipPutAcl
+}) => {
+  const hash = providerSpecifics.randomHash();
+  if (needsToUpload) {
+    const bucketName = userSpecifiedBucketName ?? (await internalGetOrCreateBucket({
+      region,
+      enableFolderExpiry: null,
+      customCredentials: null,
+      providerSpecifics,
+      forcePathStyle,
+      skipPutAcl
+    })).bucketName;
+    await providerSpecifics.writeFile({
+      body: stringifiedInputProps,
+      bucketName,
+      region,
+      customCredentials: null,
+      downloadBehavior: null,
+      expectedBucketOwner: null,
+      key: makeKey(propsType, hash),
+      privacy: "private",
+      forcePathStyle
+    });
+    return {
+      type: "bucket-url",
+      hash,
+      bucketName
+    };
+  }
+  return {
+    type: "payload",
+    payload: stringifiedInputProps
+  };
+};
+var decompressInputProps = async ({
+  serialized,
+  region,
+  bucketName,
+  expectedBucketOwner,
+  propsType,
+  providerSpecifics,
+  forcePathStyle
+}) => {
+  if (serialized.type === "payload") {
+    return serialized.payload;
+  }
+  try {
+    const response = await providerSpecifics.readFile({
+      bucketName,
+      expectedBucketOwner,
+      key: makeKey(propsType, serialized.hash),
+      region,
+      forcePathStyle
+    });
+    const body = await streamToString(response);
+    const payload = body;
+    return payload;
+  } catch (err) {
+    throw new Error(`Failed to parse input props that were serialized: ${err.stack}`);
+  }
+};
+// src/docs-url.ts
+var DOCS_URL = "https://remotion.dev";
+// src/error-category.ts
+var errorIsOutOfSpaceError = (err) => {
+  return err.includes("ENOSPC") || err.toLowerCase().includes("no space left on device");
+};
+var isErrInsufficientResourcesErr = (err) => {
+  return err.includes("net::ERR_INSUFFICIENT_RESOURCES");
+};
+var isBrowserCrashedError = (err) => {
+  return err.includes("Target closed.") || err.includes("Session closed");
+};
+// src/estimate-price-from-bucket.ts
+var estimatePriceFromMetadata = ({
+  renderMetadata,
+  memorySizeInMb,
+  diskSizeInMb,
+  functionsInvoked,
+  timings,
+  region,
+  providerSpecifics
+}) => {
+  if (!renderMetadata) {
+    return null;
+  }
+  const elapsedTime = Math.max(0, Date.now() - (renderMetadata?.startedDate ?? 0));
+  const unfinished = Math.max(0, (renderMetadata?.totalChunks ?? 0) - timings.length);
+  const timeElapsedOfUnfinished = new Array(unfinished).fill(true).map(() => elapsedTime).reduce((a, b) => a + b, 0);
+  const estimatedBillingDurationInMilliseconds = calculateChunkTimes({
+    type: "combined-time-for-cost-calculation",
+    timings
+  }) + timeElapsedOfUnfinished;
+  const accruedSoFar = Number(providerSpecifics.estimatePrice({
+    region,
+    durationInMilliseconds: estimatedBillingDurationInMilliseconds,
+    memorySizeInMb,
+    diskSizeInMb,
+    lambdasInvoked: functionsInvoked
+  }).toPrecision(5));
+  return { accruedSoFar, estimatedBillingDurationInMilliseconds };
+};
+// src/expected-out-name.ts
+var import_pure2 = __toESM(require_pure(), 1);
+
+// src/get-custom-out-name.ts
+var getCustomOutName = ({
+  renderMetadata,
+  customCredentials
+}) => {
+  if (!renderMetadata.outName) {
+    return null;
+  }
+  if (typeof renderMetadata.outName === "string") {
+    return renderMetadata.outName;
+  }
+  if (renderMetadata.outName.s3OutputProvider) {
+    if (!customCredentials && renderMetadata.privacy === "private") {
+      throw new TypeError(`The file was rendered with a custom S3 implementation and is not public, but no custom credentials were passed to downloadMedia().`);
+    }
+    return {
+      bucketName: renderMetadata.outName.bucketName,
+      key: renderMetadata.outName.key,
+      s3OutputProvider: {
+        endpoint: renderMetadata.outName.s3OutputProvider.endpoint,
+        accessKeyId: customCredentials?.accessKeyId ?? null,
+        secretAccessKey: customCredentials?.secretAccessKey ?? null,
+        region: customCredentials?.region,
+        forcePathStyle: customCredentials?.forcePathStyle ?? false
+      }
+    };
+  }
+  return {
+    bucketName: renderMetadata.outName.bucketName,
+    key: renderMetadata.outName.key
+  };
+};
+
+// src/validate-outname.ts
+var import_pure = __toESM(require_pure(), 1);
+
+// src/validate-bucket-name.ts
+var validateBucketName = ({
+  bucketName,
+  bucketNamePrefix,
+  options
+}) => {
+  if (typeof bucketName !== "string") {
+    throw new TypeError(`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`);
+  }
+  if (options.mustStartWithRemotion && !bucketName.startsWith(bucketNamePrefix)) {
+    throw new Error(`The bucketName parameter must start with ${bucketNamePrefix}.`);
+  }
+  if (!bucketName.match(/^(?=^.{3,63}$)(?!^(\d+\.)+\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])$)/)) {
+    throw new Error(`The bucket ${bucketName} `);
+  }
+};
+
+// src/validate-outname.ts
+var validateS3Key = (s3Key) => {
+  if (typeof s3Key !== "string") {
+    throw new TypeError("The S3 key must be a string. Passed an object of type " + typeof s3Key);
+  }
+  if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g)) {
+    throw new Error("The S3 Key must match the RegExp `/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g`. You passed: " + s3Key + ". Check for invalid characters.");
+  }
+};
+var validateOutname = ({
+  outName: outName2,
+  codec,
+  audioCodecSetting,
+  separateAudioTo,
+  bucketNamePrefix
+}) => {
+  if (typeof outName2 === "undefined" || outName2 === null) {
+    return;
+  }
+  if (typeof outName2 !== "string") {
+    validateS3Key(outName2.key);
+    validateBucketName({
+      bucketName: outName2.bucketName,
+      bucketNamePrefix,
+      options: {
+        mustStartWithRemotion: false
+      }
+    });
+    return;
+  }
+  if (codec) {
+    import_pure.NoReactAPIs.validateOutputFilename({
+      codec,
+      audioCodecSetting,
+      extension: import_pure.NoReactAPIs.getExtensionOfFilename(outName2),
+      preferLossless: false,
+      separateAudioTo
+    });
+  }
+  validateS3Key(outName2);
+};
+
+// src/expected-out-name.ts
+var getCredentialsFromOutName = (name) => {
+  if (typeof name === "string") {
+    return null;
+  }
+  if (name === null) {
+    return null;
+  }
+  if (typeof name === "undefined") {
+    return null;
+  }
+  return name.s3OutputProvider ?? null;
+};
+var getExpectedOutName = ({
+  renderMetadata,
+  bucketName,
+  customCredentials,
+  bucketNamePrefix
+}) => {
+  const outNameValue = getCustomOutName({
+    customCredentials,
+    renderMetadata
+  });
+  if (outNameValue) {
+    validateOutname({
+      outName: outNameValue,
+      codec: renderMetadata.codec,
+      audioCodecSetting: renderMetadata.audioCodec,
+      separateAudioTo: null,
+      bucketNamePrefix
+    });
+    return customOutName(renderMetadata.renderId, bucketName, outNameValue);
+  }
+  if (renderMetadata.type === "still") {
+    return {
+      renderBucketName: bucketName,
+      key: outStillName(renderMetadata.renderId, renderMetadata.imageFormat),
+      customCredentials: null
+    };
+  }
+  if (renderMetadata.type === "video") {
+    return {
+      renderBucketName: bucketName,
+      key: outName(renderMetadata.renderId, import_pure2.NoReactAPIs.getFileExtensionFromCodec(renderMetadata.codec, renderMetadata.audioCodec)),
+      customCredentials: null
+    };
+  }
+  throw new TypeError("no type passed");
+};
+// src/format-costs-info.ts
+var display = (accrued) => {
+  if (accrued < 0.001) {
+    return "<$0.001";
+  }
+  return new Intl.NumberFormat("en-US", {
+    currency: "USD",
+    style: "currency",
+    currencyDisplay: "narrowSymbol",
+    minimumFractionDigits: 3
+  }).format(accrued);
+};
+var formatCostsInfo = (accrued) => {
+  return {
+    accruedSoFar: accrued,
+    displayCost: display(accrued),
+    currency: "USD",
+    disclaimer: "Estimated cost only. Does not include charges for other AWS services."
+  };
+};
+// src/get-overall-progress-from-storage.ts
+var getOverallProgressFromStorage = async ({
+  renderId,
+  bucketName,
+  expectedBucketOwner,
+  region,
+  providerSpecifics,
+  forcePathStyle
+}) => {
+  try {
+    const Body = await providerSpecifics.readFile({
+      bucketName,
+      key: overallProgressKey(renderId),
+      expectedBucketOwner,
+      region,
+      forcePathStyle
+    });
+    const str = await streamToString(Body);
+    return JSON.parse(str);
+  } catch (err) {
+    if (err.name === "NotFound") {
+      throw new TypeError(`No render with ID "${renderId}" found in bucket ${bucketName} and region ${region}`);
+    }
+    throw err;
+  }
+};
+// src/inspect-error.ts
+var FAILED_TO_LAUNCH_TOKEN = "Failed to launch browser.";
+var getExplanation = (stack) => {
+  if (stack.includes("FATAL:zygote_communication_linux.cc")) {
+    return FAILED_TO_LAUNCH_TOKEN + " Will be retried - you can probably ignore this error.";
+  }
+  if (stack.includes("error while loading shared libraries: libnss3.so")) {
+    return FAILED_TO_LAUNCH_TOKEN + " Will be retried - you can probably ignore this error.";
+  }
+  if (stack.includes("TooManyRequestsException")) {
+    return `AWS returned an "TooManyRequestsException" error message which could mean you reached the concurrency limit of AWS Lambda. You can increase the limit - read this troubleshooting page: ${DOCS_URL}/docs/lambda/troubleshooting/rate-limit`;
+  }
+  if (errorIsOutOfSpaceError(stack)) {
+    return `Your lambda function reached the storage limit. Reduce the amount of space needed per lambda function or increase the storage limit: ${DOCS_URL}/docs/lambda/disk-size.`;
+  }
+  if (isErrInsufficientResourcesErr(stack)) {
+    return "The lambda ran out of memory. Deploy a new function with more memory.";
+  }
+  if (isBrowserCrashedError(stack)) {
+    return "The browser crashed while rendering the video. Deploy a new function with memory to give the browser more resources.";
+  }
+  return null;
+};
+var inspectErrors = ({
+  errors
+}) => {
+  return errors.map((e) => {
+    return {
+      ...e,
+      explanation: getExplanation(e.stack),
+      s3Location: ""
+    };
+  });
+};
+// src/most-expensive-chunks.ts
+var OVERHEAD_TIME_PER_LAMBDA = 100;
+var getMostExpensiveChunks = ({
+  parsedTimings,
+  framesPerFunction: framesPerLambda,
+  firstFrame,
+  lastFrame
+}) => {
+  const mostExpensiveChunks = parsedTimings.slice(0).sort((a, b) => {
+    const durA = a.rendered - a.start;
+    const durB = b.rendered - b.start;
+    return durB - durA;
+  }).slice(0, 5);
+  return mostExpensiveChunks.map((c) => {
+    const isLastChunk = c.chunk === parsedTimings.length - 1;
+    return {
+      timeInMilliseconds: c.rendered - c.start,
+      chunk: c.chunk,
+      frameRange: [
+        framesPerLambda * c.chunk + firstFrame,
+        isLastChunk ? lastFrame : framesPerLambda * (c.chunk + 1) - 1 + firstFrame
+      ]
+    };
+  });
+};
+// src/progress.ts
+var import_pure4 = __toESM(require_pure(), 1);
+
+// src/get-overall-progress.ts
+var weights = {
+  evaluating: 0.1,
+  encoding: 0.1,
+  frames: 0.6,
+  invoking: 0.1,
+  combining: 0.1
+};
+var getOverallProgress = ({
+  encoding,
+  invoking,
+  frames,
+  invokedLambda,
+  visitedServeUrl,
+  gotComposition,
+  combining
+}) => {
+  const evaluationProgress = [
+    Boolean(invokedLambda),
+    Boolean(visitedServeUrl),
+    Boolean(gotComposition)
+  ].reduce((a, b) => Number(a) + Number(b), 0) / 3;
+  return evaluationProgress * weights.evaluating + encoding * weights.encoding + invoking * weights.invoking + frames * weights.frames + combining * weights.combining;
+};
+
+// src/make-timeout-message.ts
+var MAX_MISSING_CHUNKS = 5;
+var makeChunkMissingMessage = ({
+  missingChunks,
+  renderMetadata,
+  region,
+  providerSpecifics,
+  functionName
+}) => {
+  if (missingChunks.length === 0) {
+    return "All chunks have been successfully rendered, but the main function has timed out.";
+  }
+  return [
+    `The following chunks are missing (showing ${Math.min(MAX_MISSING_CHUNKS, missingChunks.length)} out of ${missingChunks.length}):`,
+    ...missingChunks.map((ch) => {
+      const isLastChunk = ch === renderMetadata.totalChunks - 1;
+      const start = ch * renderMetadata.framesPerLambda;
+      const end = renderMetadata.type === "still" ? 0 : isLastChunk ? renderMetadata.frameRange[1] : (ch + 1) * renderMetadata.framesPerLambda - 1;
+      const msg = `Chunk ${ch} (Frames ${start} - ${end})`;
+      return [
+        msg,
+        `▸ Logs for chunk ${ch}: ${providerSpecifics.getLoggingUrlForRendererFunction({
+          functionName,
+          region,
+          rendererFunctionName: null,
+          renderId: renderMetadata.renderId,
+          chunk: ch
+        })}`
+      ].join(`
+`);
+    }).slice(0, 5)
+  ].join(`
+`);
+};
+var makeTimeoutMessage = ({
+  timeoutInMilliseconds,
+  missingChunks,
+  renderMetadata,
+  renderId,
+  functionName,
+  region,
+  providerSpecifics
+}) => {
+  const cloudWatchRendererUrl = providerSpecifics.getLoggingUrlForRendererFunction({
+    renderId,
+    functionName,
+    region,
+    rendererFunctionName: functionName,
+    chunk: null
+  });
+  const cloudWatchLaunchUrl = providerSpecifics.getLoggingUrlForMethod({
+    renderId,
+    functionName,
+    method: "launch" /* launch */,
+    region,
+    rendererFunctionName: functionName
+  });
+  const message = [
+    `The main function timed out after ${timeoutInMilliseconds}ms.`,
+    makeChunkMissingMessage({
+      missingChunks,
+      renderMetadata,
+      region,
+      providerSpecifics,
+      functionName
+    }),
+    "",
+    `Consider increasing the timeout of your function.`,
+    `▸ You can use the "--timeout" parameter when deploying a function via CLI, or the "timeoutInSeconds" parameter when using the deployFunction() API.`,
+    `${DOCS_URL}/docs/lambda/cli/functions#deploy`,
+    "",
+    "▸ Visit the logs for the main function:",
+    cloudWatchLaunchUrl,
+    "▸ Visit the logs for the renderer functions:",
+    cloudWatchRendererUrl,
+    "",
+    "▸ Get help on debugging this error:",
+    `${DOCS_URL}/docs/lambda/troubleshooting/debug`
+  ].join(`
+`);
+  return message;
+};
+
+// src/make-timeout-error.ts
+var makeTimeoutError = ({
+  timeoutInMilliseconds,
+  missingChunks,
+  renderMetadata,
+  renderId,
+  functionName,
+  region,
+  providerSpecifics
+}) => {
+  const message = makeTimeoutMessage({
+    missingChunks,
+    renderMetadata,
+    timeoutInMilliseconds,
+    renderId,
+    functionName,
+    region,
+    providerSpecifics
+  });
+  const error = new Error(message);
+  return {
+    attempt: 1,
+    chunk: null,
+    explanation: null,
+    frame: null,
+    isFatal: true,
+    s3Location: "",
+    stack: error.stack,
+    tmpDir: null,
+    totalAttempts: 1,
+    type: "stitcher",
+    willRetry: false,
+    message,
+    name: "TimeoutError"
+  };
+};
+
+// src/render-has-audio-video.ts
+var import_pure3 = __toESM(require_pure(), 1);
+var lambdaRenderHasAudioVideo = (renderMetadata) => {
+  if (renderMetadata.type === "still") {
+    throw new Error("Cannot merge stills");
+  }
+  const support = import_pure3.NoReactAPIs.codecSupportsMedia(renderMetadata.codec);
+  const hasVideo = renderMetadata ? !import_pure3.NoReactAPIs.isAudioCodec(renderMetadata.codec) : false;
+  const hasAudio = renderMetadata ? !renderMetadata.muted && support.audio : false;
+  return {
+    hasAudio,
+    hasVideo
+  };
+};
+
+// src/truthy.ts
+function truthy2(value) {
+  return Boolean(value);
+}
+
+// src/progress.ts
+var getProgress = async ({
+  bucketName,
+  renderId,
+  expectedBucketOwner,
+  region,
+  memorySizeInMb,
+  timeoutInMilliseconds,
+  customCredentials,
+  providerSpecifics,
+  forcePathStyle,
+  functionName
+}) => {
+  const overallProgress = await getOverallProgressFromStorage({
+    renderId,
+    bucketName,
+    expectedBucketOwner,
+    region,
+    providerSpecifics,
+    forcePathStyle
+  });
+  if (overallProgress.postRenderData) {
+    if (!overallProgress.renderMetadata) {
+      throw new Error("No render metadata found even though render is finished");
+    }
+    if (overallProgress.renderMetadata.type === "still") {
+      throw new Error("You don't need to call getRenderProgress() on a still render. Once you have obtained the `renderId`, the render is already done! \uD83D\uDE09");
+    }
+    const outData = getExpectedOutName({
+      renderMetadata: overallProgress.renderMetadata,
+      bucketName,
+      customCredentials,
+      bucketNamePrefix: providerSpecifics.getBucketPrefix()
+    });
+    const totalFrameCount = import_pure4.NoReactAPIs.getFramesToRender(overallProgress.renderMetadata.frameRange, overallProgress.renderMetadata.everyNthFrame).length;
+    return {
+      framesRendered: totalFrameCount,
+      bucket: bucketName,
+      renderSize: overallProgress.postRenderData.renderSize,
+      chunks: overallProgress.renderMetadata.totalChunks,
+      cleanup: {
+        doneIn: overallProgress.postRenderData.timeToCleanUp,
+        filesDeleted: overallProgress.postRenderData.filesCleanedUp,
+        minFilesToDelete: overallProgress.postRenderData.filesCleanedUp
+      },
+      costs: {
+        accruedSoFar: overallProgress.postRenderData.cost.estimatedCost,
+        displayCost: overallProgress.postRenderData.cost.estimatedDisplayCost,
+        currency: overallProgress.postRenderData.cost.currency,
+        disclaimer: overallProgress.postRenderData.cost.disclaimer
+      },
+      currentTime: Date.now(),
+      done: true,
+      encodingStatus: {
+        framesEncoded: totalFrameCount,
+        combinedFrames: totalFrameCount,
+        timeToCombine: overallProgress.postRenderData.timeToCombine
+      },
+      errors: overallProgress.postRenderData.errors,
+      fatalErrorEncountered: false,
+      lambdasInvoked: overallProgress.renderMetadata.totalChunks,
+      outputFile: overallProgress.postRenderData.outputFile,
+      renderId,
+      timeToFinish: overallProgress.postRenderData.timeToFinish,
+      timeToFinishChunks: overallProgress.postRenderData.timeToRenderChunks,
+      timeToRenderFrames: overallProgress.postRenderData.timeToRenderFrames,
+      overallProgress: 1,
+      retriesInfo: overallProgress.postRenderData.retriesInfo,
+      outKey: outData.key,
+      outBucket: outData.renderBucketName,
+      mostExpensiveFrameRanges: overallProgress.postRenderData.mostExpensiveFrameRanges ?? null,
+      timeToEncode: overallProgress.postRenderData.timeToEncode,
+      outputSizeInBytes: overallProgress.postRenderData.outputSize,
+      type: "success",
+      estimatedBillingDurationInMilliseconds: overallProgress.postRenderData.estimatedBillingDurationInMilliseconds,
+      timeToCombine: overallProgress.postRenderData.timeToCombine,
+      combinedFrames: totalFrameCount,
+      renderMetadata: overallProgress.renderMetadata,
+      timeoutTimestamp: overallProgress.timeoutTimestamp,
+      compositionValidated: overallProgress.compositionValidated,
+      functionLaunched: overallProgress.functionLaunched,
+      serveUrlOpened: overallProgress.serveUrlOpened,
+      artifacts: overallProgress.receivedArtifact
+    };
+  }
+  const { renderMetadata } = overallProgress;
+  const errorExplanations = inspectErrors({
+    errors: overallProgress.errors
+  });
+  const { hasAudio, hasVideo } = renderMetadata ? lambdaRenderHasAudioVideo(renderMetadata) : { hasAudio: false, hasVideo: false };
+  const chunkCount = overallProgress.chunks.length ?? 0;
+  const cleanup = {
+    doneIn: null,
+    minFilesToDelete: 0,
+    filesDeleted: 0
+  };
+  if (renderMetadata === null) {
+    return {
+      framesRendered: overallProgress.framesRendered ?? 0,
+      chunks: chunkCount,
+      done: false,
+      encodingStatus: {
+        framesEncoded: overallProgress.framesEncoded,
+        combinedFrames: overallProgress.combinedFrames,
+        timeToCombine: overallProgress.timeToCombine
+      },
+      timeToRenderFrames: overallProgress.timeToRenderFrames,
+      costs: formatCostsInfo(0),
+      renderId,
+      renderMetadata,
+      bucket: bucketName,
+      outputFile: null,
+      timeToFinish: null,
+      errors: errorExplanations,
+      fatalErrorEncountered: errorExplanations.some((f) => f.isFatal && !f.willRetry),
+      currentTime: Date.now(),
+      renderSize: 0,
+      lambdasInvoked: overallProgress.lambdasInvoked ?? 0,
+      cleanup,
+      timeToFinishChunks: null,
+      overallProgress: getOverallProgress({
+        encoding: 0,
+        invoking: 0,
+        frames: 0,
+        gotComposition: overallProgress.compositionValidated,
+        visitedServeUrl: overallProgress.serveUrlOpened,
+        invokedLambda: overallProgress.lambdasInvoked,
+        combining: 0
+      }),
+      retriesInfo: overallProgress.retries ?? [],
+      outKey: null,
+      outBucket: null,
+      mostExpensiveFrameRanges: null,
+      timeToEncode: overallProgress.timeToEncode,
+      outputSizeInBytes: null,
+      estimatedBillingDurationInMilliseconds: null,
+      combinedFrames: overallProgress.combinedFrames ?? 0,
+      timeToCombine: overallProgress.timeToCombine ?? null,
+      timeoutTimestamp: overallProgress.timeoutTimestamp,
+      type: "success",
+      compositionValidated: overallProgress.compositionValidated,
+      functionLaunched: overallProgress.functionLaunched,
+      serveUrlOpened: overallProgress.serveUrlOpened,
+      artifacts: overallProgress.receivedArtifact
+    };
+  }
+  const priceFromBucket = estimatePriceFromMetadata({
+    renderMetadata,
+    memorySizeInMb: providerSpecifics.parseFunctionName(renderMetadata.rendererFunctionName)?.memorySizeInMb ?? memorySizeInMb,
+    functionsInvoked: renderMetadata.estimatedRenderLambdaInvokations ?? 0,
+    diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+    timings: overallProgress.timings ?? [],
+    region,
+    providerSpecifics
+  });
+  const chunkMultiplier = [hasAudio, hasVideo].filter(truthy2).length;
+  if (renderMetadata.type === "still") {
+    throw new Error("You don't need to call getRenderProgress() on a still render. Once you have obtained the `renderId`, the render is already done! \uD83D\uDE09");
+  }
+  const allChunks = (overallProgress.chunks ?? []).length / chunkMultiplier === (renderMetadata.totalChunks ?? Infinity);
+  const frameCount = import_pure4.NoReactAPIs.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame).length;
+  const missingChunks = new Array(renderMetadata.totalChunks).fill(true).map((_, i) => i).filter((index) => {
+    return typeof (overallProgress.chunks ?? []).find((c) => c === index) === "undefined";
+  });
+  const isBeyondTimeoutAndMissingChunks = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000 && missingChunks && missingChunks.length > 0;
+  const isBeyondTimeoutAndHasStitchTimeout = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds * 2 + 20000;
+  const allErrors = [
+    isBeyondTimeoutAndMissingChunks || isBeyondTimeoutAndHasStitchTimeout ? makeTimeoutError({
+      timeoutInMilliseconds,
+      renderMetadata,
+      renderId,
+      missingChunks: missingChunks ?? [],
+      region,
+      functionName,
+      providerSpecifics
+    }) : null,
+    ...errorExplanations
+  ].filter(truthy2);
+  return {
+    framesRendered: overallProgress.framesRendered ?? 0,
+    chunks: chunkCount,
+    done: false,
+    encodingStatus: {
+      framesEncoded: overallProgress.framesEncoded,
+      combinedFrames: overallProgress.combinedFrames,
+      timeToCombine: overallProgress.timeToCombine
+    },
+    timeToRenderFrames: overallProgress.timeToRenderFrames,
+    costs: priceFromBucket ? formatCostsInfo(priceFromBucket.accruedSoFar) : formatCostsInfo(0),
+    renderId,
+    renderMetadata,
+    bucket: bucketName,
+    outputFile: null,
+    timeToFinish: null,
+    errors: allErrors,
+    fatalErrorEncountered: allErrors.some((f) => f.isFatal && !f.willRetry),
+    currentTime: Date.now(),
+    renderSize: 0,
+    lambdasInvoked: overallProgress.lambdasInvoked ?? 0,
+    cleanup,
+    timeToFinishChunks: allChunks && overallProgress ? calculateChunkTimes({
+      type: "absolute-time",
+      timings: overallProgress.timings
+    }) : null,
+    overallProgress: getOverallProgress({
+      encoding: frameCount ? (overallProgress.framesEncoded ?? 0) / frameCount : 0,
+      invoking: (overallProgress.lambdasInvoked ?? 0) / renderMetadata.estimatedRenderLambdaInvokations,
+      frames: (overallProgress.framesRendered ?? 0) / (frameCount ?? 1),
+      gotComposition: overallProgress.compositionValidated,
+      visitedServeUrl: overallProgress.serveUrlOpened,
+      invokedLambda: overallProgress.lambdasInvoked,
+      combining: overallProgress.combinedFrames / (frameCount ?? 1)
+    }),
+    retriesInfo: overallProgress.retries ?? [],
+    outKey: null,
+    outBucket: null,
+    mostExpensiveFrameRanges: null,
+    timeToEncode: overallProgress.timeToEncode,
+    outputSizeInBytes: null,
+    estimatedBillingDurationInMilliseconds: priceFromBucket ? priceFromBucket.estimatedBillingDurationInMilliseconds : null,
+    combinedFrames: overallProgress.combinedFrames ?? 0,
+    timeToCombine: overallProgress.timeToCombine ?? null,
+    timeoutTimestamp: overallProgress.timeoutTimestamp,
+    type: "success",
+    compositionValidated: overallProgress.compositionValidated,
+    functionLaunched: overallProgress.functionLaunched,
+    serveUrlOpened: overallProgress.serveUrlOpened,
+    artifacts: overallProgress.receivedArtifact
+  };
+};
+// src/streaming/streaming.ts
+var import_streaming = __toESM(require_dist(), 1);
+var framesRendered = "frames-rendered";
+var errorOccurred = "error-occurred";
+var renderIdDetermined = "render-id-determined";
+var videoChunkRendered = "video-chunk-rendered";
+var audioChunkRendered = "audio-chunk-rendered";
+var chunkComplete = "chunk-complete";
+var stillRendered = "still-rendered";
+var functionInvoked = "lambda-invoked";
+var artifactEmitted = "artifact-emitted";
+var messageTypes = {
+  "1": { type: framesRendered },
+  "2": { type: errorOccurred },
+  "3": { type: renderIdDetermined },
+  "4": { type: videoChunkRendered },
+  "5": { type: audioChunkRendered },
+  "6": { type: stillRendered },
+  "7": { type: chunkComplete },
+  "8": { type: functionInvoked },
+  "9": { type: artifactEmitted }
+};
+var formatMap = {
+  [framesRendered]: "json",
+  [errorOccurred]: "json",
+  [renderIdDetermined]: "json",
+  [videoChunkRendered]: "binary",
+  [audioChunkRendered]: "binary",
+  [stillRendered]: "json",
+  [chunkComplete]: "json",
+  [functionInvoked]: "json",
+  [artifactEmitted]: "json"
+};
+var messageTypeIdToMessageType = (messageTypeId) => {
+  const types = messageTypes[messageTypeId];
+  if (!types) {
+    throw new Error(`Unknown message type id ${messageTypeId}`);
+  }
+  return types.type;
+};
+var messageTypeToMessageId = (messageType) => {
+  const id = Object.keys(messageTypes).find((key) => messageTypes[key].type === messageType);
+  if (!id) {
+    throw new Error(`Unknown message type ${messageType}`);
+  }
+  return id;
+};
+var makeStreamPayload = ({
+  message
+}) => {
+  const body = formatMap[message.type] === "json" ? new TextEncoder().encode(JSON.stringify(message.payload)) : message.payload;
+  return import_streaming.makeStreamPayloadMessage({
+    body,
+    nonce: messageTypeToMessageId(message.type),
+    status: 0
+  });
+};
+// src/validate-privacy.ts
+function validatePrivacy(privacy, allowPrivate) {
+  if (typeof privacy !== "string") {
+    throw new TypeError("Privacy must be a string");
+  }
+  if (!allowPrivate && privacy === "private") {
+    throw new TypeError('Privacy must be either "public" or "no-acl"');
+  }
+  if (privacy !== "private" && privacy !== "public" && privacy !== "no-acl") {
+    throw new TypeError('Privacy must be either "private", "public" or "no-acl"');
+  }
+}
+// src/index.ts
+var {
+  ENABLE_V5_BREAKING_CHANGES: ENABLE_V5_BREAKING_CHANGES2,
+  serializeJSONWithDate: serializeJSONWithDate2,
+  validateFps: validateFps2,
+  validateDimension: validateDimension2,
+  validateDurationInFrames: validateDurationInFrames2
+} = NoReactInternals;
+var export_wrapWithErrorHandling = import_error_handling.wrapWithErrorHandling;
+var export_makeStreamer = import_streaming2.makeStreamer;
+var export_makeStreamPayloadMessage = import_streaming2.makeStreamPayloadMessage;
+
+export {
+  export_wrapWithErrorHandling as wrapWithErrorHandling,
+  validateWebhook,
+  validatePrivacy,
+  validateOutname,
+  validateFramesPerFunction,
+  validateFps2 as validateFps,
+  validateDurationInFrames2 as validateDurationInFrames,
+  validateDownloadBehavior,
+  validateDimension2 as validateDimension,
+  validateBucketName,
+  truthy2 as truthy,
+  streamToString,
+  serverlessCodecs,
+  serializeOrThrow,
+  serializeJSONWithDate2 as serializeJSONWithDate,
+  serializeArtifact,
+  resolvedPropsKey,
+  rendersPrefix,
+  random,
+  overallProgressKey,
+  outStillName,
+  outName,
+  messageTypeIdToMessageType,
+  export_makeStreamer as makeStreamer,
+  export_makeStreamPayloadMessage as makeStreamPayloadMessage,
+  makeStreamPayload,
+  makeBucketName,
+  isErrInsufficientResourcesErr,
+  isBrowserCrashedError,
+  interpolate,
+  internalGetOrCreateBucket,
+  inspectErrors,
+  inputPropsKey,
+  getProgress,
+  getOverallProgressFromStorage,
+  getNeedsToUpload,
+  getMostExpensiveChunks,
+  getExpectedOutName,
+  getCredentialsFromOutName,
+  formatMap,
+  formatCostsInfo,
+  expiryDays,
+  estimatePriceFromMetadata,
+  errorIsOutOfSpaceError,
+  deserializeArtifact,
+  decompressInputProps,
+  customOutName,
+  compressInputProps,
+  calculateChunkTimes,
+  artifactName,
+  VERSION,
+  ServerlessRoutines,
+  RENDERER_PATH_TOKEN,
+  REMOTION_FILELIST_TOKEN,
+  REMOTION_CONCATENATED_TOKEN,
+  OVERHEAD_TIME_PER_LAMBDA,
+  MINIMUM_FRAMES_PER_FUNCTIONS,
+  MAX_FUNCTIONS_PER_RENDER,
+  ENABLE_V5_BREAKING_CHANGES2 as ENABLE_V5_BREAKING_CHANGES,
+  DOCS_URL,
+  CONCAT_FOLDER_TOKEN,
+  COMMAND_NOT_FOUND
+};