@remotion/renderer 4.0.267 → 4.0.269

package/dist/esm/client.mjs

@@ -0,0 +1,3095 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../node_modules/.pnpm/react@19.0.0/node_modules/react/cjs/react-jsx-runtime.production.js
+var exports_react_jsx_runtime_production = {};
+__export(exports_react_jsx_runtime_production, {
+  jsxs: () => $jsxs,
+  jsx: () => $jsx,
+  Fragment: () => $Fragment
+});
+function jsxProd(type, config, maybeKey) {
+  var key = null;
+  maybeKey !== undefined && (key = "" + maybeKey);
+  config.key !== undefined && (key = "" + config.key);
+  if ("key" in config) {
+    maybeKey = {};
+    for (var propName in config)
+      propName !== "key" && (maybeKey[propName] = config[propName]);
+  } else
+    maybeKey = config;
+  config = maybeKey.ref;
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type,
+    key,
+    ref: config !== undefined ? config : null,
+    props: maybeKey
+  };
+}
+var REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, $Fragment, $jsx, $jsxs;
+var init_react_jsx_runtime_production = __esm(() => {
+  REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  $Fragment = REACT_FRAGMENT_TYPE;
+  $jsx = jsxProd;
+  $jsxs = jsxProd;
+});
+
+// ../../node_modules/.pnpm/react@19.0.0/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS((exports, module) => {
+  init_react_jsx_runtime_production();
+  if (true) {
+    module.exports = exports_react_jsx_runtime_production;
+  } else {
+  }
+});
+
+// src/browser/TimeoutSettings.ts
+var DEFAULT_TIMEOUT = 30000;
+
+class TimeoutSettings {
+  #defaultTimeout;
+  #defaultNavigationTimeout;
+  constructor() {
+    this.#defaultTimeout = null;
+    this.#defaultNavigationTimeout = null;
+  }
+  setDefaultTimeout(timeout) {
+    this.#defaultTimeout = timeout;
+  }
+  setDefaultNavigationTimeout(timeout) {
+    this.#defaultNavigationTimeout = timeout;
+  }
+  navigationTimeout() {
+    if (this.#defaultNavigationTimeout !== null) {
+      return this.#defaultNavigationTimeout;
+    }
+    if (this.#defaultTimeout !== null) {
+      return this.#defaultTimeout;
+    }
+    return DEFAULT_TIMEOUT;
+  }
+  timeout() {
+    if (this.#defaultTimeout !== null) {
+      return this.#defaultTimeout;
+    }
+    return DEFAULT_TIMEOUT;
+  }
+}
+
+// src/codec.ts
+var validCodecs = [
+  "h264",
+  "h265",
+  "vp8",
+  "vp9",
+  "mp3",
+  "aac",
+  "wav",
+  "prores",
+  "h264-mkv",
+  "h264-ts",
+  "gif"
+];
+var DEFAULT_CODEC = "h264";
+
+// src/crf.ts
+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;
+};
+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;
+};
+
+// src/codec-supports-media.ts
+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 = getValidCrfRanges(codec);
+  return range[0] !== range[1];
+};
+var codecSupportsVideoBitrate = (codec) => {
+  return codecSupportsVideoBitrateMap[codec];
+};
+
+// src/file-extensions.ts
+var defaultFileExtensionMap = {
+  "h264-mkv": {
+    default: "mkv",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv"], default: "mkv" },
+      mp3: { possible: ["mkv"], default: "mkv" }
+    }
+  },
+  "h264-ts": {
+    default: "ts",
+    forAudioCodec: {
+      "pcm-16": { possible: ["ts"], default: "ts" },
+      aac: { possible: ["ts"], default: "ts" }
+    }
+  },
+  aac: {
+    default: "aac",
+    forAudioCodec: {
+      aac: {
+        possible: ["aac", "3gp", "m4a", "m4b", "mpg", "mpeg"],
+        default: "aac"
+      },
+      "pcm-16": {
+        possible: ["wav"],
+        default: "wav"
+      }
+    }
+  },
+  gif: {
+    default: "gif",
+    forAudioCodec: {}
+  },
+  h264: {
+    default: "mp4",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv", "mov"], default: "mkv" },
+      aac: { possible: ["mp4", "mkv", "mov"], default: "mp4" },
+      mp3: { possible: ["mp4", "mkv", "mov"], default: "mp4" }
+    }
+  },
+  h265: {
+    default: "mp4",
+    forAudioCodec: {
+      aac: { possible: ["mp4", "mkv", "hevc"], default: "mp4" },
+      "pcm-16": { possible: ["mkv"], default: "mkv" }
+    }
+  },
+  mp3: {
+    default: "mp3",
+    forAudioCodec: {
+      mp3: { possible: ["mp3"], default: "mp3" },
+      "pcm-16": { possible: ["wav"], default: "wav" }
+    }
+  },
+  prores: {
+    default: "mov",
+    forAudioCodec: {
+      aac: { possible: ["mov", "mkv", "mxf"], default: "mov" },
+      "pcm-16": { possible: ["mov", "mkv", "mxf"], default: "mov" }
+    }
+  },
+  vp8: {
+    default: "webm",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv"], default: "mkv" },
+      opus: { possible: ["webm"], default: "webm" }
+    }
+  },
+  vp9: {
+    default: "webm",
+    forAudioCodec: {
+      "pcm-16": { possible: ["mkv"], default: "mkv" },
+      opus: { possible: ["webm"], default: "webm" }
+    }
+  },
+  wav: {
+    default: "wav",
+    forAudioCodec: {
+      "pcm-16": { possible: ["wav"], default: "wav" }
+    }
+  }
+};
+
+// src/get-extension-from-codec.ts
+var getFileExtensionFromCodec = (codec, audioCodec) => {
+  if (!validCodecs.includes(codec)) {
+    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${codec}`);
+  }
+  const map = defaultFileExtensionMap[codec];
+  if (audioCodec === null) {
+    return map.default;
+  }
+  const typedAudioCodec = audioCodec;
+  if (!(typedAudioCodec in map.forAudioCodec)) {
+    throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+  }
+  return map.forAudioCodec[audioCodec].default;
+};
+var makeFileExtensionMap = () => {
+  const map = {};
+  Object.keys(defaultFileExtensionMap).forEach((_codec) => {
+    const codec = _codec;
+    const fileExtMap = 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;
+};
+var 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"
+};
+
+// src/image-format.ts
+var validVideoImageFormats = ["png", "jpeg", "none"];
+var validStillImageFormats = ["png", "jpeg", "pdf", "webp"];
+
+// src/jpeg-quality.ts
+var DEFAULT_JPEG_QUALITY = 80;
+var validateJpegQuality = (q) => {
+  if (typeof q !== "undefined" && typeof q !== "number") {
+    throw new Error(`JPEG Quality option must be a number or undefined. Got ${typeof q} (${JSON.stringify(q)})`);
+  }
+  if (typeof q === "undefined") {
+    return;
+  }
+  if (!Number.isFinite(q)) {
+    throw new RangeError(`JPEG Quality must be a finite number, but is ${q}`);
+  }
+  if (Number.isNaN(q)) {
+    throw new RangeError(`JPEG Quality is NaN, but must be a real number`);
+  }
+  if (q > 100 || q < 0) {
+    throw new RangeError("JPEG Quality option must be between 0 and 100.");
+  }
+};
+
+// src/log-level.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isValidLogLevel = (level) => {
+  return getNumberForLogLevel(level) > -1;
+};
+
+// src/options/api-key.tsx
+var jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var currentApiKey = null;
+var cliFlag = "api-key";
+var apiKeyOption = {
+  name: "API key",
+  cliFlag,
+  description: () => /* @__PURE__ */ jsx_runtime.jsxs(jsx_runtime.Fragment, {
+    children: [
+      "API key for sending a usage event using ",
+      /* @__PURE__ */ jsx_runtime.jsx("code", {
+        children: "@remotion/licensing"
+      }),
+      "."
+    ]
+  }),
+  ssrName: "apiKey",
+  docLink: "https://www.remotion.dev/docs/licensing",
+  type: null,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag]
+      };
+    }
+    return {
+      source: "default",
+      value: currentApiKey
+    };
+  },
+  setConfig: (value) => {
+    currentApiKey = value;
+  }
+};
+
+// src/options/audio-bitrate.tsx
+var jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
+var cliFlag2 = "audio-bitrate";
+var audioBitrate = null;
+var audioBitrateOption = {
+  name: "Audio Bitrate",
+  cliFlag: cliFlag2,
+  description: () => /* @__PURE__ */ jsx_runtime2.jsxs(jsx_runtime2.Fragment, {
+    children: [
+      "Specify the target bitrate for the generated video. The syntax for FFmpeg",
+      "'",
+      "s ",
+      /* @__PURE__ */ jsx_runtime2.jsx("code", {
+        children: "-b:a"
+      }),
+      " parameter should be used. FFmpeg may encode the video in a way that will not result in the exact audio bitrate specified. Example values: ",
+      /* @__PURE__ */ jsx_runtime2.jsx("code", {
+        children: "512K"
+      }),
+      " for 512 kbps, ",
+      /* @__PURE__ */ jsx_runtime2.jsx("code", {
+        children: "1M"
+      }),
+      " for 1 Mbps. Default: ",
+      /* @__PURE__ */ jsx_runtime2.jsx("code", {
+        children: "320k"
+      })
+    ]
+  }),
+  ssrName: "audioBitrate",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#audiobitrate-",
+  type: "0",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag2]) {
+      return {
+        value: commandLine[cliFlag2],
+        source: "cli"
+      };
+    }
+    if (audioBitrate) {
+      return {
+        value: audioBitrate,
+        source: "config file"
+      };
+    }
+    return {
+      value: null,
+      source: "default"
+    };
+  },
+  setConfig: (value) => {
+    audioBitrate = value;
+  }
+};
+
+// src/options/separate-audio.tsx
+var DEFAULT = null;
+var cliFlag3 = "separate-audio-to";
+var separateAudioOption = {
+  cliFlag: cliFlag3,
+  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[cliFlag3]) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag3]
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT
+    };
+  },
+  name: "Separate audio to",
+  setConfig: () => {
+    throw new Error("Not implemented");
+  },
+  ssrName: "separateAudioTo",
+  type: "string"
+};
+
+// src/options/audio-codec.tsx
+var validAudioCodecs = ["pcm-16", "aac", "mp3", "opus"];
+var supportedAudioCodecs = {
+  h264: ["aac", "pcm-16", "mp3"],
+  "h264-mkv": ["pcm-16", "mp3"],
+  "h264-ts": ["pcm-16", "aac"],
+  aac: ["aac", "pcm-16"],
+  avi: [],
+  gif: [],
+  h265: ["aac", "pcm-16"],
+  mp3: ["mp3", "pcm-16"],
+  prores: ["aac", "pcm-16"],
+  vp8: ["opus", "pcm-16"],
+  vp9: ["opus", "pcm-16"],
+  wav: ["pcm-16"]
+};
+var _satisfies = supportedAudioCodecs;
+if (_satisfies) {
+}
+var cliFlag4 = "audio-codec";
+var ssrName = "audioCodec";
+var defaultAudioCodecs = {
+  "h264-mkv": {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  },
+  "h264-ts": {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  aac: {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  gif: {
+    lossless: null,
+    compressed: null
+  },
+  h264: {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  h265: {
+    lossless: "pcm-16",
+    compressed: "aac"
+  },
+  mp3: {
+    lossless: "pcm-16",
+    compressed: "mp3"
+  },
+  prores: {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  },
+  vp8: {
+    lossless: "pcm-16",
+    compressed: "opus"
+  },
+  vp9: {
+    lossless: "pcm-16",
+    compressed: "opus"
+  },
+  wav: {
+    lossless: "pcm-16",
+    compressed: "pcm-16"
+  }
+};
+var extensionMap = {
+  aac: "aac",
+  mp3: "mp3",
+  opus: "opus",
+  "pcm-16": "wav"
+};
+var getExtensionFromAudioCodec = (audioCodec) => {
+  if (extensionMap[audioCodec]) {
+    return extensionMap[audioCodec];
+  }
+  throw new Error(`Unsupported audio codec: ${audioCodec}`);
+};
+var resolveAudioCodec = ({
+  codec,
+  setting,
+  preferLossless,
+  separateAudioTo
+}) => {
+  let derivedFromSeparateAudioToExtension = null;
+  if (separateAudioTo) {
+    const extension = separateAudioTo.split(".").pop();
+    for (const [key, value] of Object.entries(extensionMap)) {
+      if (value === extension) {
+        derivedFromSeparateAudioToExtension = key;
+        if (!supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) && derivedFromSeparateAudioToExtension) {
+          throw new Error(`The codec is ${codec} but the audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${supportedAudioCodecs[codec].join(", ")}`);
+        }
+      }
+    }
+  }
+  if (preferLossless) {
+    const selected = getDefaultAudioCodec({ codec, preferLossless });
+    if (derivedFromSeparateAudioToExtension && selected !== derivedFromSeparateAudioToExtension) {
+      throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+    }
+    return selected;
+  }
+  if (setting === null) {
+    if (derivedFromSeparateAudioToExtension) {
+      return derivedFromSeparateAudioToExtension;
+    }
+    return getDefaultAudioCodec({ codec, preferLossless });
+  }
+  if (derivedFromSeparateAudioToExtension !== setting && derivedFromSeparateAudioToExtension) {
+    throw new Error(`The audio codec derived from --${separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+  }
+  return setting;
+};
+var getDefaultAudioCodec = ({
+  codec,
+  preferLossless
+}) => {
+  return defaultAudioCodecs[codec][preferLossless ? "lossless" : "compressed"];
+};
+var _audioCodec = null;
+var audioCodecOption = {
+  cliFlag: cliFlag4,
+  setConfig: (audioCodec) => {
+    if (audioCodec === null) {
+      _audioCodec = null;
+      return;
+    }
+    if (!validAudioCodecs.includes(audioCodec)) {
+      throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${audioCodec}`);
+    }
+    _audioCodec = audioCodec;
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag4]) {
+      const codec = commandLine[cliFlag4];
+      if (!validAudioCodecs.includes(commandLine[cliFlag4])) {
+        throw new Error(`Audio codec must be one of the following: ${validAudioCodecs.join(", ")}, but got ${codec}`);
+      }
+      return {
+        source: "cli",
+        value: commandLine[cliFlag4]
+      };
+    }
+    if (_audioCodec !== null) {
+      return {
+        source: "config",
+        value: _audioCodec
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
+  docLink: "https://www.remotion.dev/docs/encoding/#audio-codec",
+  name: "Audio Codec",
+  ssrName,
+  type: "aac"
+};
+
+// src/options/beep-on-finish.tsx
+var jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
+var beepOnFinish = false;
+var cliFlag5 = "beep-on-finish";
+var beepOnFinishOption = {
+  name: "Beep on finish",
+  cliFlag: cliFlag5,
+  description: () => /* @__PURE__ */ jsx_runtime3.jsx(jsx_runtime3.Fragment, {
+    children: "Whether the Remotion Studio tab should beep when the render is finished."
+  }),
+  ssrName: null,
+  docLink: "https://www.remotion.dev/docs/config#setbeeponfinish",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag5] !== undefined) {
+      return {
+        value: commandLine[cliFlag5],
+        source: "cli"
+      };
+    }
+    if (beepOnFinish !== false) {
+      return {
+        value: beepOnFinish,
+        source: "config"
+      };
+    }
+    return {
+      value: false,
+      source: "default"
+    };
+  },
+  setConfig(value) {
+    beepOnFinish = value;
+  }
+};
+
+// src/options/binaries-directory.tsx
+var jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
+var cliFlag6 = "binaries-directory";
+var currentDirectory = null;
+var binariesDirectoryOption = {
+  name: "Binaries Directory",
+  cliFlag: cliFlag6,
+  description: () => /* @__PURE__ */ jsx_runtime4.jsxs(jsx_runtime4.Fragment, {
+    children: [
+      "The directory where the platform-specific binaries and libraries that Remotion needs are located. Those include an ",
+      /* @__PURE__ */ jsx_runtime4.jsx("code", {
+        children: "ffmpeg"
+      }),
+      " and",
+      " ",
+      /* @__PURE__ */ jsx_runtime4.jsx("code", {
+        children: "ffprobe"
+      }),
+      " binary, a Rust binary for various tasks, and various shared libraries. If the value is set to ",
+      /* @__PURE__ */ jsx_runtime4.jsx("code", {
+        children: "null"
+      }),
+      ", which is the default, then the path of a platform-specific package located at",
+      " ",
+      /* @__PURE__ */ jsx_runtime4.jsx("code", {
+        children: "node_modules/@remotion/compositor-*"
+      }),
+      " is selected.",
+      /* @__PURE__ */ jsx_runtime4.jsx("br", {}),
+      "This option is useful in environments where Remotion is not officially supported to run like bundled serverless functions or Electron."
+    ]
+  }),
+  ssrName: "binariesDirectory",
+  docLink: "https://www.remotion.dev/docs/renderer",
+  type: "",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag6] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag6]
+      };
+    }
+    if (currentDirectory !== null) {
+      return {
+        source: "config",
+        value: currentDirectory
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (value) => {
+    currentDirectory = value;
+  }
+};
+
+// src/options/chrome-mode.tsx
+var jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
+var validChromeModeOptions = [
+  "headless-shell",
+  "chrome-for-testing"
+];
+var cliFlag7 = "chrome-mode";
+var configSelection = null;
+var chromeModeOption = {
+  cliFlag: cliFlag7,
+  name: "Chrome Mode",
+  ssrName: "chromeMode",
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime5.jsxs(jsx_runtime5.Fragment, {
+      children: [
+        "One of",
+        " ",
+        validChromeModeOptions.map((option, i) => /* @__PURE__ */ jsx_runtime5.jsxs("code", {
+          children: [
+            option,
+            i === validChromeModeOptions.length - 1 ? "" : ", "
+          ]
+        }, option)),
+        ". Default ",
+        /* @__PURE__ */ jsx_runtime5.jsx("code", {
+          children: "headless-shell"
+        }),
+        ".",
+        " ",
+        /* @__PURE__ */ jsx_runtime5.jsxs("a", {
+          href: "https://remotion.dev/docs/miscellaneous/chrome-headless-shell",
+          children: [
+            "Use ",
+            /* @__PURE__ */ jsx_runtime5.jsx("code", {
+              children: "chrome-for-testing"
+            }),
+            " to take advantage of GPU drivers on Linux."
+          ]
+        })
+      ]
+    });
+  },
+  docLink: "https://www.remotion.dev/chrome-for-testing",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag7]) {
+      if (!validChromeModeOptions.includes(commandLine[cliFlag7])) {
+        throw new Error(`Invalid \`--${cliFlag7}\` value passed. Accepted values: ${validChromeModeOptions.map((l) => `'${l}'`).join(", ")}.`);
+      }
+      return {
+        value: commandLine[cliFlag7],
+        source: "cli"
+      };
+    }
+    if (configSelection !== null) {
+      return {
+        value: configSelection,
+        source: "config"
+      };
+    }
+    return {
+      value: "headless-shell",
+      source: "default"
+    };
+  },
+  setConfig: (newChromeMode) => {
+    configSelection = newChromeMode;
+  },
+  type: "headless-shell"
+};
+
+// src/options/color-space.tsx
+var jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
+import { NoReactInternals } from "remotion/no-react";
+var validV4ColorSpaces = ["default", "bt709", "bt2020-ncl"];
+var validV5ColorSpaces = ["bt601", "bt709", "bt2020-ncl"];
+var validColorSpaces = NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? validV5ColorSpaces : validV4ColorSpaces;
+var DEFAULT_COLOR_SPACE = NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? "bt709" : "default";
+var colorSpace = DEFAULT_COLOR_SPACE;
+var cliFlag8 = "color-space";
+var colorSpaceOption = {
+  name: "Color space",
+  cliFlag: "color-space",
+  description: () => /* @__PURE__ */ jsx_runtime6.jsxs(jsx_runtime6.Fragment, {
+    children: [
+      "Color space to use for the video. Acceptable values:",
+      " ",
+      /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+        children: [
+          '"',
+          DEFAULT_COLOR_SPACE,
+          '"'
+        ]
+      }),
+      "(default since 5.0),",
+      " ",
+      NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+        children: [
+          '"',
+          "bt601",
+          '"',
+          ", "
+        ]
+      }) : /* @__PURE__ */ jsx_runtime6.jsxs(jsx_runtime6.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+            children: [
+              '"',
+              "bt709",
+              '"'
+            ]
+          }),
+          " ",
+          "(since v4.0.28),",
+          " "
+        ]
+      }),
+      /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+        children: [
+          '"',
+          "bt2020-ncl",
+          '"'
+        ]
+      }),
+      " ",
+      "(since v4.0.88),",
+      " ",
+      /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+        children: [
+          '"',
+          "bt2020-cl",
+          '"'
+        ]
+      }),
+      " ",
+      "(since v4.0.88), .",
+      /* @__PURE__ */ jsx_runtime6.jsx("br", {}),
+      "For best color accuracy, it is recommended to also use",
+      " ",
+      /* @__PURE__ */ jsx_runtime6.jsxs("code", {
+        children: [
+          '"',
+          "png",
+          '"'
+        ]
+      }),
+      " ",
+      "as the image format to have accurate color transformations throughout.",
+      /* @__PURE__ */ jsx_runtime6.jsx("br", {}),
+      "Only since v4.0.83, colorspace conversion is actually performed, previously it would only tag the metadata of the video."
+    ]
+  }),
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#colorspace",
+  ssrName: "colorSpace",
+  type: DEFAULT_COLOR_SPACE,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag8] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag8]
+      };
+    }
+    if (colorSpace !== DEFAULT_COLOR_SPACE) {
+      return {
+        source: "config",
+        value: colorSpace
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT_COLOR_SPACE
+    };
+  },
+  setConfig: (value) => {
+    colorSpace = value ?? DEFAULT_COLOR_SPACE;
+  }
+};
+
+// src/options/crf.tsx
+var jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
+var currentCrf;
+var validateCrf = (newCrf) => {
+  if (typeof newCrf !== "number" && newCrf !== undefined) {
+    throw new TypeError("The CRF must be a number or undefined.");
+  }
+};
+var cliFlag9 = "crf";
+var crfOption = {
+  name: "CRF",
+  cliFlag: cliFlag9,
+  description: () => /* @__PURE__ */ jsx_runtime7.jsx(jsx_runtime7.Fragment, {
+    children: "No matter which codec you end up using, there's always a tradeoff between file size and video quality. You can control it by setting the CRF (Constant Rate Factor). The lower the number, the better the quality, the higher the number, the smaller the file is – of course at the cost of quality."
+  }),
+  ssrName: "crf",
+  docLink: "https://www.remotion.dev/docs/encoding/#controlling-quality-using-the-crf-setting",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag9] !== undefined) {
+      validateCrf(commandLine[cliFlag9]);
+      return {
+        source: "cli",
+        value: commandLine[cliFlag9]
+      };
+    }
+    if (currentCrf !== null) {
+      return {
+        source: "config",
+        value: currentCrf
+      };
+    }
+    return {
+      source: "default",
+      value: undefined
+    };
+  },
+  setConfig: (crf) => {
+    validateCrf(crf);
+    currentCrf = crf;
+  }
+};
+
+// src/options/delete-after.tsx
+var jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
+var cliFlag10 = "delete-after";
+var deleteAfter = null;
+var deleteAfterOption = {
+  name: "Lambda render expiration",
+  cliFlag: cliFlag10,
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime8.jsxs(jsx_runtime8.Fragment, {
+      children: [
+        "Automatically delete the render after a certain period. Accepted values are ",
+        /* @__PURE__ */ jsx_runtime8.jsx("code", {
+          children: "1-day"
+        }),
+        ", ",
+        /* @__PURE__ */ jsx_runtime8.jsx("code", {
+          children: "3-days"
+        }),
+        ", ",
+        /* @__PURE__ */ jsx_runtime8.jsx("code", {
+          children: "7-days"
+        }),
+        " and",
+        " ",
+        /* @__PURE__ */ jsx_runtime8.jsx("code", {
+          children: "30-days"
+        }),
+        ".",
+        /* @__PURE__ */ jsx_runtime8.jsx("br", {}),
+        " For this to work, your bucket needs to have",
+        " ",
+        /* @__PURE__ */ jsx_runtime8.jsx("a", {
+          href: "/docs/lambda/autodelete",
+          children: "lifecycles enabled"
+        }),
+        "."
+      ]
+    });
+  },
+  ssrName: "deleteAfter",
+  docLink: "https://www.remotion.dev/docs/lambda/autodelete",
+  type: "1-day",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag10] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag10]
+      };
+    }
+    if (deleteAfter !== null) {
+      return {
+        source: "config",
+        value: deleteAfter
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (value) => {
+    deleteAfter = value;
+  }
+};
+
+// src/options/disable-git-source.tsx
+var DEFAULT2 = false;
+var cliFlag11 = "disable-git-source";
+var disableGitSourceOption = {
+  cliFlag: cliFlag11,
+  description: () => `Disables the Git Source being connected to the Remotion Studio. Clicking on stack traces and certain menu items will be disabled.`,
+  docLink: "https://remotion.dev/docs/bundle",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag11]) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag11]
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT2
+    };
+  },
+  name: "Disable Git source",
+  setConfig: () => {
+    throw new Error("Not implemented");
+  },
+  ssrName: "disableGitSource",
+  type: false
+};
+
+// src/options/enable-lambda-insights.tsx
+var jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
+var cliFlag12 = "enable-lambda-insights";
+var option = false;
+var enableLambdaInsights = {
+  name: "Enable Lambda Insights",
+  cliFlag: cliFlag12,
+  description: () => /* @__PURE__ */ jsx_runtime9.jsxs(jsx_runtime9.Fragment, {
+    children: [
+      "Enable",
+      " ",
+      /* @__PURE__ */ jsx_runtime9.jsx("a", {
+        href: "https://remotion.dev/docs/lambda/insights",
+        children: "Lambda Insights in AWS CloudWatch"
+      }),
+      ". For this to work, you may have to update your role permission."
+    ]
+  }),
+  ssrName: "enableLambdaInsights",
+  docLink: "https://www.remotion.dev/docs/lambda/insights",
+  type: false,
+  setConfig: (value) => {
+    option = value;
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag12] !== undefined) {
+      return {
+        value: commandLine[cliFlag12],
+        source: "cli"
+      };
+    }
+    if (option) {
+      return {
+        value: option,
+        source: "config"
+      };
+    }
+    return {
+      value: false,
+      source: "default"
+    };
+  }
+};
+
+// src/options/enable-multiprocess-on-linux.tsx
+var jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
+var DEFAULT_VALUE = true;
+var multiProcessOnLinux = DEFAULT_VALUE;
+var cliFlag13 = "enable-multiprocess-on-linux";
+var enableMultiprocessOnLinuxOption = {
+  name: "Enable Multiprocess on Linux",
+  cliFlag: cliFlag13,
+  description: () => /* @__PURE__ */ jsx_runtime10.jsxs(jsx_runtime10.Fragment, {
+    children: [
+      "Removes the ",
+      /* @__PURE__ */ jsx_runtime10.jsx("code", {
+        children: "--single-process"
+      }),
+      " flag that gets passed to Chromium on Linux by default. This will make the render faster because multiple processes can be used, but may cause issues with some Linux distributions or if window server libraries are missing.",
+      /* @__PURE__ */ jsx_runtime10.jsx("br", {}),
+      "Default: ",
+      /* @__PURE__ */ jsx_runtime10.jsx("code", {
+        children: "false"
+      }),
+      " until v4.0.136, then ",
+      /* @__PURE__ */ jsx_runtime10.jsx("code", {
+        children: "true"
+      }),
+      " from v4.0.137 on because newer Chrome versions ",
+      "don't",
+      " allow rendering with the ",
+      /* @__PURE__ */ jsx_runtime10.jsx("code", {
+        children: "--single-process"
+      }),
+      " flag. ",
+      /* @__PURE__ */ jsx_runtime10.jsx("br", {}),
+      "This flag will be removed in Remotion v5.0."
+    ]
+  }),
+  ssrName: "chromiumOptions.enableMultiprocessOnLinux",
+  docLink: "https://www.remotion.dev/docs/chromium-flags",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag13] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag13]
+      };
+    }
+    if (multiProcessOnLinux !== false) {
+      return {
+        source: "config",
+        value: multiProcessOnLinux
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT_VALUE
+    };
+  },
+  setConfig: (value) => {
+    multiProcessOnLinux = value;
+  }
+};
+
+// src/options/encoding-buffer-size.tsx
+var jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
+var encodingBufferSize = null;
+var setEncodingBufferSize = (bitrate) => {
+  encodingBufferSize = bitrate;
+};
+var cliFlag14 = "buffer-size";
+var encodingBufferSizeOption = {
+  name: "FFmpeg -bufsize flag",
+  cliFlag: cliFlag14,
+  description: () => /* @__PURE__ */ jsx_runtime11.jsxs(jsx_runtime11.Fragment, {
+    children: [
+      "The value for the ",
+      /* @__PURE__ */ jsx_runtime11.jsx("code", {
+        children: "-bufsize"
+      }),
+      " flag of FFmpeg. Should be used in conjunction with the encoding max rate flag."
+    ]
+  }),
+  ssrName: "encodingBufferSize",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#encodingbuffersize",
+  type: "",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag14] !== undefined) {
+      return {
+        value: commandLine[cliFlag14],
+        source: "cli"
+      };
+    }
+    if (encodingBufferSize !== null) {
+      return {
+        value: encodingBufferSize,
+        source: "config"
+      };
+    }
+    return {
+      value: null,
+      source: "default"
+    };
+  },
+  setConfig: setEncodingBufferSize
+};
+
+// src/options/encoding-max-rate.tsx
+var jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
+var encodingMaxRate = null;
+var cliFlag15 = "max-rate";
+var encodingMaxRateOption = {
+  name: "FFmpeg -maxrate flag",
+  cliFlag: cliFlag15,
+  description: () => /* @__PURE__ */ jsx_runtime12.jsxs(jsx_runtime12.Fragment, {
+    children: [
+      "The value for the ",
+      /* @__PURE__ */ jsx_runtime12.jsx("code", {
+        children: "-maxrate"
+      }),
+      " flag of FFmpeg. Should be used in conjunction with the encoding buffer size flag."
+    ]
+  }),
+  ssrName: "encodingMaxRate",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#encodingmaxrate",
+  type: "",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag15] !== undefined) {
+      return {
+        value: commandLine[cliFlag15],
+        source: "cli"
+      };
+    }
+    if (encodingMaxRate !== null) {
+      return {
+        value: encodingMaxRate,
+        source: "config"
+      };
+    }
+    return {
+      value: null,
+      source: "default"
+    };
+  },
+  setConfig: (newMaxRate) => {
+    encodingMaxRate = newMaxRate;
+  }
+};
+
+// src/options/enforce-audio.tsx
+var jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
+var DEFAULT_ENFORCE_AUDIO_TRACK = false;
+var enforceAudioTrackState = DEFAULT_ENFORCE_AUDIO_TRACK;
+var cliFlag16 = "enforce-audio-track";
+var enforceAudioOption = {
+  name: "Enforce Audio Track",
+  cliFlag: cliFlag16,
+  description: () => /* @__PURE__ */ jsx_runtime13.jsx(jsx_runtime13.Fragment, {
+    children: "Render a silent audio track if there would be none otherwise."
+  }),
+  ssrName: "enforceAudioTrack",
+  docLink: "https://www.remotion.dev/docs/config#setenforceaudiotrack-",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag16]) {
+      return {
+        source: "cli",
+        value: true
+      };
+    }
+    if (enforceAudioTrackState !== DEFAULT_ENFORCE_AUDIO_TRACK) {
+      return {
+        source: "config",
+        value: enforceAudioTrackState
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT_ENFORCE_AUDIO_TRACK
+    };
+  },
+  setConfig: (value) => {
+    enforceAudioTrackState = value;
+  }
+};
+
+// src/options/folder-expiry.tsx
+var jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
+var enableFolderExpiry = null;
+var cliFlag17 = "enable-folder-expiry";
+var folderExpiryOption = {
+  name: "Lambda render expiration",
+  cliFlag: cliFlag17,
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime14.jsxs(jsx_runtime14.Fragment, {
+      children: [
+        "When deploying sites, enable or disable S3 Lifecycle policies which allow for renders to auto-delete after a certain time. Default is",
+        " ",
+        /* @__PURE__ */ jsx_runtime14.jsx("code", {
+          children: "null"
+        }),
+        ", which does not change any lifecycle policies of the S3 bucket. See: ",
+        /* @__PURE__ */ jsx_runtime14.jsx("a", {
+          href: "/docs/lambda/autodelete",
+          children: "Lambda autodelete"
+        }),
+        "."
+      ]
+    });
+  },
+  ssrName: "enableFolderExpiry",
+  docLink: "https://www.remotion.dev/docs/lambda/autodelete",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag17] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag17]
+      };
+    }
+    if (enableFolderExpiry !== null) {
+      return {
+        source: "config",
+        value: enableFolderExpiry
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (value) => {
+    enableFolderExpiry = value;
+  }
+};
+
+// src/options/for-seamless-aac-concatenation.tsx
+var jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
+var DEFAULT3 = false;
+var forSeamlessAacConcatenation = DEFAULT3;
+var cliFlag18 = "for-seamless-aac-concatenation";
+var forSeamlessAacConcatenationOption = {
+  name: "For seamless AAC concatenation",
+  cliFlag: cliFlag18,
+  description: () => /* @__PURE__ */ jsx_runtime15.jsxs(jsx_runtime15.Fragment, {
+    children: [
+      "If enabled, the audio is trimmed to the nearest AAC frame, which is required for seamless concatenation of AAC files. This is a requirement if you later want to combine multiple video snippets seamlessly.",
+      /* @__PURE__ */ jsx_runtime15.jsx("br", {}),
+      /* @__PURE__ */ jsx_runtime15.jsx("br", {}),
+      " This option is used internally. There is currently no documentation yet for to concatenate the audio chunks."
+    ]
+  }),
+  docLink: "https://remotion.dev/docs/renderer",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag18]) {
+      return {
+        source: "cli",
+        value: true
+      };
+    }
+    if (forSeamlessAacConcatenation !== DEFAULT3) {
+      return {
+        source: "config",
+        value: forSeamlessAacConcatenation
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT3
+    };
+  },
+  setConfig: (value) => {
+    forSeamlessAacConcatenation = value;
+  },
+  ssrName: "forSeamlessAacConcatenation",
+  type: false
+};
+
+// src/options/gl.tsx
+var jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
+var validOpenGlRenderers = [
+  "swangle",
+  "angle",
+  "egl",
+  "swiftshader",
+  "vulkan",
+  "angle-egl"
+];
+var DEFAULT_OPENGL_RENDERER = null;
+var openGlRenderer = DEFAULT_OPENGL_RENDERER;
+var AngleChangelog = () => {
+  return /* @__PURE__ */ jsx_runtime16.jsxs("details", {
+    style: { fontSize: "0.9em", marginBottom: "1em" },
+    children: [
+      /* @__PURE__ */ jsx_runtime16.jsx("summary", {
+        children: "Changelog"
+      }),
+      /* @__PURE__ */ jsx_runtime16.jsxs("ul", {
+        children: [
+          /* @__PURE__ */ jsx_runtime16.jsxs("li", {
+            children: [
+              "From Remotion v2.6.7 until v3.0.7, the default for Remotion Lambda was",
+              " ",
+              /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: "swiftshader"
+              }),
+              ", but from v3.0.8 the default is",
+              " ",
+              /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: "swangle"
+              }),
+              " (Swiftshader on Angle) since Chrome 101 added support for it."
+            ]
+          }),
+          /* @__PURE__ */ jsx_runtime16.jsxs("li", {
+            children: [
+              "From Remotion v2.4.3 until v2.6.6, the default was ",
+              /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: "angle"
+              }),
+              ", however it turns out to have a small memory leak that could crash long Remotion renders."
+            ]
+          })
+        ]
+      })
+    ]
+  });
+};
+var cliFlag19 = "gl";
+var glOption = {
+  cliFlag: cliFlag19,
+  docLink: "https://www.remotion.dev/docs/chromium-flags#--gl",
+  name: "OpenGL renderer",
+  type: "angle",
+  ssrName: "gl",
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime16.jsxs(jsx_runtime16.Fragment, {
+      children: [
+        /* @__PURE__ */ jsx_runtime16.jsx(AngleChangelog, {}),
+        /* @__PURE__ */ jsx_runtime16.jsxs("p", {
+          children: [
+            "Select the OpenGL renderer backend for Chromium. ",
+            /* @__PURE__ */ jsx_runtime16.jsx("br", {}),
+            "Accepted values:"
+          ]
+        }),
+        /* @__PURE__ */ jsx_runtime16.jsxs("ul", {
+          children: [
+            /* @__PURE__ */ jsx_runtime16.jsx("li", {
+              children: /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: '"angle"'
+              })
+            }),
+            /* @__PURE__ */ jsx_runtime16.jsx("li", {
+              children: /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: '"egl"'
+              })
+            }),
+            /* @__PURE__ */ jsx_runtime16.jsx("li", {
+              children: /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: '"swiftshader"'
+              })
+            }),
+            /* @__PURE__ */ jsx_runtime16.jsx("li", {
+              children: /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                children: '"swangle"'
+              })
+            }),
+            /* @__PURE__ */ jsx_runtime16.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                  children: '"vulkan"'
+                }),
+                " (",
+                /* @__PURE__ */ jsx_runtime16.jsx("em", {
+                  children: "from Remotion v4.0.41"
+                }),
+                ")"
+              ]
+            }),
+            /* @__PURE__ */ jsx_runtime16.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime16.jsx("code", {
+                  children: '"angle-egl"'
+                }),
+                " (",
+                /* @__PURE__ */ jsx_runtime16.jsx("em", {
+                  children: "from Remotion v4.0.51"
+                }),
+                ")"
+              ]
+            })
+          ]
+        }),
+        /* @__PURE__ */ jsx_runtime16.jsxs("p", {
+          children: [
+            "The default is ",
+            /* @__PURE__ */ jsx_runtime16.jsx("code", {
+              children: "null"
+            }),
+            ", letting Chrome decide, except on Lambda where the default is ",
+            /* @__PURE__ */ jsx_runtime16.jsx("code", {
+              children: '"swangle"'
+            })
+          ]
+        })
+      ]
+    });
+  },
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag19]) {
+      validateOpenGlRenderer(commandLine[cliFlag19]);
+      return {
+        value: commandLine[cliFlag19],
+        source: "cli"
+      };
+    }
+    if (openGlRenderer !== DEFAULT_OPENGL_RENDERER) {
+      return {
+        value: openGlRenderer,
+        source: "config"
+      };
+    }
+    return {
+      value: DEFAULT_OPENGL_RENDERER,
+      source: "default"
+    };
+  },
+  setConfig: (value) => {
+    validateOpenGlRenderer(value);
+    openGlRenderer = value;
+  }
+};
+var validateOpenGlRenderer = (option2) => {
+  if (option2 === null) {
+    return null;
+  }
+  if (!validOpenGlRenderers.includes(option2)) {
+    throw new TypeError(`${option2} is not a valid GL backend. Accepted values: ${validOpenGlRenderers.join(", ")}`);
+  }
+  return option2;
+};
+
+// src/options/hardware-acceleration.tsx
+var hardwareAccelerationOptions = [
+  "disable",
+  "if-possible",
+  "required"
+];
+var cliFlag20 = "hardware-acceleration";
+var currentValue = null;
+var hardwareAccelerationOption = {
+  name: "Hardware Acceleration",
+  cliFlag: cliFlag20,
+  description: () => `
+			One of
+			${new Intl.ListFormat("en", { type: "disjunction" }).format(hardwareAccelerationOptions.map((a) => JSON.stringify(a)))}
+			. Default "disable". Encode using a hardware-accelerated encoder if
+			available. If set to "required" and no hardware-accelerated encoder is
+			available, then the render will fail.
+		`,
+  ssrName: "hardwareAcceleration",
+  docLink: "https://www.remotion.dev/docs/encoding",
+  type: "disable",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag20] !== undefined) {
+      const value = commandLine[cliFlag20];
+      if (!hardwareAccelerationOptions.includes(value)) {
+        throw new Error(`Invalid value for --${cliFlag20}: ${value}`);
+      }
+      return {
+        source: "cli",
+        value
+      };
+    }
+    if (currentValue !== null) {
+      return {
+        source: "config",
+        value: currentValue
+      };
+    }
+    return {
+      source: "default",
+      value: "disable"
+    };
+  },
+  setConfig: (value) => {
+    if (!hardwareAccelerationOptions.includes(value)) {
+      throw new Error(`Invalid value for --${cliFlag20}: ${value}`);
+    }
+    currentValue = value;
+  }
+};
+
+// src/options/headless.tsx
+var jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
+var DEFAULT4 = true;
+var headlessMode = DEFAULT4;
+var cliFlag21 = "disable-headless";
+var headlessOption = {
+  name: "Disable Headless Mode",
+  cliFlag: cliFlag21,
+  description: () => /* @__PURE__ */ jsx_runtime17.jsxs(jsx_runtime17.Fragment, {
+    children: [
+      "Deprecated - will be removed in 5.0.0. With the migration to",
+      " ",
+      /* @__PURE__ */ jsx_runtime17.jsx("a", {
+        href: "/docs/miscellaneous/chrome-headless-shell",
+        children: "Chrome Headless Shell"
+      }),
+      ", this option is not functional anymore.",
+      /* @__PURE__ */ jsx_runtime17.jsx("br", {}),
+      /* @__PURE__ */ jsx_runtime17.jsx("br", {}),
+      " If disabled, the render will open an actual Chrome window where you can see the render happen. The default is headless mode."
+    ]
+  }),
+  ssrName: "headless",
+  docLink: "https://www.remotion.dev/docs/chromium-flags#--disable-headless",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag21] !== undefined) {
+      return {
+        source: "cli",
+        value: !commandLine[cliFlag21]
+      };
+    }
+    if (headlessMode !== DEFAULT4) {
+      return {
+        source: "config",
+        value: headlessMode
+      };
+    }
+    return {
+      source: "default",
+      value: headlessMode
+    };
+  },
+  setConfig: (value) => {
+    headlessMode = value;
+  }
+};
+
+// src/options/jpeg-quality.tsx
+var jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
+var defaultValue = DEFAULT_JPEG_QUALITY;
+var quality = defaultValue;
+var setJpegQuality = (q) => {
+  validateJpegQuality(q);
+  if (q === 0 || q === undefined) {
+    quality = defaultValue;
+    return;
+  }
+  quality = q;
+};
+var cliFlag22 = "jpeg-quality";
+var jpegQualityOption = {
+  name: "JPEG Quality",
+  cliFlag: cliFlag22,
+  description: () => /* @__PURE__ */ jsx_runtime18.jsx(jsx_runtime18.Fragment, {
+    children: "Sets the quality of the generated JPEG images. Must be an integer between 0 and 100. Default: 80."
+  }),
+  ssrName: "jpegQuality",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#jpeg-quality",
+  type: 0,
+  setConfig: setJpegQuality,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag22] !== undefined) {
+      validateJpegQuality(commandLine[cliFlag22]);
+      return {
+        source: "cli",
+        value: commandLine[cliFlag22]
+      };
+    }
+    if (quality !== defaultValue) {
+      return {
+        source: "config",
+        value: quality
+      };
+    }
+    return {
+      source: "default",
+      value: defaultValue
+    };
+  }
+};
+
+// src/options/log-level.tsx
+var jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
+var logLevel = "info";
+var cliFlag23 = "log";
+var logLevelOption = {
+  cliFlag: cliFlag23,
+  name: "Log Level",
+  ssrName: "logLevel",
+  description: () => /* @__PURE__ */ jsx_runtime19.jsxs(jsx_runtime19.Fragment, {
+    children: [
+      "One of ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "trace"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "verbose"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "info"
+      }),
+      ",",
+      " ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "warn"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "error"
+      }),
+      ".",
+      /* @__PURE__ */ jsx_runtime19.jsx("br", {}),
+      " Determines how much info is being logged to the console.",
+      /* @__PURE__ */ jsx_runtime19.jsx("br", {}),
+      /* @__PURE__ */ jsx_runtime19.jsx("br", {}),
+      " Default ",
+      /* @__PURE__ */ jsx_runtime19.jsx("code", {
+        children: "info"
+      }),
+      "."
+    ]
+  }),
+  docLink: "https://www.remotion.dev/docs/troubleshooting/debug-failed-render",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag23]) {
+      if (!isValidLogLevel(commandLine[cliFlag23])) {
+        throw new Error(`Invalid \`--log\` value passed. Accepted values: ${logLevels.map((l) => `'${l}'`).join(", ")}.`);
+      }
+      return { value: commandLine[cliFlag23], source: "cli" };
+    }
+    if (logLevel !== "info") {
+      return { value: logLevel, source: "config" };
+    }
+    return { value: "info", source: "default" };
+  },
+  setConfig: (newLogLevel) => {
+    logLevel = newLogLevel;
+  },
+  type: "error"
+};
+
+// src/options/metadata.tsx
+var jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
+var metadata = {};
+var cliFlag24 = "metadata";
+var metadataOption = {
+  name: "Metadata",
+  cliFlag: cliFlag24,
+  description: (mode) => {
+    if (mode === "ssr") {
+      return /* @__PURE__ */ jsx_runtime20.jsxs(jsx_runtime20.Fragment, {
+        children: [
+          "An object containing metadata to be embedded in the video. See",
+          " ",
+          /* @__PURE__ */ jsx_runtime20.jsx("a", {
+            href: "/docs/metadata",
+            children: "here"
+          }),
+          " for which metadata is accepted."
+        ]
+      });
+    }
+    return /* @__PURE__ */ jsx_runtime20.jsxs(jsx_runtime20.Fragment, {
+      children: [
+        "Metadata to be embedded in the video. See",
+        " ",
+        /* @__PURE__ */ jsx_runtime20.jsx("a", {
+          href: "/docs/metadata",
+          children: "here"
+        }),
+        " for which metadata is accepted.",
+        /* @__PURE__ */ jsx_runtime20.jsx("br", {}),
+        "The parameter must be in the format of ",
+        /* @__PURE__ */ jsx_runtime20.jsx("code", {
+          children: "--metadata key=value"
+        }),
+        " ",
+        "and can be passed multiple times."
+      ]
+    });
+  },
+  docLink: "https://www.remotion.dev/docs/metadata",
+  type: {},
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag24] !== undefined) {
+      const val = commandLine[cliFlag24];
+      const array = typeof val === "string" ? [val] : val;
+      const keyValues = array.map((a) => {
+        if (!a.includes("=")) {
+          throw new Error(`"metadata" must be in the format of key=value, but got ${a}`);
+        }
+        const splitted = a.split("=");
+        if (splitted.length !== 2) {
+          throw new Error(`"metadata" must be in the format of key=value, but got ${a}`);
+        }
+        return [splitted[0], splitted[1]];
+      });
+      const value = Object.fromEntries(keyValues);
+      return {
+        source: "config",
+        value
+      };
+    }
+    return {
+      source: "config",
+      value: metadata
+    };
+  },
+  setConfig: (newMetadata) => {
+    metadata = newMetadata;
+  },
+  ssrName: "metadata"
+};
+
+// src/options/mute.tsx
+var jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
+var DEFAULT_MUTED_STATE = false;
+var mutedState = DEFAULT_MUTED_STATE;
+var cliFlag25 = "muted";
+var mutedOption = {
+  name: "Muted",
+  cliFlag: cliFlag25,
+  description: () => /* @__PURE__ */ jsx_runtime21.jsx(jsx_runtime21.Fragment, {
+    children: "The Audio of the video will be omitted."
+  }),
+  ssrName: "muted",
+  docLink: "https://www.remotion.dev/docs/using-audio/#muted-property",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag25] !== null) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag25]
+      };
+    }
+    if (mutedState !== DEFAULT_MUTED_STATE) {
+      return {
+        source: "config",
+        value: mutedState
+      };
+    }
+    return {
+      source: "config",
+      value: mutedState
+    };
+  },
+  setConfig: () => {
+    mutedState = true;
+  }
+};
+
+// src/options/number-of-gif-loops.tsx
+var jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
+var currentLoop = null;
+var validate = (newLoop) => {
+  if (newLoop !== null && typeof newLoop !== "number") {
+    throw new Error("--number-of-gif-loops flag must be a number.");
+  }
+};
+var cliFlag26 = "number-of-gif-loops";
+var numberOfGifLoopsOption = {
+  name: "Number of GIF loops",
+  cliFlag: cliFlag26,
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime22.jsxs(jsx_runtime22.Fragment, {
+      children: [
+        "Allows you to set the number of loops as follows:",
+        /* @__PURE__ */ jsx_runtime22.jsxs("ul", {
+          children: [
+            /* @__PURE__ */ jsx_runtime22.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime22.jsx("code", {
+                  children: "null"
+                }),
+                " (or omitting in the CLI) plays the GIF indefinitely."
+              ]
+            }),
+            /* @__PURE__ */ jsx_runtime22.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime22.jsx("code", {
+                  children: "0"
+                }),
+                " disables looping"
+              ]
+            }),
+            /* @__PURE__ */ jsx_runtime22.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime22.jsx("code", {
+                  children: "1"
+                }),
+                " loops the GIF once (plays twice in total)"
+              ]
+            }),
+            /* @__PURE__ */ jsx_runtime22.jsxs("li", {
+              children: [
+                /* @__PURE__ */ jsx_runtime22.jsx("code", {
+                  children: "2"
+                }),
+                " loops the GIF twice (plays three times in total) and so on."
+              ]
+            })
+          ]
+        })
+      ]
+    });
+  },
+  ssrName: "numberOfGifLoops",
+  docLink: "https://www.remotion.dev/docs/render-as-gif#changing-the-number-of-loops",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag26] !== undefined) {
+      validate(commandLine[cliFlag26]);
+      return {
+        value: commandLine[cliFlag26],
+        source: "cli"
+      };
+    }
+    if (currentLoop !== null) {
+      return {
+        value: currentLoop,
+        source: "config"
+      };
+    }
+    return {
+      value: null,
+      source: "default"
+    };
+  },
+  setConfig: (newLoop) => {
+    validate(newLoop);
+    currentLoop = newLoop;
+  }
+};
+
+// src/options/offthreadvideo-cache-size.tsx
+var jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
+var offthreadVideoCacheSizeInBytes = null;
+var cliFlag27 = "offthreadvideo-cache-size-in-bytes";
+var offthreadVideoCacheSizeInBytesOption = {
+  name: "OffthreadVideo cache size",
+  cliFlag: cliFlag27,
+  description: () => /* @__PURE__ */ jsx_runtime23.jsxs(jsx_runtime23.Fragment, {
+    children: [
+      "From v4.0, Remotion has a cache for",
+      " ",
+      /* @__PURE__ */ jsx_runtime23.jsx("a", {
+        href: "https://remotion.dev/docs/offthreadvideo",
+        children: /* @__PURE__ */ jsx_runtime23.jsx("code", {
+          children: "<OffthreadVideo>"
+        })
+      }),
+      " ",
+      "frames. The default is ",
+      /* @__PURE__ */ jsx_runtime23.jsx("code", {
+        children: "null"
+      }),
+      ", corresponding to half of the system memory available when the render starts.",
+      /* @__PURE__ */ jsx_runtime23.jsx("br", {}),
+      " This option allows to override the size of the cache. The higher it is, the faster the render will be, but the more memory will be used.",
+      /* @__PURE__ */ jsx_runtime23.jsx("br", {}),
+      "The used value will be printed when running in verbose mode.",
+      /* @__PURE__ */ jsx_runtime23.jsx("br", {}),
+      "Default: ",
+      /* @__PURE__ */ jsx_runtime23.jsx("code", {
+        children: "null"
+      })
+    ]
+  }),
+  ssrName: "offthreadVideoCacheSizeInBytes",
+  docLink: "https://www.remotion.dev/docs/offthreadvideo",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag27] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag27]
+      };
+    }
+    if (offthreadVideoCacheSizeInBytes !== null) {
+      return {
+        source: "config",
+        value: offthreadVideoCacheSizeInBytes
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (size) => {
+    offthreadVideoCacheSizeInBytes = size ?? null;
+  }
+};
+
+// src/options/offthreadvideo-threads.tsx
+var jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
+var value = null;
+var cliFlag28 = "offthreadvideo-video-threads";
+var offthreadVideoThreadsOption = {
+  name: "OffthreadVideo threads",
+  cliFlag: cliFlag28,
+  description: () => /* @__PURE__ */ jsx_runtime24.jsxs(jsx_runtime24.Fragment, {
+    children: [
+      "The number of threads that",
+      /* @__PURE__ */ jsx_runtime24.jsx("a", {
+        href: "https://remotion.dev/docs/offthreadvideo",
+        children: /* @__PURE__ */ jsx_runtime24.jsx("code", {
+          children: "<OffthreadVideo>"
+        })
+      }),
+      " ",
+      "can start to extract frames. frames. The default is",
+      " ",
+      DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS,
+      ". Increase carefully, as too much threads may cause instability."
+    ]
+  }),
+  ssrName: "offthreadVideoThreads",
+  docLink: "https://www.remotion.dev/docs/offthreadvideo",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag28] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag28]
+      };
+    }
+    if (value !== null) {
+      return {
+        source: "config",
+        value
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (size) => {
+    value = size ?? null;
+  }
+};
+var DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;
+
+// src/options/on-browser-download.tsx
+var jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
+var cliFlag29 = "on-browser-download";
+var onBrowserDownloadOption = {
+  name: "Browser download callback function",
+  cliFlag: cliFlag29,
+  description: () => /* @__PURE__ */ jsx_runtime25.jsxs(jsx_runtime25.Fragment, {
+    children: [
+      "Gets called when no compatible local browser is detected on the system and this API needs to download a browser. Return a callback to observe progress.",
+      " ",
+      /* @__PURE__ */ jsx_runtime25.jsx("a", {
+        href: "/docs/renderer/ensure-browser#onbrowserdownload",
+        children: "See here for how to use this option."
+      })
+    ]
+  }),
+  ssrName: "onBrowserDownload",
+  docLink: "https://www.remotion.dev/docs/renderer/ensure-browser",
+  type: undefined,
+  getValue: () => {
+    throw new Error("does not support config file");
+  },
+  setConfig: () => {
+    throw new Error("does not support config file");
+  }
+};
+
+// src/options/overwrite.tsx
+var jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
+var shouldOverwrite = null;
+var cliFlag30 = "overwrite";
+var validate2 = (value2) => {
+  if (typeof value2 !== "boolean") {
+    throw new Error(`overwriteExisting must be a boolean but got ${typeof value2} (${value2})`);
+  }
+};
+var overwriteOption = {
+  name: "Overwrite output",
+  cliFlag: cliFlag30,
+  description: () => /* @__PURE__ */ jsx_runtime26.jsxs(jsx_runtime26.Fragment, {
+    children: [
+      "If set to ",
+      /* @__PURE__ */ jsx_runtime26.jsx("code", {
+        children: "false"
+      }),
+      ", will prevent rendering to a path that already exists. Default is ",
+      /* @__PURE__ */ jsx_runtime26.jsx("code", {
+        children: "true"
+      }),
+      "."
+    ]
+  }),
+  ssrName: "overwrite",
+  docLink: "https://www.remotion.dev/docs/config#setoverwriteoutput",
+  type: false,
+  getValue: ({ commandLine }, defaultValue2) => {
+    if (commandLine[cliFlag30] !== undefined) {
+      validate2(commandLine[cliFlag30]);
+      return {
+        source: "cli",
+        value: commandLine[cliFlag30]
+      };
+    }
+    if (shouldOverwrite !== null) {
+      return {
+        source: "config",
+        value: shouldOverwrite
+      };
+    }
+    return {
+      source: "default",
+      value: defaultValue2
+    };
+  },
+  setConfig: (value2) => {
+    validate2(value2);
+    shouldOverwrite = value2;
+  }
+};
+
+// src/options/prefer-lossless.tsx
+var jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
+var cliFlag31 = "prefer-lossless";
+var input = false;
+var preferLosslessAudioOption = {
+  name: "Prefer lossless",
+  cliFlag: cliFlag31,
+  description: () => /* @__PURE__ */ jsx_runtime27.jsxs(jsx_runtime27.Fragment, {
+    children: [
+      "Uses a lossless audio codec, if one is available for the codec. If you set",
+      /* @__PURE__ */ jsx_runtime27.jsx("code", {
+        children: "audioCodec"
+      }),
+      ", it takes priority over",
+      " ",
+      /* @__PURE__ */ jsx_runtime27.jsx("code", {
+        children: "preferLossless"
+      }),
+      "."
+    ]
+  }),
+  docLink: "https://www.remotion.dev/docs/encoding",
+  type: false,
+  ssrName: "preferLossless",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag31]) {
+      return { value: true, source: "cli" };
+    }
+    if (input === true) {
+      return { value: true, source: "config" };
+    }
+    return { value: false, source: "default" };
+  },
+  setConfig: (val) => {
+    input = val;
+  }
+};
+
+// src/options/public-dir.tsx
+var jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
+var cliFlag32 = "public-dir";
+var currentPublicDir = null;
+var publicDirOption = {
+  name: "Public Directory",
+  cliFlag: cliFlag32,
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime28.jsxs(jsx_runtime28.Fragment, {
+      children: [
+        "Define the location of the",
+        " ",
+        /* @__PURE__ */ jsx_runtime28.jsx("a", {
+          href: "/docs/terminology/public-dir",
+          children: /* @__PURE__ */ jsx_runtime28.jsx("code", {
+            children: "public/ directory"
+          })
+        }),
+        ". If not defined, Remotion will assume the location is the `public` folder in your Remotion root."
+      ]
+    });
+  },
+  ssrName: "publicDir",
+  docLink: "https://www.remotion.dev/docs/terminology/public-dir",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag32] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag32]
+      };
+    }
+    if (currentPublicDir !== null) {
+      return {
+        source: "config",
+        value: currentPublicDir
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (value2) => {
+    currentPublicDir = value2;
+  },
+  type: ""
+};
+
+// src/options/public-path.tsx
+var jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
+var cliFlag33 = "public-path";
+var currentPublicPath = null;
+var publicPathOption = {
+  name: "Public Path",
+  cliFlag: cliFlag33,
+  description: () => {
+    return /* @__PURE__ */ jsx_runtime29.jsxs(jsx_runtime29.Fragment, {
+      children: [
+        "The path of the URL where the bundle is going to be hosted. By default it is ",
+        /* @__PURE__ */ jsx_runtime29.jsx("code", {
+          children: "/"
+        }),
+        ", meaning that the bundle is going to be hosted at the root of the domain (e.g. ",
+        /* @__PURE__ */ jsx_runtime29.jsx("code", {
+          children: "https://localhost:3000/"
+        }),
+        "). If you are deploying to a subdirectory (e.g. ",
+        /* @__PURE__ */ jsx_runtime29.jsx("code", {
+          children: "/sites/my-site/"
+        }),
+        "), you should set this to the subdirectory."
+      ]
+    });
+  },
+  ssrName: "publicPath",
+  docLink: "https://www.remotion.dev/docs/renderer",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag33] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag33]
+      };
+    }
+    if (currentPublicPath !== null) {
+      return {
+        source: "config",
+        value: currentPublicPath
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (value2) => {
+    currentPublicPath = value2;
+  },
+  type: ""
+};
+
+// src/options/repro.tsx
+var jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
+var enableRepro = false;
+var setRepro = (should) => {
+  enableRepro = should;
+};
+var cliFlag34 = "repro";
+var reproOption = {
+  name: "Create reproduction",
+  cliFlag: cliFlag34,
+  description: () => /* @__PURE__ */ jsx_runtime30.jsx(jsx_runtime30.Fragment, {
+    children: "Create a ZIP that you can submit to Remotion if asked for a reproduction."
+  }),
+  ssrName: "repro",
+  docLink: "https://www.remotion.dev/docs/render-media#repro",
+  type: false,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag34] !== undefined) {
+      return {
+        value: commandLine[cliFlag34],
+        source: "cli"
+      };
+    }
+    if (enableRepro) {
+      return {
+        value: enableRepro,
+        source: "config"
+      };
+    }
+    return {
+      value: false,
+      source: "default"
+    };
+  },
+  setConfig: setRepro
+};
+
+// src/options/scale.tsx
+var jsx_runtime31 = __toESM(require_jsx_runtime(), 1);
+var currentScale = 1;
+var cliFlag35 = "scale";
+var validateScale = (value2) => {
+  if (typeof value2 !== "number") {
+    throw new Error("scale must be a number.");
+  }
+};
+var scaleOption = {
+  name: "Scale",
+  cliFlag: cliFlag35,
+  description: () => /* @__PURE__ */ jsx_runtime31.jsxs(jsx_runtime31.Fragment, {
+    children: [
+      "Scales the output by a factor. For example, a 1280x720px frame will become a 1920x1080px frame with a scale factor of ",
+      /* @__PURE__ */ jsx_runtime31.jsx("code", {
+        children: "1.5"
+      }),
+      ". Vector elements like fonts and HTML markups will be rendered with extra details."
+    ]
+  }),
+  ssrName: "scale",
+  docLink: "https://www.remotion.dev/docs/scaling",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag35] !== undefined) {
+      validateScale(commandLine[cliFlag35]);
+      return {
+        source: "cli",
+        value: commandLine[cliFlag35]
+      };
+    }
+    if (currentScale !== null) {
+      return {
+        source: "config",
+        value: currentScale
+      };
+    }
+    return {
+      source: "default",
+      value: 1
+    };
+  },
+  setConfig: (scale) => {
+    currentScale = scale;
+  }
+};
+
+// src/options/throw-if-site-exists.tsx
+var DEFAULT5 = false;
+var cliFlag36 = "throw-if-site-exists";
+var throwIfSiteExistsOption = {
+  cliFlag: cliFlag36,
+  description: () => `Prevents accidential update of an existing site. If there are any files in the subfolder where the site should be placed, the function will throw.`,
+  docLink: "https://remotion.dev/docs/lambda/deploy-site",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag36]) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag36]
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT5
+    };
+  },
+  name: "Throw if site exists",
+  setConfig: () => {
+    throw new Error("Not implemented");
+  },
+  ssrName: "throwIfSiteExists",
+  type: false
+};
+
+// src/options/timeout.tsx
+var jsx_runtime32 = __toESM(require_jsx_runtime(), 1);
+var currentTimeout = DEFAULT_TIMEOUT;
+var validate3 = (value2) => {
+  if (typeof value2 !== "number") {
+    throw new Error("--timeout flag / setDelayRenderTimeoutInMilliseconds() must be a number, but got " + JSON.stringify(value2));
+  }
+};
+var cliFlag37 = "timeout";
+var delayRenderTimeoutInMillisecondsOption = {
+  name: "delayRender() timeout",
+  cliFlag: cliFlag37,
+  description: () => /* @__PURE__ */ jsx_runtime32.jsxs(jsx_runtime32.Fragment, {
+    children: [
+      "A number describing how long the render may take to resolve all",
+      " ",
+      /* @__PURE__ */ jsx_runtime32.jsx("a", {
+        href: "https://remotion.dev/docs/delay-render",
+        children: /* @__PURE__ */ jsx_runtime32.jsx("code", {
+          children: "delayRender()"
+        })
+      }),
+      " ",
+      "calls ",
+      /* @__PURE__ */ jsx_runtime32.jsx("a", {
+        href: "https://remotion.dev/docs/timeout",
+        children: "before it times out"
+      }),
+      ". Default: ",
+      /* @__PURE__ */ jsx_runtime32.jsx("code", {
+        children: "30000"
+      })
+    ]
+  }),
+  ssrName: "timeoutInMilliseconds",
+  docLink: "https://www.remotion.dev/docs/timeout",
+  type: 0,
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag37] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag37]
+      };
+    }
+    if (currentTimeout !== null) {
+      validate3(currentTimeout);
+      return {
+        source: "config",
+        value: currentTimeout
+      };
+    }
+    return {
+      source: "default",
+      value: DEFAULT_TIMEOUT
+    };
+  },
+  setConfig: (value2) => {
+    validate3(value2);
+    currentTimeout = value2;
+  }
+};
+
+// src/options/video-bitrate.tsx
+var jsx_runtime33 = __toESM(require_jsx_runtime(), 1);
+var videoBitrate = null;
+var cliFlag38 = "video-bitrate";
+var videoBitrateOption = {
+  name: "Video Bitrate",
+  cliFlag: cliFlag38,
+  description: () => /* @__PURE__ */ jsx_runtime33.jsxs(jsx_runtime33.Fragment, {
+    children: [
+      "Specify the target bitrate for the generated video. The syntax for FFmpeg",
+      "'",
+      "s",
+      /* @__PURE__ */ jsx_runtime33.jsx("code", {
+        children: "-b:v"
+      }),
+      " parameter should be used. FFmpeg may encode the video in a way that will not result in the exact video bitrate specified. Example values: ",
+      /* @__PURE__ */ jsx_runtime33.jsx("code", {
+        children: "512K"
+      }),
+      " for 512 kbps, ",
+      /* @__PURE__ */ jsx_runtime33.jsx("code", {
+        children: "1M"
+      }),
+      " for 1 Mbps."
+    ]
+  }),
+  ssrName: "videoBitrate",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media#videobitrate-",
+  type: "",
+  getValue: ({ commandLine }) => {
+    if (commandLine[cliFlag38] !== undefined) {
+      return {
+        source: "cli",
+        value: commandLine[cliFlag38]
+      };
+    }
+    if (videoBitrate !== null) {
+      return {
+        source: "config",
+        value: videoBitrate
+      };
+    }
+    return {
+      source: "default",
+      value: null
+    };
+  },
+  setConfig: (bitrate) => {
+    videoBitrate = bitrate;
+  }
+};
+
+// src/path-normalize.ts
+var SLASH = 47;
+var DOT = 46;
+var assertPath = (path) => {
+  const t = typeof path;
+  if (t !== "string") {
+    throw new TypeError(`Expected a string, got a ${t}`);
+  }
+};
+var posixNormalize = (path, allowAboveRoot) => {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0;i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += "/" + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+};
+var decode = (s) => {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+};
+var pathNormalize = (p) => {
+  assertPath(p);
+  let path = p;
+  if (path.length === 0) {
+    return ".";
+  }
+  const isAbsolute = path.charCodeAt(0) === SLASH;
+  const trailingSeparator = path.charCodeAt(path.length - 1) === SLASH;
+  path = decode(path);
+  path = posixNormalize(path, !isAbsolute);
+  if (path.length === 0 && !isAbsolute) {
+    path = ".";
+  }
+  if (path.length > 0 && trailingSeparator) {
+    path += "/";
+  }
+  if (isAbsolute) {
+    return "/" + path;
+  }
+  return path;
+};
+
+// src/get-extension-of-filename.ts
+var getExtensionOfFilename = (filename) => {
+  if (filename === null) {
+    return null;
+  }
+  const filenameArr = pathNormalize(filename).split(".");
+  const hasExtension = filenameArr.length >= 2;
+  const filenameArrLength = filenameArr.length;
+  const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;
+  return extension;
+};
+
+// src/options/video-codec.tsx
+var jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
+var codec;
+var setCodec = (newCodec) => {
+  if (newCodec === undefined) {
+    codec = undefined;
+    return;
+  }
+  if (!validCodecs.includes(newCodec)) {
+    throw new Error(`Codec must be one of the following: ${validCodecs.join(", ")}, but got ${newCodec}`);
+  }
+  codec = newCodec;
+};
+var getOutputCodecOrUndefined = () => {
+  return codec;
+};
+var deriveCodecsFromFilename = (extension) => {
+  if (extension === null) {
+    return { possible: [], default: null };
+  }
+  return {
+    default: defaultCodecsForFileExtension[extension] ?? null,
+    possible: makeFileExtensionMap()[extension] ?? []
+  };
+};
+var cliFlag39 = "codec";
+var videoCodecOption = {
+  name: "Codec",
+  cliFlag: cliFlag39,
+  description: () => /* @__PURE__ */ jsx_runtime34.jsx(jsx_runtime34.Fragment, {
+    children: "H264 works well in most cases, but sometimes it's worth going for a different codec. WebM achieves higher compression but is slower to render. WebM, GIF and ProRes support transparency."
+  }),
+  ssrName: "codec",
+  docLink: "https://www.remotion.dev/docs/encoding/#choosing-a-codec",
+  type: "",
+  getValue: ({ commandLine }, {
+    compositionCodec,
+    configFile,
+    downloadName,
+    outName,
+    uiCodec
+  }) => {
+    if (uiCodec) {
+      return { value: uiCodec, source: "via UI" };
+    }
+    const downloadNameExtension = getExtensionOfFilename(downloadName);
+    const outNameExtension = getExtensionOfFilename(outName);
+    const derivedDownloadCodecs = deriveCodecsFromFilename(downloadNameExtension);
+    const derivedOutNameCodecs = deriveCodecsFromFilename(outNameExtension);
+    if (derivedDownloadCodecs.possible.length > 0 && derivedOutNameCodecs.possible.length > 0 && derivedDownloadCodecs.possible.join("") !== derivedOutNameCodecs.possible.join("")) {
+      throw new TypeError(`The download name is ${downloadName} but the output name is ${outName}. The file extensions must match`);
+    }
+    const cliArgument = commandLine[cliFlag39];
+    if (cliArgument) {
+      if (derivedDownloadCodecs.possible.length > 0 && derivedDownloadCodecs.possible.indexOf(cliArgument) === -1) {
+        throw new TypeError(`The download name is ${downloadName} but --codec=${cliArgument} was passed. The download name implies a codec of ${derivedDownloadCodecs.possible.join(" or ")} which does not align with the --codec flag.`);
+      }
+      if (derivedOutNameCodecs.possible.length > 0 && derivedOutNameCodecs.possible.indexOf(cliArgument) === -1) {
+        throw new TypeError(`The out name is ${outName} but --codec=${cliArgument} was passed. The out name implies a codec of ${derivedOutNameCodecs.possible.join(" or ")} which does not align with the --codec flag.`);
+      }
+      return { value: cliArgument, source: "from --codec flag" };
+    }
+    if (derivedDownloadCodecs.possible.length > 0) {
+      return {
+        value: derivedDownloadCodecs.default,
+        source: "derived from download name"
+      };
+    }
+    if (derivedOutNameCodecs.possible.length > 0) {
+      return {
+        value: derivedOutNameCodecs.default,
+        source: "derived from out name"
+      };
+    }
+    if (compositionCodec) {
+      return { value: compositionCodec, source: "via calculateMetadata" };
+    }
+    if (configFile) {
+      return {
+        value: configFile,
+        source: "Config file"
+      };
+    }
+    return { value: DEFAULT_CODEC, source: "default" };
+  },
+  setConfig: setCodec
+};
+
+// src/options/webhook-custom-data.tsx
+var jsx_runtime35 = __toESM(require_jsx_runtime(), 1);
+var cliFlag40 = "webhook-custom-data";
+var webhookCustomDataOption = {
+  name: "Webhook custom data",
+  cliFlag: cliFlag40,
+  description: (type) => /* @__PURE__ */ jsx_runtime35.jsxs(jsx_runtime35.Fragment, {
+    children: [
+      "Pass up to 1,024 bytes of a JSON-serializable object to the webhook. This data will be included in the webhook payload.",
+      " ",
+      type === "cli" ? "Alternatively, pass a file path pointing to a JSON file" : null
+    ]
+  }),
+  ssrName: "customData",
+  docLink: "https://www.remotion.dev/docs/lambda/webhooks",
+  type: {},
+  getValue: () => {
+    throw new Error("Option resolution not implemented");
+  },
+  setConfig: () => {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/options/x264-preset.tsx
+var jsx_runtime36 = __toESM(require_jsx_runtime(), 1);
+var x264PresetOptions = [
+  "ultrafast",
+  "superfast",
+  "veryfast",
+  "faster",
+  "fast",
+  "medium",
+  "slow",
+  "slower",
+  "veryslow",
+  "placebo"
+];
+var preset = null;
+var cliFlag41 = "x264-preset";
+var DEFAULT_PRESET = "medium";
+var x264Option = {
+  name: "x264 Preset",
+  cliFlag: cliFlag41,
+  description: () => /* @__PURE__ */ jsx_runtime36.jsxs(jsx_runtime36.Fragment, {
+    children: [
+      "Sets a x264 preset profile. Only applies to videos rendered with",
+      " ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "h264"
+      }),
+      " codec.",
+      /* @__PURE__ */ jsx_runtime36.jsx("br", {}),
+      "Possible values: ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "superfast"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "veryfast"
+      }),
+      ",",
+      " ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "faster"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "fast"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "medium"
+      }),
+      ",",
+      " ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "slow"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "slower"
+      }),
+      ", ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "veryslow"
+      }),
+      ",",
+      " ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: "placebo"
+      }),
+      ".",
+      /* @__PURE__ */ jsx_runtime36.jsx("br", {}),
+      "Default: ",
+      /* @__PURE__ */ jsx_runtime36.jsx("code", {
+        children: DEFAULT_PRESET
+      })
+    ]
+  }),
+  ssrName: "x264Preset",
+  docLink: "https://www.remotion.dev/docs/renderer/render-media",
+  type: "fast",
+  getValue: ({ commandLine }) => {
+    const value2 = commandLine[cliFlag41];
+    if (typeof value2 !== "undefined") {
+      return { value: value2, source: "cli" };
+    }
+    if (preset !== null) {
+      return { value: preset, source: "config" };
+    }
+    return { value: null, source: "default" };
+  },
+  setConfig: (profile) => {
+    preset = profile;
+  }
+};
+
+// src/options/index.tsx
+var allOptions = {
+  audioCodecOption,
+  scaleOption,
+  crfOption,
+  jpegQualityOption,
+  videoBitrateOption,
+  audioBitrateOption,
+  enforceAudioOption,
+  mutedOption,
+  videoCodecOption,
+  offthreadVideoCacheSizeInBytesOption,
+  offthreadVideoThreadsOption,
+  webhookCustomDataOption,
+  colorSpaceOption,
+  deleteAfterOption,
+  folderExpiryOption,
+  enableMultiprocessOnLinuxOption,
+  glOption,
+  enableLambdaInsights,
+  encodingMaxRateOption,
+  encodingBufferSizeOption,
+  beepOnFinishOption,
+  numberOfGifLoopsOption,
+  reproOption,
+  preferLosslessOption: preferLosslessAudioOption,
+  x264Option,
+  logLevelOption,
+  delayRenderTimeoutInMillisecondsOption,
+  headlessOption,
+  overwriteOption,
+  binariesDirectoryOption,
+  forSeamlessAacConcatenationOption,
+  separateAudioOption,
+  publicPathOption,
+  publicDirOption,
+  onBrowserDownloadOption,
+  throwIfSiteExistsOption,
+  disableGitSourceOption,
+  metadataOption,
+  hardwareAccelerationOption,
+  chromeModeOption,
+  apiKeyOption
+};
+
+// src/options/options-map.ts
+var optionsMap = {
+  renderMedia: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    videoBitrate: videoBitrateOption,
+    numberOfGifLoops: numberOfGifLoopsOption,
+    repro: reproOption,
+    x264Preset: x264Option,
+    audioBitrate: audioBitrateOption,
+    colorSpace: colorSpaceOption,
+    codec: videoCodecOption,
+    jpegQuality: jpegQualityOption,
+    encodingMaxRate: encodingMaxRateOption,
+    encodingBufferSize: encodingBufferSizeOption,
+    muted: mutedOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    binariesDirectory: binariesDirectoryOption,
+    forSeamlessAacConcatenation: forSeamlessAacConcatenationOption,
+    separateAudioTo: separateAudioOption,
+    audioCodec: audioCodecOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    hardwareAcceleration: hardwareAccelerationOption,
+    chromeMode: chromeModeOption
+  },
+  stitchFramesToVideo: {
+    separateAudioTo: separateAudioOption,
+    hardwareAcceleration: hardwareAccelerationOption
+  },
+  renderStill: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    jpegQuality: jpegQualityOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    binariesDirectory: binariesDirectoryOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  getCompositions: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    binariesDirectory: binariesDirectoryOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  selectComposition: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    binariesDirectory: binariesDirectoryOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  renderFrames: {
+    forSeamlessAacConcatenation: forSeamlessAacConcatenationOption,
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    jpegQuality: jpegQualityOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    binariesDirectory: binariesDirectoryOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  renderMediaOnLambda: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    videoBitrate: videoBitrateOption,
+    numberOfGifLoops: numberOfGifLoopsOption,
+    preferLossless: preferLosslessAudioOption,
+    audioBitrate: audioBitrateOption,
+    deleteAfter: deleteAfterOption,
+    x264Preset: x264Option,
+    encodingMaxRate: encodingMaxRateOption,
+    encodingBufferSize: encodingBufferSizeOption,
+    colorSpace: colorSpaceOption,
+    muted: mutedOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    apiKey: apiKeyOption
+  },
+  renderStillOnLambda: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    jpegQuality: jpegQualityOption,
+    logLevel: logLevelOption,
+    deleteAfter: deleteAfterOption,
+    scale: scaleOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    apiKey: apiKeyOption
+  },
+  getCompositionsOnLambda: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    logLevel: logLevelOption,
+    timeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption
+  },
+  renderMediaOnCloudRun: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    numberOfGifLoops: numberOfGifLoopsOption,
+    preferLossless: preferLosslessAudioOption,
+    colorSpace: colorSpaceOption,
+    audioBitrate: audioBitrateOption,
+    videoBitrate: videoBitrateOption,
+    x264Preset: x264Option,
+    encodingMaxRate: encodingMaxRateOption,
+    encodingBufferSize: encodingBufferSizeOption,
+    muted: mutedOption,
+    logLevel: logLevelOption,
+    delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption,
+    enforceAudioTrack: enforceAudioOption,
+    scale: scaleOption,
+    crf: crfOption,
+    jpegQuality: jpegQualityOption
+  },
+  renderStillOnCloudRun: {
+    offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreads: offthreadVideoThreadsOption,
+    logLevel: logLevelOption,
+    scale: scaleOption,
+    jpegQuality: jpegQualityOption,
+    delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMillisecondsOption
+  },
+  ensureBrowser: {
+    logLevel: logLevelOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  openBrowser: {
+    logLevel: logLevelOption,
+    onBrowserDownload: onBrowserDownloadOption,
+    chromeMode: chromeModeOption
+  },
+  deploySiteLambda: {
+    logLevel: logLevelOption,
+    throwIfSiteExists: throwIfSiteExistsOption
+  },
+  deploySiteCloudRun: {
+    logLevel: logLevelOption
+  }
+};
+
+// src/pixel-format.ts
+var validPixelFormats = [
+  "yuv420p",
+  "yuva420p",
+  "yuv422p",
+  "yuv444p",
+  "yuv420p10le",
+  "yuv422p10le",
+  "yuv444p10le",
+  "yuva444p10le"
+];
+var DEFAULT_PIXEL_FORMAT = "yuv420p";
+var validPixelFormatsForCodec = (codec2) => {
+  if (codec2 === "vp8" || codec2 === "vp9") {
+    return validPixelFormats;
+  }
+  return validPixelFormats.filter((format) => format !== "yuva420p");
+};
+
+// src/prores-profile.ts
+var proResProfileOptions = [
+  "4444-xq",
+  "4444",
+  "hq",
+  "standard",
+  "light",
+  "proxy"
+];
+
+// src/validate-output-filename.ts
+var validateOutputFilename = ({
+  codec: codec2,
+  audioCodecSetting,
+  extension,
+  preferLossless,
+  separateAudioTo
+}) => {
+  if (!defaultFileExtensionMap[codec2]) {
+    throw new TypeError(`The codec "${codec2}" is not supported. Supported codecs are: ${Object.keys(defaultFileExtensionMap).join(", ")}`);
+  }
+  const map = defaultFileExtensionMap[codec2];
+  const resolvedAudioCodec = resolveAudioCodec({
+    codec: codec2,
+    preferLossless,
+    setting: audioCodecSetting,
+    separateAudioTo
+  });
+  if (resolvedAudioCodec === null) {
+    if (extension !== map.default) {
+      throw new TypeError(`When using the ${codec2} 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 ${codec2}`);
+  }
+  const acceptableExtensions = map.forAudioCodec[resolvedAudioCodec].possible;
+  if (!acceptableExtensions.includes(extension) && !separateAudioTo) {
+    throw new TypeError(`When using the ${codec2} codec with the ${resolvedAudioCodec} audio codec, the output filename must end in one of the following: ${acceptableExtensions.join(", ")}.`);
+  }
+};
+
+// src/client.ts
+var BrowserSafeApis = {
+  getFileExtensionFromCodec,
+  validCodecs,
+  validAudioCodecs,
+  getDefaultCrfForCodec,
+  getValidCrfRanges,
+  proResProfileOptions,
+  x264PresetOptions,
+  hardwareAccelerationOptions,
+  validPixelFormats,
+  validOpenGlRenderers,
+  validPixelFormatsForCodec,
+  validVideoImageFormats,
+  validStillImageFormats,
+  DEFAULT_PIXEL_FORMAT,
+  DEFAULT_TIMEOUT,
+  DEFAULT_JPEG_QUALITY,
+  DEFAULT_COLOR_SPACE,
+  supportedAudioCodecs,
+  defaultFileExtensionMap,
+  defaultAudioCodecs,
+  defaultCodecsForFileExtension,
+  validateOutputFilename,
+  options: allOptions,
+  validColorSpaces,
+  optionsMap,
+  codecSupportsCrf,
+  codecSupportsVideoBitrate,
+  logLevels,
+  getOutputCodecOrUndefined,
+  getExtensionFromAudioCodec,
+  validChromeModeOptions
+};
+export {
+  BrowserSafeApis
+};