@remotion/studio-shared 4.0.501 → 4.0.503

package/dist/esm/index.mjs

@@ -0,0 +1,3696 @@
+// src/ansi.ts
+var ansiRegex = () => {
+  const pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|");
+  return new RegExp(pattern, "g");
+};
+function splitAnsi(str) {
+  const parts = str.match(ansiRegex());
+  if (!parts)
+    return [str];
+  const result = [];
+  let offset = 0;
+  let ptr = 0;
+  for (let i = 0;i < parts.length; i++) {
+    offset = str.indexOf(parts[i], offset);
+    if (offset === -1)
+      throw new Error("Could not split string");
+    if (ptr !== offset)
+      result.push(str.slice(ptr, offset));
+    if (ptr === offset && result.length) {
+      result[result.length - 1] += parts[i];
+    } else {
+      if (offset === 0)
+        result.push("");
+      result.push(parts[i]);
+    }
+    ptr = offset + parts[i].length;
+  }
+  result.push(str.slice(ptr));
+  return result;
+}
+var stripAnsi = (str) => {
+  if (typeof str !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof str}\``);
+  }
+  return str.replace(ansiRegex(), "");
+};
+// src/composition-drag-data.ts
+var compositionDragDataToSymbolicatedStack = (dragData) => {
+  if (dragData.compositionFile === null) {
+    return null;
+  }
+  return {
+    originalColumnNumber: null,
+    originalFileName: dragData.compositionFile,
+    originalFunctionName: null,
+    originalLineNumber: null,
+    originalScriptCode: null
+  };
+};
+// src/default-buffer-state-delay-in-milliseconds.ts
+var DEFAULT_BUFFER_STATE_DELAY_IN_MILLISECONDS = 300;
+// src/detect-file-type.ts
+var webmPattern = new Uint8Array([26, 69, 223, 163]);
+var matchesPattern = (pattern) => {
+  return (data) => {
+    return pattern.every((value, index) => data[index] === value);
+  };
+};
+var isRiffAvi = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  const aviPattern = new Uint8Array([65, 86, 73, 32]);
+  return matchesPattern(aviPattern)(fileType);
+};
+var isRiffWave = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  if (!matchesPattern(riffPattern)(data.subarray(0, 4))) {
+    return false;
+  }
+  const fileType = data.subarray(8, 12);
+  const wavePattern = new Uint8Array([87, 65, 86, 69]);
+  return matchesPattern(wavePattern)(fileType);
+};
+var isWebm = (data) => {
+  return matchesPattern(webmPattern)(data.subarray(0, 4));
+};
+var isIsoBaseMedia = (data) => {
+  const isoBaseMediaMp4Pattern = new TextEncoder().encode("ftyp");
+  return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+var isTransportStream = (data) => {
+  return data[0] === 71 && data[188] === 71;
+};
+var isMp3 = (data) => {
+  const mpegPattern = new Uint8Array([255, 243]);
+  const mpegPattern2 = new Uint8Array([255, 251]);
+  const id3v4Pattern = new Uint8Array([73, 68, 51, 4]);
+  const id3v3Pattern = new Uint8Array([73, 68, 51, 3]);
+  const id3v2Pattern = new Uint8Array([73, 68, 51, 2]);
+  const subarray = data.subarray(0, 4);
+  return matchesPattern(mpegPattern)(subarray) || matchesPattern(mpegPattern2)(subarray) || matchesPattern(id3v4Pattern)(subarray) || matchesPattern(id3v3Pattern)(subarray) || matchesPattern(id3v2Pattern)(subarray);
+};
+var isAac = (data) => {
+  const aacPattern = new Uint8Array([255, 241]);
+  return matchesPattern(aacPattern)(data.subarray(0, 2));
+};
+var isFlac = (data) => {
+  const flacPattern = new Uint8Array([102, 76, 97, 67]);
+  return matchesPattern(flacPattern)(data.subarray(0, 4));
+};
+var isM3u = (data) => {
+  return new TextDecoder("utf-8").decode(data.slice(0, 7)) === "#EXTM3U";
+};
+var pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+var acTLChunkType = new Uint8Array([97, 99, 84, 76]);
+var idatChunkType = new Uint8Array([73, 68, 65, 84]);
+var iendChunkType = new Uint8Array([73, 69, 78, 68]);
+var getPngDimensions = (pngData) => {
+  if (pngData.length < 24) {
+    return null;
+  }
+  const view = new DataView(pngData.buffer, pngData.byteOffset);
+  for (let i = 0;i < 8; i++) {
+    if (pngData[i] !== pngSignature[i]) {
+      return null;
+    }
+  }
+  return {
+    width: view.getUint32(16, false),
+    height: view.getUint32(20, false)
+  };
+};
+var hasApngAnimationControlChunk = (pngData) => {
+  if (pngData.length < 16) {
+    return false;
+  }
+  const view = new DataView(pngData.buffer, pngData.byteOffset, pngData.byteLength);
+  let offset = 8;
+  while (offset + 8 <= pngData.length) {
+    const chunkLength = view.getUint32(offset, false);
+    const chunkType = pngData.subarray(offset + 4, offset + 8);
+    if (matchesPattern(acTLChunkType)(chunkType)) {
+      return true;
+    }
+    if (matchesPattern(idatChunkType)(chunkType) || matchesPattern(iendChunkType)(chunkType)) {
+      return false;
+    }
+    const nextOffset = offset + 12 + chunkLength;
+    if (nextOffset <= offset) {
+      return false;
+    }
+    offset = nextOffset;
+  }
+  return false;
+};
+var isPng = (data) => {
+  const pngPattern = new Uint8Array([137, 80, 78, 71]);
+  if (matchesPattern(pngPattern)(data.subarray(0, 4))) {
+    const png = getPngDimensions(data);
+    return {
+      dimensions: png,
+      type: hasApngAnimationControlChunk(data) ? "apng" : "png"
+    };
+  }
+  return null;
+};
+var getJpegDimensions = (data) => {
+  let offset = 0;
+  const readUint16BE = (o) => {
+    return data[o] << 8 | data[o + 1];
+  };
+  if (data.length < 4 || readUint16BE(offset) !== 65496) {
+    return null;
+  }
+  offset += 2;
+  while (offset + 3 < data.length) {
+    if (data[offset] === 255) {
+      const marker = data[offset + 1];
+      if (marker === 192 || marker === 194) {
+        if (offset + 8 >= data.length) {
+          return null;
+        }
+        const height = readUint16BE(offset + 5);
+        const width = readUint16BE(offset + 7);
+        return { width, height };
+      }
+      const length = readUint16BE(offset + 2);
+      if (length <= 0) {
+        return null;
+      }
+      offset += length + 2;
+    } else {
+      offset++;
+    }
+  }
+  return null;
+};
+var isJpeg = (data) => {
+  const jpegPattern = new Uint8Array([255, 216]);
+  const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+  if (!jpeg) {
+    return null;
+  }
+  const dim = getJpegDimensions(data);
+  return { dimensions: dim, type: "jpeg" };
+};
+var getGifDimensions = (data) => {
+  if (data.length < 10) {
+    return null;
+  }
+  const view = new DataView(data.buffer, data.byteOffset);
+  const width = view.getUint16(6, true);
+  const height = view.getUint16(8, true);
+  return { width, height };
+};
+var isGif = (data) => {
+  const gifPattern = new Uint8Array([71, 73, 70, 56]);
+  if (matchesPattern(gifPattern)(data.subarray(0, 4))) {
+    return { type: "gif", dimensions: getGifDimensions(data) };
+  }
+  return null;
+};
+var getWebPDimensions = (bytes) => {
+  if (bytes.length < 30) {
+    return null;
+  }
+  if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70 || bytes[8] !== 87 || bytes[9] !== 69 || bytes[10] !== 66 || bytes[11] !== 80) {
+    return null;
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56) {
+    if (bytes[15] === 32) {
+      return {
+        width: bytes[26] | bytes[27] << 8 & 16383,
+        height: bytes[28] | bytes[29] << 8 & 16383
+      };
+    }
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 76) {
+    return {
+      width: 1 + (bytes[21] | (bytes[22] & 63) << 8),
+      height: 1 + ((bytes[22] & 192) >> 6 | bytes[23] << 2 | (bytes[24] & 15) << 10)
+    };
+  }
+  if (bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 88) {
+    return {
+      width: 1 + (bytes[24] | bytes[25] << 8 | bytes[26] << 16),
+      height: 1 + (bytes[27] | bytes[28] << 8 | bytes[29] << 16)
+    };
+  }
+  return null;
+};
+var isAnimatedWebp = (data) => {
+  const animationChunk = new Uint8Array([65, 78, 73, 77]);
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 12;
+  while (offset + 8 <= data.length) {
+    const chunkType = data.subarray(offset, offset + 4);
+    if (matchesPattern(animationChunk)(chunkType)) {
+      return true;
+    }
+    const chunkLength = view.getUint32(offset + 4, true);
+    const nextOffset = offset + 8 + chunkLength + chunkLength % 2;
+    if (nextOffset <= offset) {
+      return false;
+    }
+    offset = nextOffset;
+  }
+  return false;
+};
+var isWebp = (data) => {
+  const riffPattern = new Uint8Array([82, 73, 70, 70]);
+  const webpPattern = new Uint8Array([87, 69, 66, 80]);
+  if (matchesPattern(riffPattern)(data.subarray(0, 4)) && matchesPattern(webpPattern)(data.subarray(8, 12))) {
+    return {
+      type: "webp",
+      dimensions: getWebPDimensions(data),
+      animated: isAnimatedWebp(data)
+    };
+  }
+  return null;
+};
+var getBmpDimensions = (bmpData) => {
+  if (bmpData.length < 26) {
+    return null;
+  }
+  const view = new DataView(bmpData.buffer, bmpData.byteOffset);
+  return {
+    width: view.getUint32(18, true),
+    height: Math.abs(view.getInt32(22, true))
+  };
+};
+var isBmp = (data) => {
+  const bmpPattern = new Uint8Array([66, 77]);
+  if (matchesPattern(bmpPattern)(data.subarray(0, 2))) {
+    const bmp = getBmpDimensions(data);
+    return { dimensions: bmp, type: "bmp" };
+  }
+  return null;
+};
+var isPdf = (data) => {
+  if (data.length < 4) {
+    return null;
+  }
+  const pdfPattern = new Uint8Array([37, 80, 68, 70]);
+  return matchesPattern(pdfPattern)(data.subarray(0, 4)) ? { type: "pdf" } : null;
+};
+var isImageFileType = (fileType) => {
+  return fileType.type === "jpeg" || fileType.type === "webp" || fileType.type === "gif" || fileType.type === "png" || fileType.type === "apng" || fileType.type === "bmp";
+};
+var detectFileType = (data) => {
+  if (isRiffWave(data)) {
+    return { type: "wav" };
+  }
+  if (isRiffAvi(data)) {
+    return { type: "riff" };
+  }
+  if (isAac(data)) {
+    return { type: "aac" };
+  }
+  if (isFlac(data)) {
+    return { type: "flac" };
+  }
+  if (isM3u(data)) {
+    return { type: "m3u" };
+  }
+  const webp = isWebp(data);
+  if (webp) {
+    return webp;
+  }
+  if (isWebm(data)) {
+    return { type: "webm" };
+  }
+  if (isIsoBaseMedia(data)) {
+    return { type: "iso-base-media" };
+  }
+  if (isTransportStream(data)) {
+    return { type: "transport-stream" };
+  }
+  if (isMp3(data)) {
+    return { type: "mp3" };
+  }
+  const gif = isGif(data);
+  if (gif) {
+    return gif;
+  }
+  const png = isPng(data);
+  if (png) {
+    return png;
+  }
+  const pdf = isPdf(data);
+  if (pdf) {
+    return pdf;
+  }
+  const bmp = isBmp(data);
+  if (bmp) {
+    return bmp;
+  }
+  const jpeg = isJpeg(data);
+  if (jpeg) {
+    return jpeg;
+  }
+  return { type: "unknown" };
+};
+// src/easing-clipboard-data.ts
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isFiniteNumber = (value) => {
+  return typeof value === "number" && Number.isFinite(value);
+};
+var isKeyframeEasing = (value) => {
+  return isRecord(value) && (value.type === "linear" || value.type === "bezier" && isFiniteNumber(value.x1) && isFiniteNumber(value.y1) && isFiniteNumber(value.x2) && isFiniteNumber(value.y2) || value.type === "spring" && isFiniteNumber(value.damping) && isFiniteNumber(value.mass) && isFiniteNumber(value.stiffness) && (value.allowTail === undefined || value.allowTail === null || typeof value.allowTail === "boolean") && (value.durationRestThreshold === undefined || value.durationRestThreshold === null || isFiniteNumber(value.durationRestThreshold)) && typeof value.overshootClamping === "boolean");
+};
+var normalizeKeyframeEasing = (easing) => {
+  if (easing.type !== "spring") {
+    return easing;
+  }
+  return {
+    ...easing,
+    allowTail: easing.allowTail ?? null,
+    durationRestThreshold: easing.durationRestThreshold ?? null
+  };
+};
+var parseEasingClipboardDataResult = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed)) {
+      return { status: "invalid" };
+    }
+    if (parsed.remotionClipboard !== "easing") {
+      return { status: "invalid" };
+    }
+    if (parsed.version !== 1) {
+      return {
+        status: "unsupported-version",
+        version: parsed.version
+      };
+    }
+    if (parsed.type !== "easing" || !isKeyframeEasing(parsed.easing)) {
+      return { status: "invalid" };
+    }
+    return {
+      status: "valid",
+      data: {
+        type: "easing",
+        version: 1,
+        remotionClipboard: "easing",
+        easing: normalizeKeyframeEasing(parsed.easing)
+      }
+    };
+  } catch {
+    return { status: "invalid" };
+  }
+};
+var parseEasingClipboardData = (value) => {
+  const result = parseEasingClipboardDataResult(value);
+  if (result.status !== "valid") {
+    return null;
+  }
+  return result.data;
+};
+// src/effect-catalog.ts
+var getEffectDocumentationPath = (item) => {
+  return `/docs/effects/${item.id.slice("effects-".length)}`;
+};
+var getEffectDocumentationLink = (item) => {
+  return `https://www.remotion.dev${getEffectDocumentationPath(item)}`;
+};
+var getEffectPreviewSource = (item) => {
+  return `/img/${item.id}-preview.png`;
+};
+var getEffectPreviewAlt = (item) => {
+  const effectName = item.id.slice("effects-".length).replaceAll("-", " ").replace(/^uv /, "UV ").replace(/^xy /, "XY ").replace(/^tv /, "TV ");
+  return `${effectName} effect preview`;
+};
+var getEffectCatalogCategories = (items) => {
+  const categories = [];
+  for (const item of items) {
+    const last = categories[categories.length - 1];
+    if (last?.title === item.category) {
+      categories[categories.length - 1] = {
+        ...last,
+        effects: [...last.effects, item]
+      };
+      continue;
+    }
+    categories.push({
+      title: item.category,
+      effects: [item]
+    });
+  }
+  return categories;
+};
+var EFFECT_CATALOG = [
+  {
+    id: "effects-brightness",
+    category: "Color",
+    label: "brightness()",
+    description: "Brightness adjustment effect",
+    effect: {
+      name: "brightness",
+      importPath: "@remotion/effects/brightness",
+      config: {}
+    }
+  },
+  {
+    id: "effects-contrast",
+    category: "Color",
+    label: "contrast()",
+    description: "Contrast adjustment effect",
+    effect: {
+      name: "contrast",
+      importPath: "@remotion/effects/contrast",
+      config: {}
+    }
+  },
+  {
+    id: "effects-color-key",
+    category: "Color",
+    label: "colorKey()",
+    description: "Remove a key color (greenscreen)",
+    effect: {
+      name: "colorKey",
+      importPath: "@remotion/effects/color-key",
+      config: {
+        similarity: 0.45
+      }
+    }
+  },
+  {
+    id: "effects-duotone",
+    category: "Color",
+    label: "duotone()",
+    description: "Two-color threshold effect",
+    effect: {
+      name: "duotone",
+      importPath: "@remotion/effects/duotone",
+      config: {}
+    }
+  },
+  {
+    id: "effects-grayscale",
+    category: "Color",
+    label: "grayscale()",
+    description: "Black-and-white effect",
+    effect: {
+      name: "grayscale",
+      importPath: "@remotion/effects/grayscale",
+      config: {}
+    }
+  },
+  {
+    id: "effects-hue",
+    category: "Color",
+    label: "hue()",
+    description: "Hue rotation effect",
+    effect: {
+      name: "hue",
+      importPath: "@remotion/effects/hue",
+      config: {}
+    }
+  },
+  {
+    id: "effects-invert",
+    category: "Color",
+    label: "invert()",
+    description: "Negative color effect",
+    effect: {
+      name: "invert",
+      importPath: "@remotion/effects/invert",
+      config: {}
+    }
+  },
+  {
+    id: "effects-saturation",
+    category: "Color",
+    label: "saturation()",
+    description: "Saturation adjustment effect",
+    effect: {
+      name: "saturation",
+      importPath: "@remotion/effects/saturation",
+      config: {}
+    }
+  },
+  {
+    id: "effects-tint",
+    category: "Color",
+    label: "tint()",
+    description: "Color tint effect",
+    effect: {
+      name: "tint",
+      importPath: "@remotion/effects/tint",
+      config: {
+        color: "#1ec8ff"
+      }
+    }
+  },
+  {
+    id: "effects-linear-gradient",
+    category: "Color",
+    label: "linearGradient()",
+    description: "Two-stop gradient effect",
+    effect: {
+      name: "linearGradient",
+      importPath: "@remotion/effects/linear-gradient",
+      config: {}
+    }
+  },
+  {
+    id: "effects-linear-gradient-tint",
+    category: "Color",
+    label: "linearGradientTint()",
+    description: "Gradient tint effect",
+    effect: {
+      name: "linearGradientTint",
+      importPath: "@remotion/effects/linear-gradient-tint",
+      config: {}
+    }
+  },
+  {
+    id: "effects-thermal-vision",
+    category: "Color",
+    label: "thermalVision()",
+    description: "Thermal heat-map color effect",
+    effect: {
+      name: "thermalVision",
+      importPath: "@remotion/effects/thermal-vision",
+      config: {}
+    }
+  },
+  {
+    id: "effects-blur",
+    category: "Blur & Shadow",
+    label: "blur()",
+    description: "Gaussian blur effect",
+    effect: {
+      name: "blur",
+      importPath: "@remotion/effects/blur",
+      config: {
+        radius: 40
+      }
+    }
+  },
+  {
+    id: "effects-linear-progressive-blur",
+    category: "Blur & Shadow",
+    label: "linearProgressiveBlur()",
+    description: "Gradient-controlled blur effect",
+    effect: {
+      name: "linearProgressiveBlur",
+      importPath: "@remotion/effects/linear-progressive-blur",
+      config: {}
+    }
+  },
+  {
+    id: "effects-radial-progressive-blur",
+    category: "Blur & Shadow",
+    label: "radialProgressiveBlur()",
+    description: "Ellipse-controlled blur effect",
+    effect: {
+      name: "radialProgressiveBlur",
+      importPath: "@remotion/effects/radial-progressive-blur",
+      config: {}
+    }
+  },
+  {
+    id: "effects-zoom-blur",
+    category: "Blur & Shadow",
+    label: "zoomBlur()",
+    description: "Radial zoom blur effect",
+    effect: {
+      name: "zoomBlur",
+      importPath: "@remotion/effects/zoom-blur",
+      config: {}
+    }
+  },
+  {
+    id: "effects-drop-shadow",
+    category: "Blur & Shadow",
+    label: "dropShadow()",
+    description: "Blurred alpha shadow effect",
+    effect: {
+      name: "dropShadow",
+      importPath: "@remotion/effects/drop-shadow",
+      config: {}
+    }
+  },
+  {
+    id: "effects-glow",
+    category: "Blur & Shadow",
+    label: "glow()",
+    description: "Soft halo effect",
+    effect: {
+      name: "glow",
+      importPath: "@remotion/effects/glow",
+      config: {}
+    }
+  },
+  {
+    id: "effects-light-trail",
+    category: "Blur & Shadow",
+    label: "lightTrail()",
+    description: "Directional light trail effect",
+    effect: {
+      name: "lightTrail",
+      importPath: "@remotion/effects/light-trail",
+      config: {}
+    }
+  },
+  {
+    id: "effects-evolve",
+    category: "Reveal",
+    label: "evolve()",
+    description: "Directional reveal effect",
+    effect: {
+      name: "evolve",
+      importPath: "@remotion/effects/evolve",
+      config: {}
+    }
+  },
+  {
+    id: "effects-venetian-blinds",
+    category: "Reveal",
+    label: "venetianBlinds()",
+    description: "Slatted reveal effect",
+    effect: {
+      name: "venetianBlinds",
+      importPath: "@remotion/effects/venetian-blinds",
+      config: {}
+    }
+  },
+  {
+    id: "effects-mirror",
+    category: "Transform",
+    label: "mirror()",
+    description: "Mirror reflection effect",
+    effect: {
+      name: "mirror",
+      importPath: "@remotion/effects/mirror",
+      config: {}
+    }
+  },
+  {
+    id: "effects-scale",
+    category: "Transform",
+    label: "scale()",
+    description: "Scale transform effect",
+    effect: {
+      name: "scale",
+      importPath: "@remotion/effects/scale",
+      config: {
+        scale: 1
+      }
+    }
+  },
+  {
+    id: "effects-uv-translate",
+    category: "Transform",
+    label: "uvTranslate()",
+    description: "UV-based translate effect",
+    effect: {
+      name: "uvTranslate",
+      importPath: "@remotion/effects/translate",
+      config: {}
+    }
+  },
+  {
+    id: "effects-xy-translate",
+    category: "Transform",
+    label: "xyTranslate()",
+    description: "Pixel-based translate effect",
+    effect: {
+      name: "xyTranslate",
+      importPath: "@remotion/effects/translate",
+      config: {}
+    }
+  },
+  {
+    id: "effects-barrel-distortion",
+    category: "Distort",
+    label: "barrelDistortion()",
+    description: "Barrel distortion effect",
+    effect: {
+      name: "barrelDistortion",
+      importPath: "@remotion/effects/barrel-distortion",
+      config: {}
+    }
+  },
+  {
+    id: "effects-chromatic-aberration",
+    category: "Distort",
+    label: "chromaticAberration()",
+    description: "RGB channel split effect",
+    effect: {
+      name: "chromaticAberration",
+      importPath: "@remotion/effects/chromatic-aberration",
+      config: {}
+    }
+  },
+  {
+    id: "effects-fisheye",
+    category: "Distort",
+    label: "fisheye()",
+    description: "Ultra-wide-angle lens effect",
+    effect: {
+      name: "fisheye",
+      importPath: "@remotion/effects/fisheye",
+      config: {}
+    }
+  },
+  {
+    id: "effects-corner-pin",
+    category: "Distort",
+    label: "cornerPin()",
+    description: "Pin source corners to a quad",
+    effect: {
+      name: "cornerPin",
+      importPath: "@remotion/effects/corner-pin",
+      config: {
+        topLeft: [0.08, 0.12],
+        topRight: [0.92, 0.04],
+        bottomRight: [0.86, 0.9],
+        bottomLeft: [0.14, 0.96]
+      }
+    }
+  },
+  {
+    id: "effects-wave",
+    category: "Distort",
+    label: "wave()",
+    description: "Sine wave distortion",
+    effect: {
+      name: "wave",
+      importPath: "@remotion/effects/wave",
+      config: {}
+    }
+  },
+  {
+    id: "effects-skew",
+    category: "Distort",
+    label: "skew()",
+    description: "Skew the source on two axes",
+    effect: {
+      name: "skew",
+      importPath: "@remotion/effects/skew",
+      config: {}
+    }
+  },
+  {
+    id: "effects-burlap",
+    category: "Stylize",
+    label: "burlap()",
+    description: "Procedural woven texture effect",
+    effect: {
+      name: "burlap",
+      importPath: "@remotion/effects/burlap",
+      config: {}
+    }
+  },
+  {
+    id: "effects-emboss",
+    category: "Stylize",
+    label: "emboss()",
+    description: "Procedural raised-line relief",
+    effect: {
+      name: "emboss",
+      importPath: "@remotion/effects/emboss",
+      config: {}
+    }
+  },
+  {
+    id: "effects-dot-grid",
+    category: "Stylize",
+    label: "dotGrid()",
+    description: "Source-color dot mask effect",
+    effect: {
+      name: "dotGrid",
+      importPath: "@remotion/effects/dot-grid",
+      config: {}
+    }
+  },
+  {
+    id: "effects-halftone",
+    category: "Stylize",
+    label: "halftone()",
+    description: "Source-image halftone effect",
+    effect: {
+      name: "halftone",
+      importPath: "@remotion/effects/halftone",
+      config: {}
+    }
+  },
+  {
+    id: "effects-noise",
+    category: "Stylize",
+    label: "noise()",
+    description: "Procedural grain effect",
+    effect: {
+      name: "noise",
+      importPath: "@remotion/effects/noise",
+      config: {}
+    }
+  },
+  {
+    id: "effects-noise-displacement",
+    category: "Stylize",
+    label: "noiseDisplacement()",
+    description: "Localized noisy displacement",
+    effect: {
+      name: "noiseDisplacement",
+      importPath: "@remotion/effects/noise-displacement",
+      config: {
+        center: [0.6124309308853857, 0.5010527449123625],
+        radius: 0.41,
+        strength: 15.5,
+        seed: 78,
+        grainSize: 0.9,
+        passes: 12,
+        blur: 0,
+        feather: 1,
+        biasDirection: 313,
+        biasAmount: 1
+      }
+    }
+  },
+  {
+    id: "effects-paper",
+    category: "Stylize",
+    label: "paper()",
+    description: "Procedural paper texture effect",
+    effect: {
+      name: "paper",
+      importPath: "@remotion/effects/paper",
+      config: {}
+    }
+  },
+  {
+    id: "effects-roughen-edges",
+    category: "Stylize",
+    label: "roughenEdges()",
+    description: "Procedural alpha-edge roughening",
+    effect: {
+      name: "roughenEdges",
+      importPath: "@remotion/effects/roughen-edges",
+      config: {}
+    }
+  },
+  {
+    id: "effects-pattern",
+    category: "Stylize",
+    label: "pattern()",
+    description: "Repeated source tile effect",
+    effect: {
+      name: "pattern",
+      importPath: "@remotion/effects/pattern",
+      config: {}
+    }
+  },
+  {
+    id: "effects-pixel-dissolve",
+    category: "Stylize",
+    label: "pixelDissolve()",
+    description: "Pixelated dissolve effect",
+    effect: {
+      name: "pixelDissolve",
+      importPath: "@remotion/effects/pixel-dissolve",
+      config: {}
+    }
+  },
+  {
+    id: "effects-pixelate",
+    category: "Stylize",
+    label: "pixelate()",
+    description: "Pixelation effect",
+    effect: {
+      name: "pixelate",
+      importPath: "@remotion/effects/pixelate",
+      config: {
+        blockSize: 20
+      }
+    }
+  },
+  {
+    id: "effects-linear-progressive-pixelate",
+    category: "Stylize",
+    label: "linearProgressivePixelate()",
+    description: "Gradient-controlled pixelation",
+    effect: {
+      name: "linearProgressivePixelate",
+      importPath: "@remotion/effects/linear-progressive-pixelate",
+      config: {}
+    }
+  },
+  {
+    id: "effects-radial-progressive-pixelate",
+    category: "Stylize",
+    label: "radialProgressivePixelate()",
+    description: "Ellipse-controlled pixelation",
+    effect: {
+      name: "radialProgressivePixelate",
+      importPath: "@remotion/effects/radial-progressive-pixelate",
+      config: {}
+    }
+  },
+  {
+    id: "effects-scanlines",
+    category: "Stylize",
+    label: "scanlines()",
+    description: "Additive horizontal scanlines",
+    effect: {
+      name: "scanlines",
+      importPath: "@remotion/effects/scanlines",
+      config: {}
+    }
+  },
+  {
+    id: "effects-speckle",
+    category: "Stylize",
+    label: "speckle()",
+    description: "Random alpha-hole effect",
+    effect: {
+      name: "speckle",
+      importPath: "@remotion/effects/speckle",
+      config: {}
+    }
+  },
+  {
+    id: "effects-shine",
+    category: "Stylize",
+    label: "shine()",
+    description: "Glossy light sweep effect",
+    effect: {
+      name: "shine",
+      importPath: "@remotion/effects/shine",
+      config: {}
+    }
+  },
+  {
+    id: "effects-shrinkwrap",
+    category: "Stylize",
+    label: "shrinkwrap()",
+    description: "Procedural plastic wrap effect",
+    effect: {
+      name: "shrinkwrap",
+      importPath: "@remotion/effects/shrinkwrap",
+      config: {
+        amount: 0.94,
+        displacement: 13.5,
+        highlightIntensity: 1.54,
+        wrinkleDensity: 0.87,
+        edgeTension: 0.58,
+        phase: 0,
+        seed: 12
+      }
+    }
+  },
+  {
+    id: "effects-vignette",
+    category: "Stylize",
+    label: "vignette()",
+    description: "Edge darkening or transparency effect",
+    effect: {
+      name: "vignette",
+      importPath: "@remotion/effects/vignette",
+      config: {}
+    }
+  },
+  {
+    id: "effects-contour-lines",
+    category: "Generate",
+    label: "contourLines()",
+    description: "Topographic line overlay effect",
+    effect: {
+      name: "contourLines",
+      importPath: "@remotion/effects/contour-lines",
+      config: {}
+    }
+  },
+  {
+    id: "effects-liquid-contours",
+    category: "Generate",
+    label: "liquidContours()",
+    description: "Two-color liquid contour background",
+    effect: {
+      name: "liquidContours",
+      importPath: "@remotion/effects/liquid-contours",
+      config: {}
+    }
+  },
+  {
+    id: "effects-checkerboard",
+    category: "Generate",
+    label: "checkerboard()",
+    description: "Checkerboard pattern effect",
+    effect: {
+      name: "checkerboard",
+      importPath: "@remotion/effects/checkerboard",
+      config: {}
+    }
+  },
+  {
+    id: "effects-flannel",
+    category: "Generate",
+    label: "flannel()",
+    description: "Plaid woven fabric pattern",
+    effect: {
+      name: "flannel",
+      importPath: "@remotion/effects/flannel",
+      config: {}
+    }
+  },
+  {
+    id: "effects-halftone-linear-gradient",
+    category: "Generate",
+    label: "halftoneLinearGradient()",
+    description: "Procedural dot gradient effect",
+    effect: {
+      name: "halftoneLinearGradient",
+      importPath: "@remotion/effects/halftone-linear-gradient",
+      config: {}
+    }
+  },
+  {
+    id: "effects-gridlines",
+    category: "Generate",
+    label: "gridlines()",
+    description: "Procedural grid pattern effect",
+    effect: {
+      name: "gridlines",
+      importPath: "@remotion/effects/gridlines",
+      config: {}
+    }
+  },
+  {
+    id: "effects-white-noise",
+    category: "Generate",
+    label: "whiteNoise()",
+    description: "Random grayscale noise layer",
+    effect: {
+      name: "whiteNoise",
+      importPath: "@remotion/effects/white-noise",
+      config: {}
+    }
+  },
+  {
+    id: "effects-tv-signal-off",
+    category: "Generate",
+    label: "tvSignalOff()",
+    description: "TV color bars test pattern",
+    effect: {
+      name: "tvSignalOff",
+      importPath: "@remotion/effects/tv-signal-off",
+      config: {}
+    }
+  },
+  {
+    id: "effects-lines",
+    category: "Generate",
+    label: "lines()",
+    description: "Alternating line pattern effect",
+    effect: {
+      name: "lines",
+      importPath: "@remotion/effects/lines",
+      config: {}
+    }
+  },
+  {
+    id: "effects-rings",
+    category: "Generate",
+    label: "rings()",
+    description: "Concentric ring pattern effect",
+    effect: {
+      name: "rings",
+      importPath: "@remotion/effects/rings",
+      config: {}
+    }
+  },
+  {
+    id: "effects-waves",
+    category: "Generate",
+    label: "waves()",
+    description: "Wavy band pattern effect",
+    effect: {
+      name: "waves",
+      importPath: "@remotion/effects/waves",
+      config: {}
+    }
+  },
+  {
+    id: "effects-zigzag",
+    category: "Generate",
+    label: "zigzag()",
+    description: "Zig-zag band pattern effect",
+    effect: {
+      name: "zigzag",
+      importPath: "@remotion/effects/zigzag",
+      config: {}
+    }
+  },
+  {
+    id: "effects-light-leak",
+    category: "Generate",
+    label: "lightLeak()",
+    description: "Light leak overlay effect",
+    effect: {
+      name: "lightLeak",
+      importPath: "@remotion/effects/light-leak",
+      config: {}
+    }
+  },
+  {
+    id: "effects-starburst",
+    category: "Generate",
+    label: "starburst()",
+    description: "Starburst ray effect",
+    effect: {
+      name: "starburst",
+      importPath: "@remotion/effects/starburst",
+      config: {
+        rays: 16,
+        colors: ["#ff6600", "#ffff00"]
+      }
+    }
+  }
+];
+// src/keyframe-interpolation-function.ts
+var keyframeInterpolationFunctions = [
+  "interpolate",
+  "interpolateColors"
+];
+var KEYFRAME_FIELD_TYPE_SUPPORT = {
+  array: false,
+  asset: false,
+  boolean: false,
+  "remotion-captions": false,
+  color: true,
+  enum: false,
+  "font-family": false,
+  hidden: true,
+  number: true,
+  "rotation-css": true,
+  "rotation-degrees": true,
+  scale: true,
+  "text-content": false,
+  "transform-origin": true,
+  translate: true,
+  "uv-coordinate": true
+};
+var KEYFRAME_FIELD_TYPE_INTERPOLATION = {
+  array: "unsupported",
+  asset: "unsupported",
+  boolean: "unsupported",
+  "remotion-captions": "unsupported",
+  color: "interpolateColors",
+  enum: "unsupported",
+  "font-family": "unsupported",
+  hidden: "infer",
+  number: "infer",
+  "rotation-css": "interpolate",
+  "rotation-degrees": "infer",
+  scale: "interpolate",
+  "text-content": "unsupported",
+  "transform-origin": "interpolate",
+  translate: "interpolate",
+  "uv-coordinate": "infer"
+};
+var KEYFRAME_INTERPOLATION_EASING_SUPPORT = {
+  interpolate: true,
+  interpolateColors: true
+};
+var isKeyframeInterpolationFunction = (name) => {
+  return keyframeInterpolationFunctions.includes(name);
+};
+var canEditEasingForInterpolationFunction = (interpolationFunction) => isKeyframeInterpolationFunction(interpolationFunction) && KEYFRAME_INTERPOLATION_EASING_SUPPORT[interpolationFunction];
+var isInteractivitySchemaFieldKeyframable = (field) => {
+  if (!field) {
+    return true;
+  }
+  return KEYFRAME_FIELD_TYPE_SUPPORT[field.type] && field.keyframable !== false;
+};
+var findFieldInSchema = (schema, key) => {
+  if (key in schema) {
+    return schema[key];
+  }
+  for (const field of Object.values(schema)) {
+    if (field.type !== "enum") {
+      continue;
+    }
+    for (const variant of Object.values(field.variants)) {
+      const found = findFieldInSchema(variant, key);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return;
+};
+var isSchemaFieldKeyframable = ({
+  schema,
+  key
+}) => {
+  const field = schema ? findFieldInSchema(schema, key) : undefined;
+  return isInteractivitySchemaFieldKeyframable(field);
+};
+var getKeyframeInterpolationFunctionForSchemaField = ({
+  schema,
+  key
+}) => {
+  const field = schema ? findFieldInSchema(schema, key) : undefined;
+  if (!field) {
+    return null;
+  }
+  const strategy = KEYFRAME_FIELD_TYPE_INTERPOLATION[field.type];
+  return strategy === "infer" || strategy === "unsupported" ? null : strategy;
+};
+var getKeyframeInterpolationFunction = ({
+  schema,
+  key,
+  staticValue,
+  newValue
+}) => {
+  const schemaFunction = getKeyframeInterpolationFunctionForSchemaField({
+    schema,
+    key
+  });
+  if (schemaFunction) {
+    return schemaFunction;
+  }
+  return typeof staticValue === "string" && typeof newValue === "string" ? "interpolateColors" : "interpolate";
+};
+
+// src/effect-clipboard-data.ts
+var isRecord2 = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var extrapolateTypes = new Set(["extend", "identity", "clamp", "wrap"]);
+var outputOptions = new Set(["linear", "perceptual-scale"]);
+var isFiniteNumber2 = (value) => {
+  return typeof value === "number" && Number.isFinite(value);
+};
+var isEasing = (value) => {
+  return isRecord2(value) && (value.type === "linear" || value.type === "bezier" && isFiniteNumber2(value.x1) && isFiniteNumber2(value.y1) && isFiniteNumber2(value.x2) && isFiniteNumber2(value.y2) || value.type === "spring" && isFiniteNumber2(value.damping) && isFiniteNumber2(value.mass) && isFiniteNumber2(value.stiffness) && (value.allowTail === undefined || value.allowTail === null || typeof value.allowTail === "boolean") && (value.durationRestThreshold === undefined || value.durationRestThreshold === null || isFiniteNumber2(value.durationRestThreshold)) && typeof value.overshootClamping === "boolean");
+};
+var normalizeEasing = (easing) => {
+  if (easing.type !== "spring") {
+    return easing;
+  }
+  return {
+    ...easing,
+    allowTail: easing.allowTail ?? null,
+    durationRestThreshold: easing.durationRestThreshold ?? null
+  };
+};
+var normalizeParam = (param) => {
+  if (param.type === "static") {
+    return param;
+  }
+  return {
+    ...param,
+    easing: param.easing.map(normalizeEasing)
+  };
+};
+var normalizeSnapshot = (snapshot) => {
+  return {
+    ...snapshot,
+    params: Object.fromEntries(Object.entries(snapshot.params).map(([key, param]) => [
+      key,
+      normalizeParam(param)
+    ]))
+  };
+};
+var isKeyframe = (value) => {
+  return isRecord2(value) && isFiniteNumber2(value.frame) && "value" in value;
+};
+var isClamping = (value) => {
+  return isRecord2(value) && typeof value.left === "string" && extrapolateTypes.has(value.left) && typeof value.right === "string" && extrapolateTypes.has(value.right);
+};
+var isEffectClipboardParam = (value) => {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  if (value.type === "static") {
+    return "value" in value;
+  }
+  if (value.type !== "keyframed") {
+    return false;
+  }
+  const { posterize } = value;
+  const { output } = value;
+  const easingLength = Array.isArray(value.keyframes) && value.keyframes.length > 0 ? value.keyframes.length - 1 : null;
+  return typeof value.interpolationFunction === "string" && isKeyframeInterpolationFunction(value.interpolationFunction) && Array.isArray(value.keyframes) && value.keyframes.length > 0 && value.keyframes.every(isKeyframe) && Array.isArray(value.easing) && value.easing.length === easingLength && value.easing.every(isEasing) && isClamping(value.clamping) && (output === undefined || value.interpolationFunction === "interpolate" && typeof output === "string" && outputOptions.has(output)) && (posterize === undefined || isFiniteNumber2(posterize) && posterize > 0);
+};
+var isEffectClipboardSnapshotV3 = (value) => {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.callee === "string" && typeof value.importPath === "string" && isRecord2(value.params) && Object.values(value.params).every(isEffectClipboardParam);
+};
+var parseEffectClipboardDataResult = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord2(parsed)) {
+      return { status: "invalid" };
+    }
+    if (parsed.remotionClipboard !== "effects") {
+      return { status: "invalid" };
+    }
+    if (parsed.version !== 3) {
+      return {
+        status: "unsupported-version",
+        version: parsed.version
+      };
+    }
+    if (parsed.type !== "effects-additive" && parsed.type !== "effects-replacing") {
+      return { status: "invalid" };
+    }
+    if (!Array.isArray(parsed.effects)) {
+      return { status: "invalid" };
+    }
+    const effects = [];
+    for (const effect of parsed.effects) {
+      if (!isEffectClipboardSnapshotV3(effect)) {
+        return { status: "invalid" };
+      }
+      effects.push(normalizeSnapshot(effect));
+    }
+    return {
+      status: "valid",
+      data: {
+        type: parsed.type,
+        version: 3,
+        remotionClipboard: "effects",
+        effects
+      }
+    };
+  } catch {
+    return { status: "invalid" };
+  }
+};
+var parseEffectClipboardData = (value) => {
+  const result = parseEffectClipboardDataResult(value);
+  if (result.status !== "valid") {
+    return null;
+  }
+  return result.data;
+};
+var parseEffectPropClipboardDataResult = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord2(parsed)) {
+      return { status: "invalid" };
+    }
+    if (parsed.remotionClipboard !== "effect-prop") {
+      return { status: "invalid" };
+    }
+    if (parsed.version !== 1) {
+      return {
+        status: "unsupported-version",
+        version: parsed.version
+      };
+    }
+    if (parsed.type !== "effect-prop") {
+      return { status: "invalid" };
+    }
+    if (!isRecord2(parsed.effect)) {
+      return { status: "invalid" };
+    }
+    if (typeof parsed.effect.callee !== "string" || typeof parsed.effect.importPath !== "string") {
+      return { status: "invalid" };
+    }
+    if (typeof parsed.key !== "string") {
+      return { status: "invalid" };
+    }
+    if (!isEffectClipboardParam(parsed.param)) {
+      return { status: "invalid" };
+    }
+    return {
+      status: "valid",
+      data: {
+        type: "effect-prop",
+        version: 1,
+        remotionClipboard: "effect-prop",
+        effect: {
+          callee: parsed.effect.callee,
+          importPath: parsed.effect.importPath
+        },
+        key: parsed.key,
+        param: normalizeParam(parsed.param)
+      }
+    };
+  } catch {
+    return { status: "invalid" };
+  }
+};
+var parseEffectPropClipboardData = (value) => {
+  const result = parseEffectPropClipboardDataResult(value);
+  if (result.status !== "valid") {
+    return null;
+  }
+  return result.data;
+};
+// src/format-bytes.ts
+var BYTE_UNITS = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+var BIBYTE_UNITS = [
+  "B",
+  "kiB",
+  "MiB",
+  "GiB",
+  "TiB",
+  "PiB",
+  "EiB",
+  "ZiB",
+  "YiB"
+];
+var BIT_UNITS = [
+  "b",
+  "kbit",
+  "Mbit",
+  "Gbit",
+  "Tbit",
+  "Pbit",
+  "Ebit",
+  "Zbit",
+  "Ybit"
+];
+var BIBIT_UNITS = [
+  "b",
+  "kibit",
+  "Mibit",
+  "Gibit",
+  "Tibit",
+  "Pibit",
+  "Eibit",
+  "Zibit",
+  "Yibit"
+];
+var toLocaleString = (number, locale, options) => {
+  if (typeof locale === "string" || Array.isArray(locale)) {
+    return number.toLocaleString(locale, options);
+  }
+  if (locale === true || options !== undefined) {
+    return number.toLocaleString(undefined, options);
+  }
+  return String(number);
+};
+var formatBytes = (number, options = {
+  locale: "en-US",
+  signed: false,
+  maximumFractionDigits: 1
+}) => {
+  if (!Number.isFinite(number)) {
+    throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+  }
+  options = { bits: false, binary: false, ...options };
+  const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
+  if (options.signed && number === 0) {
+    return `0 $ {
+            UNITS[0]
+        }`;
+  }
+  const isNegative = number < 0;
+  const prefix = isNegative ? "-" : options.signed ? "+" : "";
+  if (isNegative) {
+    number = -number;
+  }
+  let localeOptions;
+  if (options.minimumFractionDigits !== undefined) {
+    localeOptions = {
+      minimumFractionDigits: options.minimumFractionDigits
+    };
+  }
+  if (options.maximumFractionDigits !== undefined) {
+    localeOptions = {
+      maximumFractionDigits: options.maximumFractionDigits,
+      ...localeOptions
+    };
+  }
+  if (number < 1) {
+    const numString = toLocaleString(number, options.locale, localeOptions);
+    return prefix + numString + " " + UNITS[0];
+  }
+  const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
+  number /= (options.binary ? 1024 : 1000) ** exponent;
+  const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+  const unit = UNITS[exponent];
+  return prefix + numberString + " " + unit;
+};
+// src/get-all-keys.ts
+import { Internals } from "remotion";
+var getAllSchemaKeys = (schema) => {
+  return Object.keys(Internals.getFlatSchemaWithAllKeys(schema));
+};
+var getAssetSchemaKeys = (schema) => {
+  return Object.entries(Internals.getFlatSchemaWithAllKeys(schema)).filter(([, field]) => field?.type === "asset").map(([key]) => key);
+};
+// src/get-default-out-name.ts
+var hasFileExtension = (location) => {
+  const lastSegment = location.split("/").pop() ?? location;
+  return lastSegment.includes(".");
+};
+var getDefaultOutLocation = ({
+  compositionName,
+  defaultExtension,
+  type,
+  compositionDefaultOutName,
+  outputLocation
+}) => {
+  if (outputLocation && hasFileExtension(outputLocation)) {
+    return outputLocation;
+  }
+  const base = outputLocation ?? "out";
+  const dir = base.endsWith("/") ? base : `${base}/`;
+  const nameToUse = compositionDefaultOutName ?? compositionName;
+  if (type === "sequence") {
+    return `${dir}${nameToUse}`;
+  }
+  return `${dir}${nameToUse}.${defaultExtension}`;
+};
+// src/get-location-from-build-error.ts
+import { NoReactInternals } from "remotion/no-react";
+var getLocationFromBuildError = (err) => {
+  if (!err.stack) {
+    return null;
+  }
+  if (!err.stack.startsWith("Error: Module build failed") && !err.stack.startsWith("Error: Cannot find module")) {
+    return null;
+  }
+  const split = err.stack.split(`
+`);
+  return split.map((s) => {
+    if (s.startsWith("Error")) {
+      return null;
+    }
+    const matchWebpackOrEsbuild = s.match(/(.*):([0-9]+):([0-9]+): (.*)/);
+    if (matchWebpackOrEsbuild) {
+      return {
+        fileName: matchWebpackOrEsbuild[1],
+        lineNumber: Number(matchWebpackOrEsbuild[2]),
+        columnNumber: Number(matchWebpackOrEsbuild[3]),
+        message: matchWebpackOrEsbuild[4]
+      };
+    }
+    const matchMissingModule = s.match(/\s+at(.*)\s\((.*)\)/);
+    if (!matchMissingModule) {
+      return null;
+    }
+    if (s.includes("webpackMissingModule")) {
+      return null;
+    }
+    const [, filename] = matchMissingModule;
+    return {
+      columnNumber: 0,
+      lineNumber: 1,
+      message: split[0],
+      fileName: filename.trim()
+    };
+  }).filter(NoReactInternals.truthy)[0] ?? null;
+};
+// src/get-project-name.ts
+var getProjectName = ({
+  gitSource,
+  resolvedRemotionRoot,
+  basename
+}) => {
+  if (!gitSource) {
+    return basename(resolvedRemotionRoot);
+  }
+  if (gitSource.relativeFromGitRoot.trim()) {
+    return basename(gitSource.relativeFromGitRoot.trim());
+  }
+  return gitSource.name;
+};
+// src/hot-middleware.ts
+var hotMiddlewareOptions = {
+  timeout: 20 * 1000,
+  reload: true,
+  warn: true
+};
+// src/keyframe-clipboard-data.ts
+var KEYFRAME_CLIPBOARD_FIELD_TYPE_SUPPORT = {
+  array: false,
+  asset: false,
+  boolean: false,
+  "remotion-captions": false,
+  color: true,
+  enum: false,
+  "font-family": false,
+  hidden: false,
+  number: true,
+  "rotation-css": true,
+  "rotation-degrees": true,
+  scale: true,
+  "text-content": false,
+  "transform-origin": true,
+  translate: true,
+  "uv-coordinate": true
+};
+var isRecord3 = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isKeyframeClipboardFieldType = (value) => {
+  return typeof value === "string" && Object.hasOwn(KEYFRAME_CLIPBOARD_FIELD_TYPE_SUPPORT, value) && KEYFRAME_CLIPBOARD_FIELD_TYPE_SUPPORT[value];
+};
+var isKeyframeClipboardEntry = (value) => {
+  return isRecord3(value) && Number.isInteger(value.frameOffset) && Object.hasOwn(value, "value");
+};
+var areValidKeyframes = (value) => {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  let previousOffset = -1;
+  for (const keyframe of value) {
+    if (!isKeyframeClipboardEntry(keyframe) || keyframe.frameOffset <= previousOffset) {
+      return false;
+    }
+    previousOffset = keyframe.frameOffset;
+  }
+  return value[0]?.frameOffset === 0;
+};
+var isKeyframeClipboardField = (value) => {
+  return isRecord3(value) && (value.type === "sequence" || value.type === "effect") && typeof value.fieldKey === "string";
+};
+var parseEasings = ({
+  value,
+  keyframeCount
+}) => {
+  if (Array.isArray(value) && value.length === Math.max(0, keyframeCount - 1) && value.every(isKeyframeEasing)) {
+    return value.map(normalizeKeyframeEasing);
+  }
+  return null;
+};
+var parseKeyframeClipboardDataResult = (value) => {
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord3(parsed) || parsed.remotionClipboard !== "keyframe") {
+      return { status: "invalid" };
+    }
+    if (parsed.version !== 1) {
+      return { status: "unsupported-version", version: parsed.version };
+    }
+    const easing = parseEasings({
+      value: parsed.easing,
+      keyframeCount: Array.isArray(parsed.keyframes) ? parsed.keyframes.length : 0
+    });
+    if (parsed.type !== "keyframe" || !areValidKeyframes(parsed.keyframes) || easing === null || parsed.field !== null && !isKeyframeClipboardField(parsed.field) || parsed.fieldType !== null && !isKeyframeClipboardFieldType(parsed.fieldType)) {
+      return { status: "invalid" };
+    }
+    return {
+      status: "valid",
+      data: {
+        type: "keyframe",
+        version: 1,
+        remotionClipboard: "keyframe",
+        fieldType: parsed.fieldType,
+        field: parsed.field,
+        keyframes: parsed.keyframes,
+        easing
+      }
+    };
+  } catch {
+    return { status: "invalid" };
+  }
+};
+var parseKeyframeClipboardData = (value) => {
+  const result = parseKeyframeClipboardDataResult(value);
+  return result.status === "valid" ? result.data : null;
+};
+// src/keyframe-easing-presets.ts
+var LINEAR_KEYFRAME_EASING = { type: "linear" };
+var EASE_KEYFRAME_EASING = {
+  type: "bezier",
+  x1: 0.42,
+  y1: 0,
+  x2: 1,
+  y2: 1
+};
+var QUAD_KEYFRAME_EASING = {
+  type: "bezier",
+  x1: 1 / 3,
+  y1: 0,
+  x2: 2 / 3,
+  y2: 1 / 3
+};
+var CUBIC_KEYFRAME_EASING = {
+  type: "bezier",
+  x1: 1 / 3,
+  y1: 0,
+  x2: 2 / 3,
+  y2: 0
+};
+var getBackKeyframeEasing = (s = 1.70158) => ({
+  type: "bezier",
+  x1: 1 / 3,
+  y1: 0,
+  x2: 2 / 3,
+  y2: -s / 3
+});
+var getPolyKeyframeEasing = (n) => {
+  if (n === 1) {
+    return LINEAR_KEYFRAME_EASING;
+  }
+  if (n === 2) {
+    return QUAD_KEYFRAME_EASING;
+  }
+  if (n === 3) {
+    return CUBIC_KEYFRAME_EASING;
+  }
+  return null;
+};
+var getOutKeyframeEasing = (easing) => {
+  if (easing.type === "linear") {
+    return LINEAR_KEYFRAME_EASING;
+  }
+  if (easing.type !== "bezier") {
+    return null;
+  }
+  return {
+    type: "bezier",
+    x1: 1 - easing.x2,
+    y1: 1 - easing.y2,
+    x2: 1 - easing.x1,
+    y2: 1 - easing.y1
+  };
+};
+var KEYFRAME_EASING_PRESETS = [
+  {
+    id: "ease-in",
+    label: "Ease in",
+    easing: { type: "bezier", x1: 0.42, y1: 0, x2: 1, y2: 1 }
+  },
+  {
+    id: "ease-out",
+    label: "Ease out",
+    easing: { type: "bezier", x1: 0, y1: 0, x2: 0.58, y2: 1 }
+  },
+  {
+    id: "ease-in-out",
+    label: "Ease in-out",
+    easing: { type: "bezier", x1: 0.42, y1: 0, x2: 0.58, y2: 1 }
+  },
+  {
+    id: "tail-spring",
+    label: "Tail spring",
+    easing: {
+      type: "spring",
+      allowTail: true,
+      damping: 200,
+      durationRestThreshold: 0.02,
+      mass: 1,
+      overshootClamping: false,
+      stiffness: 100
+    }
+  },
+  {
+    id: "spring",
+    label: "Spring",
+    easing: {
+      type: "spring",
+      allowTail: true,
+      damping: 10,
+      durationRestThreshold: 0.02,
+      mass: 1,
+      overshootClamping: false,
+      stiffness: 100
+    }
+  },
+  {
+    id: "bouncy-spring",
+    label: "Bouncy spring",
+    easing: {
+      type: "spring",
+      allowTail: true,
+      damping: 5,
+      durationRestThreshold: 0.02,
+      mass: 1,
+      overshootClamping: false,
+      stiffness: 120
+    }
+  }
+];
+// src/max-timeline-tracks.ts
+var DEFAULT_TIMELINE_TRACKS = 90;
+// src/package-info.ts
+import { VERSION } from "remotion";
+
+// src/release-package-policy.ts
+var packagesRemovedInV5 = [
+  "@remotion/light-leaks",
+  "@remotion/media-parser",
+  "@remotion/starburst",
+  "@remotion/webcodecs"
+];
+var packagesRemovedInV5Set = new Set(packagesRemovedInV5);
+var shouldReleasePackage = ({
+  packageName,
+  releaseVersion
+}) => {
+  const majorVersion = Number.parseInt(releaseVersion.split(".")[0], 10);
+  if (!Number.isInteger(majorVersion)) {
+    throw new Error(`Invalid release version: ${releaseVersion}`);
+  }
+  return majorVersion < 5 || !packagesRemovedInV5Set.has(packageName);
+};
+
+// src/package-info.ts
+var allPackages = [
+  "svg-3d-engine",
+  "animation-utils",
+  "animated-emoji",
+  "astro-example",
+  "babel-loader",
+  "bugs",
+  "brand",
+  "bundler",
+  "browser-studio",
+  "claude-code-plugin",
+  "cli",
+  "cloudrun",
+  "codex-plugin",
+  "kimi-code-plugin",
+  "compositor-darwin-arm64",
+  "compositor-darwin-x64",
+  "compositor-linux-arm64-gnu",
+  "compositor-linux-arm64-musl",
+  "compositor-linux-x64-gnu",
+  "compositor-linux-x64-musl",
+  "compositor-win32-x64-msvc",
+  "core",
+  "create-video",
+  "discord-poster",
+  "docusaurus-plugin",
+  "docs",
+  "enable-scss",
+  "eslint-config",
+  "eslint-config-flat",
+  "eslint-config-internal",
+  "eslint-plugin",
+  "example-without-zod",
+  "example",
+  "fonts",
+  "gif",
+  "google-fonts",
+  "install-whisper-cpp",
+  "it-tests",
+  "react18-tests",
+  "lambda-go-example",
+  "lambda-go",
+  "lambda-php",
+  "lambda-ruby",
+  "lambda-python",
+  "lambda",
+  "lambda-client",
+  "layout-utils",
+  "rounded-text-box",
+  "licensing",
+  "lottie",
+  "mcp",
+  "media-utils",
+  "motion-blur",
+  "noise",
+  "paths",
+  "player-a11y",
+  "player-example",
+  "player",
+  "preload",
+  "renderer",
+  "rive",
+  "shapes",
+  "skia",
+  "promo-pages",
+  "streaming",
+  "serverless",
+  "serverless-client",
+  "skills",
+  "skills-evals",
+  "studio-codemods",
+  "studio-server",
+  "studio-shared",
+  "studio",
+  "tailwind",
+  "tailwind-v4",
+  "timeline-utils",
+  "test-utils",
+  "three",
+  "transitions",
+  "media-parser",
+  "zod-types",
+  "zod-types-v3",
+  "webcodecs",
+  "convert",
+  "captions",
+  "openai-whisper",
+  "elevenlabs",
+  "compositor",
+  "example-videos",
+  "whisper-web",
+  "media",
+  "remotion-media",
+  "web-renderer",
+  "design",
+  "studio-protocol",
+  "light-leaks",
+  "rough-notation",
+  "starburst",
+  "vercel",
+  "sfx",
+  "effects"
+];
+var packages = allPackages.filter((pkg) => shouldReleasePackage({
+  packageName: pkg === "core" ? "remotion" : `@remotion/${pkg}`,
+  releaseVersion: VERSION
+}));
+var extraPackages = [
+  {
+    name: "mediabunny",
+    version: "1.50.8",
+    description: "Multimedia library used by Remotion",
+    docsUrl: "https://www.remotion.dev/docs/mediabunny/version"
+  },
+  {
+    name: "@mediabunny/ac3",
+    version: "1.50.8",
+    description: "AC-3 and E-AC-3 audio codec support for Mediabunny",
+    docsUrl: "https://www.remotion.dev/docs/mediabunny/formats#ac-3-and-e-ac-3"
+  },
+  {
+    name: "@mediabunny/prores",
+    version: "1.50.8",
+    description: "Apple ProRes decoder support for Mediabunny",
+    docsUrl: "https://www.remotion.dev/docs/mediabunny/formats"
+  },
+  {
+    name: "zod",
+    version: "4.4.3",
+    description: "TypeScript-first schema validation",
+    docsUrl: "https://zod.dev"
+  }
+];
+var descriptions = {
+  compositor: "Rust binary for Remotion",
+  player: "React component for embedding a Remotion preview into your app",
+  cloudrun: "Render Remotion videos on Google Cloud Run",
+  "claude-code-plugin": null,
+  "codex-plugin": null,
+  "kimi-code-plugin": null,
+  renderer: "Render Remotion videos using Node.js or Bun",
+  cli: "Control Remotion features using the `npx remotion` command",
+  core: "Make videos programmatically",
+  lambda: "Render Remotion videos on AWS Lambda",
+  bundler: "Bundle Remotion compositions using Webpack",
+  "browser-studio": "Run Remotion Studio in the browser",
+  "studio-codemods": "Shared codemods for Remotion Studio",
+  "studio-server": "Run a Remotion Studio with a server backend",
+  "install-whisper-cpp": "Helpers for installing and using Whisper.cpp",
+  "whisper-web": "Helpers for using Whisper.cpp in browser using WASM",
+  "google-fonts": "Use Google Fonts in Remotion",
+  mcp: "Remotion's Model Context Protocol",
+  "media-utils": "Utilities for working with media files",
+  lottie: "Include Lottie animations in Remotion",
+  licensing: "Manage your Remotion.pro license",
+  "layout-utils": "Utilities for working with layouts",
+  "rounded-text-box": "Create a TikTok-like multiline text box SVG path with rounded corners",
+  noise: "Noise generation functions",
+  "motion-blur": "Motion blur effect for Remotion",
+  preload: "Preloads assets for use in Remotion",
+  shapes: "Generate SVG shapes",
+  "zod-types": "Zod types for Remotion",
+  "zod-types-v3": "Zod 3.22.3 types for Remotion",
+  gif: "Embed GIFs in a Remotion video",
+  "eslint-plugin": "Rules for writing Remotion code",
+  "eslint-config": "Default configuration for Remotion templates (ESLint <= 8)",
+  "eslint-config-flat": "Default configuration for Remotion templates (ESLint >= 9)",
+  "compositor-linux-x64-gnu": "Linux x64 binary for the Remotion Rust code",
+  "compositor-linux-x64-musl": "Linux x64 binary for the Remotion Rust code",
+  "compositor-darwin-x64": "MacOS x64 binary for the Remotion Rust code",
+  "compositor-darwin-arm64": "MacOS Apple Silicon binary for the Remotion Rust code",
+  "compositor-linux-arm64-gnu": "Linux ARM64 binary for the Remotion Rust code",
+  "compositor-linux-arm64-musl": "Linux ARM64 binary for the Remotion Rust code",
+  "babel-loader": "Babel loader for Remotion",
+  fonts: "Helpers for loading local fonts into Remotion",
+  transitions: "Library for creating transitions in Remotion",
+  "enable-scss": "Enable SCSS support in Remotion",
+  "create-video": "Create a new Remotion project",
+  "studio-shared": "Internal package for shared objects between the Studio backend and frontend",
+  "timeline-utils": "Internal utilities for rendering Remotion timelines",
+  tailwind: "Enable TailwindCSS support in Remotion (TailwindCSS v3)",
+  "tailwind-v4": "Enable TailwindCSS support in Remotion (TailwindCSS v4)",
+  streaming: "Utilities for streaming data between programs",
+  "media-parser": "A pure JavaScript library for parsing video files",
+  rive: "Embed Rive animations in a Remotion video",
+  paths: "Utilities for working with SVG paths",
+  studio: "APIs for interacting with the Remotion Studio",
+  skia: "Include React Native Skia components in a Remotion video",
+  three: "Include React Three Fiber components in a Remotion video",
+  "astro-example": null,
+  "lambda-go-example": null,
+  "compositor-win32-x64-msvc": null,
+  "animation-utils": "Helpers for animating CSS properties",
+  "test-utils": null,
+  "example-without-zod": null,
+  "lambda-go": null,
+  example: null,
+  "lambda-php": null,
+  "lambda-client": null,
+  bugs: null,
+  brand: null,
+  docs: null,
+  "it-tests": null,
+  "react18-tests": null,
+  "lambda-python": null,
+  "lambda-ruby": null,
+  "player-example": null,
+  skills: null,
+  "skills-evals": null,
+  "discord-poster": null,
+  "docusaurus-plugin": null,
+  "animated-emoji": "Google Fonts Animated Emojis as Remotion components",
+  serverless: "A runtime for distributed rendering",
+  webcodecs: "Media conversion in the browser",
+  convert: "Video conversion tool - convert.remotion.dev",
+  captions: "Primitives for dealing with captions",
+  "openai-whisper": "Work with the output of the OpenAI Whisper API",
+  elevenlabs: "Work with the output of the ElevenLabs API",
+  "eslint-config-internal": "ESLint condig for Remotion's internal packages",
+  "example-videos": null,
+  "promo-pages": null,
+  "svg-3d-engine": "3D SVG extrusion effects",
+  "serverless-client": null,
+  media: "Experimental WebCodecs-based media tags",
+  "remotion-media": null,
+  "web-renderer": "Render videos in the browser",
+  design: "Design system",
+  "studio-protocol": "Create Element payloads and request installation into Remotion Studio",
+  "light-leaks": "Light leak effects for Remotion",
+  "rough-notation": "Rough annotation primitives for Remotion",
+  "player-a11y": "Internal accessibility wrapper around @remotion/player",
+  starburst: "Starburst ray effect for Remotion",
+  vercel: "Render Remotion videos on Vercel Sandbox",
+  sfx: "Sound effect library",
+  effects: "Effects that can be applied to Remotion-based canvas components"
+};
+var installableMap = {
+  "svg-3d-engine": false,
+  "animation-utils": true,
+  "animated-emoji": true,
+  "astro-example": false,
+  "babel-loader": false,
+  bugs: false,
+  brand: false,
+  bundler: false,
+  "browser-studio": false,
+  cli: false,
+  cloudrun: true,
+  "claude-code-plugin": false,
+  "codex-plugin": false,
+  "kimi-code-plugin": false,
+  "lambda-client": false,
+  "serverless-client": false,
+  "compositor-darwin-arm64": false,
+  "compositor-darwin-x64": false,
+  "compositor-linux-arm64-gnu": false,
+  "compositor-linux-arm64-musl": false,
+  "compositor-linux-x64-gnu": false,
+  "compositor-linux-x64-musl": false,
+  "compositor-win32-x64-msvc": false,
+  core: false,
+  "create-video": false,
+  "discord-poster": false,
+  "docusaurus-plugin": false,
+  docs: false,
+  "enable-scss": true,
+  "eslint-config": false,
+  "eslint-config-flat": false,
+  "eslint-config-internal": false,
+  "eslint-plugin": false,
+  "example-without-zod": false,
+  example: false,
+  fonts: true,
+  gif: true,
+  "google-fonts": true,
+  "install-whisper-cpp": true,
+  "whisper-web": true,
+  "it-tests": false,
+  "react18-tests": false,
+  "lambda-go-example": false,
+  "lambda-go": false,
+  "lambda-php": false,
+  "lambda-ruby": false,
+  "lambda-python": false,
+  lambda: true,
+  mcp: true,
+  "layout-utils": true,
+  "rounded-text-box": true,
+  licensing: true,
+  lottie: true,
+  "media-utils": true,
+  "motion-blur": true,
+  noise: true,
+  paths: true,
+  "player-example": false,
+  "player-a11y": false,
+  player: true,
+  preload: true,
+  renderer: true,
+  rive: true,
+  shapes: true,
+  skia: true,
+  skills: false,
+  "skills-evals": false,
+  "promo-pages": false,
+  streaming: false,
+  serverless: false,
+  "studio-codemods": false,
+  "studio-server": false,
+  "studio-shared": false,
+  studio: true,
+  tailwind: true,
+  "tailwind-v4": true,
+  "timeline-utils": false,
+  "test-utils": false,
+  three: true,
+  transitions: true,
+  "media-parser": shouldReleasePackage({
+    packageName: "@remotion/media-parser",
+    releaseVersion: VERSION
+  }),
+  "zod-types": true,
+  "zod-types-v3": true,
+  webcodecs: shouldReleasePackage({
+    packageName: "@remotion/webcodecs",
+    releaseVersion: VERSION
+  }),
+  convert: false,
+  captions: true,
+  "openai-whisper": true,
+  elevenlabs: true,
+  compositor: false,
+  "example-videos": false,
+  media: true,
+  "remotion-media": false,
+  "web-renderer": false,
+  design: false,
+  "studio-protocol": true,
+  "light-leaks": shouldReleasePackage({
+    packageName: "@remotion/light-leaks",
+    releaseVersion: VERSION
+  }),
+  "rough-notation": true,
+  starburst: shouldReleasePackage({
+    packageName: "@remotion/starburst",
+    releaseVersion: VERSION
+  }),
+  vercel: true,
+  sfx: true,
+  effects: true
+};
+var apiDocs = {
+  player: "https://www.remotion.dev/docs/player",
+  cloudrun: "https://www.remotion.dev/docs/cloudrun",
+  "claude-code-plugin": null,
+  "codex-plugin": null,
+  "kimi-code-plugin": null,
+  renderer: "https://www.remotion.dev/docs/renderer",
+  cli: "https://www.remotion.dev/docs/cli",
+  core: "https://www.remotion.dev/docs/remotion",
+  lambda: "https://www.remotion.dev/docs/lambda",
+  bundler: "https://www.remotion.dev/docs/bundler",
+  "browser-studio": null,
+  "studio-codemods": null,
+  "lambda-client": null,
+  "serverless-client": null,
+  "studio-server": null,
+  "install-whisper-cpp": "https://www.remotion.dev/docs/install-whisper-cpp",
+  "whisper-web": "https://www.remotion.dev/docs/whisper-web",
+  "google-fonts": "https://www.remotion.dev/docs/google-fonts",
+  "media-utils": "https://www.remotion.dev/docs/media-utils",
+  lottie: "https://www.remotion.dev/docs/lottie",
+  licensing: "https://www.remotion.dev/docs/licensing",
+  "layout-utils": "https://www.remotion.dev/docs/layout-utils",
+  "rounded-text-box": "https://www.remotion.dev/docs/rounded-text-box",
+  noise: "https://www.remotion.dev/docs/noise",
+  mcp: "https://www.remotion.dev/docs/ai/mcp",
+  "motion-blur": "https://www.remotion.dev/docs/motion-blur",
+  preload: "https://www.remotion.dev/docs/preload",
+  shapes: "https://www.remotion.dev/docs/shapes",
+  "zod-types": "https://www.remotion.dev/docs/zod-types",
+  "zod-types-v3": "https://www.remotion.dev/docs/zod-types/v3",
+  gif: "https://www.remotion.dev/docs/gif",
+  "eslint-plugin": "https://www.remotion.dev/docs/brownfield#install-the-eslint-plugin",
+  "eslint-config": "https://www.remotion.dev/docs/brownfield#install-the-eslint-plugin",
+  "eslint-config-flat": "https://www.remotion.dev/docs/brownfield#install-the-eslint-plugin",
+  "compositor-linux-x64-gnu": null,
+  "compositor-linux-x64-musl": null,
+  "compositor-darwin-x64": null,
+  "discord-poster": null,
+  "docusaurus-plugin": null,
+  "animation-utils": "https://www.remotion.dev/docs/animation-utils/",
+  "example-without-zod": null,
+  "lambda-go": null,
+  example: null,
+  "lambda-php": null,
+  bugs: null,
+  brand: null,
+  docs: null,
+  "it-tests": null,
+  "react18-tests": null,
+  "lambda-python": null,
+  "lambda-ruby": "https://www.remotion.dev/docs/lambda/ruby",
+  "player-example": null,
+  "player-a11y": null,
+  "astro-example": null,
+  "lambda-go-example": null,
+  "test-utils": null,
+  "babel-loader": "https://www.remotion.dev/docs/legacy-babel",
+  "compositor-darwin-arm64": null,
+  "compositor-linux-arm64-gnu": null,
+  "compositor-linux-arm64-musl": null,
+  "compositor-win32-x64-msvc": null,
+  "enable-scss": "https://www.remotion.dev/docs/enable-scss/overview",
+  "create-video": "https://remotion.dev/templates",
+  "studio-shared": null,
+  "media-parser": "https://www.remotion.dev/docs/media-parser",
+  fonts: "https://www.remotion.dev/docs/fonts-api",
+  paths: "https://www.remotion.dev/paths",
+  rive: "https://www.remotion.dev/docs/rive",
+  tailwind: "https://www.remotion.dev/docs/tailwind/tailwind",
+  "tailwind-v4": "https://www.remotion.dev/docs/tailwind/tailwind",
+  skia: "https://www.remotion.dev/docs/skia",
+  three: "https://www.remotion.dev/docs/three",
+  streaming: null,
+  serverless: null,
+  skills: null,
+  "skills-evals": null,
+  studio: "https://www.remotion.dev/docs/studio/api",
+  "timeline-utils": null,
+  transitions: "https://www.remotion.dev/transitions",
+  "animated-emoji": "https://www.remotion.dev/docs/animated-emoji",
+  webcodecs: "https://remotion.dev/webcodecs",
+  convert: "https://convert.remotion.dev",
+  captions: "https://remotion.dev/docs/captions/api",
+  "openai-whisper": "https://www.remotion.dev/docs/openai-whisper",
+  elevenlabs: "https://www.remotion.dev/docs/elevenlabs",
+  "eslint-config-internal": null,
+  compositor: null,
+  "example-videos": null,
+  "promo-pages": null,
+  "remotion-media": null,
+  "svg-3d-engine": null,
+  media: "https://remotion.dev/docs/media",
+  "web-renderer": "https://www.remotion.dev/docs/web-renderer/",
+  design: "https://www.remotion.dev/design",
+  "studio-protocol": "https://www.remotion.dev/docs/studio-protocol",
+  "light-leaks": "https://www.remotion.dev/docs/light-leaks",
+  "rough-notation": "https://www.remotion.dev/docs/rough-notation",
+  starburst: "https://www.remotion.dev/docs/starburst",
+  vercel: "https://www.remotion.dev/docs/vercel/api",
+  sfx: "https://www.remotion.dev/docs/sfx",
+  effects: "https://www.remotion.dev/docs/effects/api"
+};
+// src/parse-spring-easing-config.ts
+var DEFAULT_SPRING_EASING = {
+  type: "spring",
+  allowTail: null,
+  damping: 10,
+  durationRestThreshold: null,
+  mass: 1,
+  overshootClamping: false,
+  stiffness: 100
+};
+var isAstNode = (value) => {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+};
+var getNumericValue = (node) => {
+  if (node.type === "NumericLiteral") {
+    return typeof node.value === "number" ? node.value : null;
+  }
+  if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+") && isAstNode(node.argument) && node.argument.type === "NumericLiteral" && typeof node.argument.value === "number") {
+    return node.operator === "-" ? -node.argument.value : node.argument.value;
+  }
+  if (node.type === "TSAsExpression" && isAstNode(node.expression)) {
+    return getNumericValue(node.expression);
+  }
+  return null;
+};
+var getBooleanValue = (node) => {
+  if (node.type === "BooleanLiteral") {
+    return typeof node.value === "boolean" ? node.value : null;
+  }
+  if (node.type === "TSAsExpression" && isAstNode(node.expression)) {
+    return getBooleanValue(node.expression);
+  }
+  return null;
+};
+var getObjectPropertyName = (prop) => {
+  if (prop.computed === true || !isAstNode(prop.key)) {
+    return null;
+  }
+  if (prop.key.type === "Identifier") {
+    return typeof prop.key.name === "string" ? prop.key.name : null;
+  }
+  if (prop.key.type === "StringLiteral") {
+    return typeof prop.key.value === "string" ? prop.key.value : null;
+  }
+  return null;
+};
+var parseSpringEasingConfig = (node) => {
+  if (node === undefined) {
+    return { ...DEFAULT_SPRING_EASING };
+  }
+  if (!isAstNode(node)) {
+    return null;
+  }
+  if (node.type === "TSAsExpression") {
+    return parseSpringEasingConfig(node.expression);
+  }
+  if (node.type !== "ObjectExpression" || !Array.isArray(node.properties)) {
+    return null;
+  }
+  const spring = { ...DEFAULT_SPRING_EASING };
+  for (const prop of node.properties) {
+    if (!isAstNode(prop) || prop.type !== "ObjectProperty") {
+      return null;
+    }
+    const key = getObjectPropertyName(prop);
+    if (!key || !isAstNode(prop.value)) {
+      return null;
+    }
+    if (key === "damping" || key === "mass" || key === "stiffness" || key === "durationRestThreshold") {
+      const numericValue = getNumericValue(prop.value);
+      if (numericValue === null || !Number.isFinite(numericValue) || numericValue <= 0) {
+        return null;
+      }
+      spring[key] = numericValue;
+      continue;
+    }
+    if (key === "overshootClamping" || key === "allowTail") {
+      const booleanValue = getBooleanValue(prop.value);
+      if (booleanValue === null) {
+        return null;
+      }
+      spring[key] = booleanValue;
+      continue;
+    }
+    return null;
+  }
+  return spring;
+};
+// src/package-name.ts
+var nodeBuiltinPackages = new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "sea",
+  "sqlite",
+  "stream",
+  "string_decoder",
+  "sys",
+  "test",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib"
+]);
+var scopedPackagePattern = /^(?:@([^/]+?)\/)?([^/]+?)$/;
+var reservedPackageNames = new Set(["node_modules", "favicon.ico"]);
+var isValidPackageName = (packageName) => {
+  if (packageName.length === 0 || packageName.length > 214 || packageName.startsWith(".") || packageName.startsWith("_") || packageName.startsWith("-") || packageName.trim() !== packageName || packageName.toLowerCase() !== packageName || reservedPackageNames.has(packageName) || nodeBuiltinPackages.has(packageName) || /[~'!()*]/.test(packageName.split("/").at(-1) ?? "")) {
+    return false;
+  }
+  if (encodeURIComponent(packageName) === packageName) {
+    return true;
+  }
+  const match = packageName.match(scopedPackagePattern);
+  if (!match) {
+    return false;
+  }
+  const [, scope, name] = match;
+  return scope !== undefined && name !== undefined && encodeURIComponent(scope) === scope && encodeURIComponent(name) === name;
+};
+
+// src/required-package.ts
+var getRequiredPackageForImportPath = (importPath) => {
+  if (importPath === "remotion" || importPath.startsWith(".")) {
+    return null;
+  }
+  if (importPath.startsWith("@")) {
+    const [scope, scopedPackageName] = importPath.split("/");
+    const scopedPackage = scope && scopedPackageName ? `${scope}/${scopedPackageName}` : null;
+    return scopedPackage && isValidPackageName(scopedPackage) ? scopedPackage : null;
+  }
+  const [packageName] = importPath.split("/");
+  return packageName && isValidPackageName(packageName) ? packageName : null;
+};
+var getRequiredPackageForInsertableElement = (element) => {
+  if (element.type === "solid" || element.type === "svg") {
+    return null;
+  }
+  if (element.type === "component") {
+    return getRequiredPackageForImportPath(element.importPath);
+  }
+  if (element.type === "composition") {
+    return null;
+  }
+  if (element.assetType === "video" || element.assetType === "audio") {
+    return "@remotion/media";
+  }
+  if (element.assetType === "gif") {
+    return "@remotion/gif";
+  }
+  if (element.assetType === "animated-image") {
+    return null;
+  }
+  return null;
+};
+var getRequiredPackageForEffectImportPath = (importPath) => {
+  if (importPath.startsWith("@remotion/effects/")) {
+    return "@remotion/effects";
+  }
+  if (importPath === "@remotion/light-leaks" || importPath === "@remotion/starburst") {
+    return importPath;
+  }
+  return null;
+};
+// src/schema-field-info.ts
+import { Internals as Internals2 } from "remotion";
+import { NoReactInternals as NoReactInternals2 } from "remotion/no-react";
+
+// src/style-property-relations.ts
+var BORDER_RADIUS_SHORTHAND_KEY = "style.borderRadius";
+var BORDER_RADIUS_LONGHAND_KEYS = [
+  "style.borderTopLeftRadius",
+  "style.borderTopRightRadius",
+  "style.borderBottomRightRadius",
+  "style.borderBottomLeftRadius"
+];
+var STYLE_PROPERTY_LONGHANDS = new Map([
+  [BORDER_RADIUS_SHORTHAND_KEY, BORDER_RADIUS_LONGHAND_KEYS]
+]);
+var getStylePropertyLonghandKeys = (fieldKey) => STYLE_PROPERTY_LONGHANDS.get(fieldKey) ?? [];
+
+// src/schema-field-info.ts
+var SCHEMA_FIELD_ROW_HEIGHT = 22;
+var SCHEMA_FIELD_GROUPS = [
+  { id: "source", label: "Source" },
+  { id: "controls", label: "Controls" },
+  { id: "transforms", label: "Transform" },
+  { id: "text", label: "Text" },
+  { id: "background", label: "Background" },
+  { id: "border", label: "Border" },
+  { id: "border-radius", label: "Border radius" },
+  { id: "crop", label: "Crop" },
+  { id: "layout", label: "Layout" }
+];
+var schemaFieldGroupOrder = SCHEMA_FIELD_GROUPS.reduce((acc, group, index) => {
+  acc[group.id] = index;
+  return acc;
+}, {});
+var TRANSFORM_FIELD_KEYS = new Set([
+  "style.transformOrigin",
+  "style.translate",
+  "style.scale",
+  "style.rotate",
+  "style.opacity"
+]);
+var CROP_FIELD_KEYS = new Set([
+  "cropLeft",
+  "cropRight",
+  "cropTop",
+  "cropBottom"
+]);
+var BORDER_RADIUS_FIELD_KEYS = new Set([
+  "style.borderRadius",
+  "style.borderTopLeftRadius",
+  "style.borderTopRightRadius",
+  "style.borderBottomRightRadius",
+  "style.borderBottomLeftRadius"
+]);
+var getBorderRadiusFieldKeysToShow = ({
+  activeSchema,
+  propStatuses,
+  nodePath
+}) => {
+  if (!(BORDER_RADIUS_SHORTHAND_KEY in activeSchema)) {
+    return null;
+  }
+  const statuses = Internals2.getPropStatusesCtx(propStatuses, nodePath);
+  const shorthand = statuses?.[BORDER_RADIUS_SHORTHAND_KEY];
+  const longhands = BORDER_RADIUS_LONGHAND_KEYS.map((key) => statuses?.[key]);
+  if (shorthand?.status === "keyframed") {
+    return new Set([BORDER_RADIUS_SHORTHAND_KEY]);
+  }
+  if (shorthand?.status === "static" && shorthand.codeValue !== undefined) {
+    return new Set([BORDER_RADIUS_SHORTHAND_KEY]);
+  }
+  const hasEditableLonghand = longhands.some((status) => status?.status === "keyframed" || status?.status === "static" && status.codeValue !== undefined);
+  if (hasEditableLonghand) {
+    return new Set(BORDER_RADIUS_LONGHAND_KEYS);
+  }
+  return new Set([BORDER_RADIUS_SHORTHAND_KEY]);
+};
+var BORDER_FIELD_KEYS = new Set([
+  "style.borderWidth",
+  "style.borderStyle",
+  "style.borderColor"
+]);
+var BACKGROUND_FIELD_KEYS = new Set(["style.backgroundColor"]);
+var LAYOUT_FIELD_KEYS = new Set(["layout", "premountFor"]);
+var TEXT_FIELD_KEYS = new Set([
+  "children",
+  "style.color",
+  "style.fontFamily",
+  "style.fontSize",
+  "style.lineHeight",
+  "style.fontWeight",
+  "style.fontStyle",
+  "style.letterSpacing",
+  "style.textAlign"
+]);
+var getSchemaFieldGroup = (key) => {
+  if (key === "src") {
+    return "source";
+  }
+  if (TRANSFORM_FIELD_KEYS.has(key)) {
+    return "transforms";
+  }
+  if (CROP_FIELD_KEYS.has(key)) {
+    return "crop";
+  }
+  if (BORDER_RADIUS_FIELD_KEYS.has(key)) {
+    return "border-radius";
+  }
+  if (BORDER_FIELD_KEYS.has(key)) {
+    return "border";
+  }
+  if (BACKGROUND_FIELD_KEYS.has(key)) {
+    return "background";
+  }
+  if (LAYOUT_FIELD_KEYS.has(key)) {
+    return "layout";
+  }
+  if (TEXT_FIELD_KEYS.has(key)) {
+    return "text";
+  }
+  return "controls";
+};
+var sortSchemaFields = (fields) => {
+  return fields.map((field, index) => ({ field, index })).sort((a, b) => {
+    const groupDiff = schemaFieldGroupOrder[a.field.group] - schemaFieldGroupOrder[b.field.group];
+    return groupDiff === 0 ? a.index - b.index : groupDiff;
+  }).map(({ field }) => field);
+};
+var TIMELINE_SCHEMA_FIELD_TYPE_SUPPORT = {
+  array: true,
+  asset: true,
+  boolean: true,
+  "remotion-captions": false,
+  color: true,
+  enum: true,
+  "font-family": true,
+  hidden: false,
+  number: true,
+  "rotation-css": true,
+  "rotation-degrees": true,
+  scale: true,
+  "text-content": true,
+  "transform-origin": true,
+  translate: true,
+  "uv-coordinate": true
+};
+var isTimelineSchemaFieldSupported = (field) => TIMELINE_SCHEMA_FIELD_TYPE_SUPPORT[field.type];
+var getArrayRowCount = ({
+  fieldSchema,
+  value
+}) => {
+  const items = Array.isArray(value) ? value : Array.isArray(fieldSchema.default) ? fieldSchema.default : Array.from({ length: fieldSchema.minLength ?? 0 });
+  const canAdd = items.length < (fieldSchema.maxLength ?? Infinity);
+  return Math.max(1, items.length + (canAdd ? 1 : 0));
+};
+var getSchemaFieldRowHeight = ({
+  fieldSchema,
+  value
+}) => {
+  if (fieldSchema.type === "array") {
+    return getArrayRowCount({
+      fieldSchema,
+      value
+    }) * SCHEMA_FIELD_ROW_HEIGHT;
+  }
+  return SCHEMA_FIELD_ROW_HEIGHT;
+};
+var getEffectFieldValue = ({
+  key,
+  dragOverrides,
+  effectStatus
+}) => {
+  const dragOverride = Internals2.getStaticDragOverrideValue(dragOverrides[key]);
+  if (dragOverride !== undefined) {
+    return dragOverride;
+  }
+  if (effectStatus?.type !== "can-update-effect") {
+    return;
+  }
+  const propStatus = effectStatus.props[key];
+  if (propStatus?.status !== "static") {
+    return;
+  }
+  return propStatus.codeValue;
+};
+var getFieldsToShow = ({
+  getDragOverrides,
+  propStatuses,
+  nodePath,
+  schema,
+  currentRuntimeValueDotNotation,
+  includeTextContent
+}) => {
+  const { merged: valuesDotNotation } = Internals2.computeEffectiveSchemaValuesDotNotation({
+    schema,
+    currentValue: currentRuntimeValueDotNotation,
+    overrideValues: getDragOverrides(nodePath),
+    propStatus: Internals2.getPropStatusesCtx(propStatuses, nodePath),
+    frame: null
+  });
+  const activeSchema = Internals2.flattenActiveSchema(schema, (key) => valuesDotNotation[key]);
+  const borderRadiusFieldKeysToShow = getBorderRadiusFieldKeysToShow({
+    activeSchema,
+    propStatuses,
+    nodePath
+  });
+  const fields = Object.entries(activeSchema).map(([key, fieldSchema]) => {
+    if (BORDER_RADIUS_FIELD_KEYS.has(key) && borderRadiusFieldKeysToShow !== null && !borderRadiusFieldKeysToShow.has(key)) {
+      return null;
+    }
+    if (!isTimelineSchemaFieldSupported(fieldSchema)) {
+      return null;
+    }
+    const typeName = fieldSchema.type;
+    if (fieldSchema.type === "number" && fieldSchema.hiddenFromList) {
+      return null;
+    }
+    if (fieldSchema.type === "text-content" && !includeTextContent) {
+      return null;
+    }
+    if (key === "hidden") {
+      return null;
+    }
+    return {
+      kind: "sequence-field",
+      key,
+      description: fieldSchema.description,
+      typeName,
+      rowHeight: getSchemaFieldRowHeight({
+        fieldSchema,
+        value: valuesDotNotation[key]
+      }),
+      fieldSchema,
+      group: getSchemaFieldGroup(key)
+    };
+  }).filter(NoReactInternals2.truthy);
+  return sortSchemaFields(fields);
+};
+var getEffectFieldsToShow = ({
+  effect,
+  effectIndex,
+  nodePath,
+  propStatuses,
+  getEffectDragOverrides
+}) => {
+  const effectStatus = nodePath === null ? null : Internals2.getEffectPropStatusesCtx({
+    propStatuses,
+    nodePath,
+    effectIndex
+  });
+  const dragOverrides = nodePath === null ? {} : getEffectDragOverrides(nodePath, effectIndex);
+  const activeSchema = Internals2.flattenActiveSchema(effect.schema, (key) => {
+    return getEffectFieldValue({ key, dragOverrides, effectStatus });
+  });
+  const fields = Object.entries(activeSchema).map(([key, fieldSchema]) => {
+    if (!isTimelineSchemaFieldSupported(fieldSchema)) {
+      return null;
+    }
+    const typeName = fieldSchema.type;
+    if (fieldSchema.type === "number" && fieldSchema.hiddenFromList) {
+      return null;
+    }
+    if (key === "disabled") {
+      return null;
+    }
+    return {
+      kind: "effect-field",
+      key,
+      description: fieldSchema.description,
+      typeName,
+      rowHeight: getSchemaFieldRowHeight({
+        fieldSchema,
+        value: getEffectFieldValue({ key, dragOverrides, effectStatus })
+      }),
+      fieldSchema,
+      effectSchema: effect.schema,
+      effectIndex,
+      group: getSchemaFieldGroup(key)
+    };
+  }).filter(NoReactInternals2.truthy);
+  return sortSchemaFields(fields);
+};
+// src/stringify-default-props.ts
+import { NoReactInternals as NoReactInternals3 } from "remotion/no-react";
+function replacerWithPath(replacer) {
+  const m = new Map;
+  return function(field, value) {
+    const path = [m.get(this), field].flat(1);
+    if (value === Object(value)) {
+      m.set(value, path);
+    }
+    return replacer.call(this, field, value, path.filter((item) => typeof item !== "undefined" && item !== ""));
+  };
+}
+var doesMatchPath = (path1, enumPaths) => {
+  return enumPaths.some((p) => path1.length === p.length && path1.every((item, index) => {
+    if (p[index] === "[]" && !Number.isNaN(Number(item))) {
+      return true;
+    }
+    if (p[index] === "{}" && typeof item === "string") {
+      return true;
+    }
+    return item === p[index];
+  }));
+};
+var stringifyDefaultProps = ({
+  props,
+  enumPaths
+}) => {
+  return JSON.stringify(props, replacerWithPath(function(key, value, path) {
+    const item = this[key];
+    if (typeof item === "string" && doesMatchPath(path, enumPaths)) {
+      return `${item}__ADD_AS_CONST__`;
+    }
+    if (doesMatchPath(path, enumPaths)) {
+      return `__REMOVEQUOTE__${JSON.stringify(item)}__ADD_AS_LITERAL_CONST__`;
+    }
+    if (typeof item === "string" && item.startsWith(NoReactInternals3.FILE_TOKEN)) {
+      return `__REMOVEQUOTE____WRAP_IN_STATIC_FILE_START__${decodeURIComponent(item.replace(NoReactInternals3.FILE_TOKEN, ""))}__WRAP_IN_STATIC_FILE_END____REMOVEQUOTE__`;
+    }
+    if (typeof item === "string" && item.startsWith(NoReactInternals3.DATE_TOKEN)) {
+      return `__REMOVEQUOTE____WRAP_IN_DATE_START__${decodeURIComponent(item.replace(NoReactInternals3.DATE_TOKEN, ""))}__WRAP_IN_DATE_END____REMOVEQUOTE__`;
+    }
+    return value;
+  })).replace(/"__REMOVEQUOTE__/g, "").replace(/__REMOVEQUOTE__"/g, "").replace(/__ADD_AS_CONST__"/g, '" as const').replace(/__ADD_AS_LITERAL_CONST__"/g, " as const").replace(/__WRAP_IN_STATIC_FILE_START__/g, 'staticFile("').replace(/__WRAP_IN_STATIC_FILE_END__/g, '")').replace(/__WRAP_IN_DATE_START__/g, 'new Date("').replace(/__WRAP_IN_DATE_END__/g, '")');
+};
+// src/studio-entry-points.ts
+var getStudioEntryPoints = ({
+  fastRefreshRuntime,
+  environmentSetup,
+  sequenceStackTraces,
+  userDefinedComponent,
+  reactShim,
+  studioRenderEntry
+}) => [
+  fastRefreshRuntime,
+  environmentSetup,
+  sequenceStackTraces,
+  userDefinedComponent,
+  reactShim,
+  studioRenderEntry
+].filter(Boolean);
+// src/studio-html.ts
+import { Internals as Internals3, VERSION as VERSION2 } from "remotion";
+var studioHtml = ({
+  publicPath,
+  editorName,
+  inputProps,
+  envVariables,
+  staticHash,
+  remotionRoot,
+  studioServerCommand,
+  renderQueue,
+  completedClientRenders,
+  numberOfAudioTags,
+  publicFiles,
+  includeFavicon,
+  title,
+  renderDefaults,
+  publicFolderExists,
+  fileSystemPlatform,
+  gitSource,
+  projectName,
+  installedDependencies,
+  packageManager,
+  audioLatencyHint,
+  sampleRate,
+  logLevel,
+  mode,
+  bundleScriptUrl,
+  readOnlyStudio,
+  studioRuntimeConfig
+}) => {
+  const scriptUrl = bundleScriptUrl ?? `${publicPath}bundle.js`;
+  const isRelativeBundle = mode === "bundle" && publicPath === "./";
+  const staticBaseValue = isRelativeBundle ? `new URL(${JSON.stringify(staticHash)}, window.location.href).pathname` : JSON.stringify(staticHash);
+  const staticFilesValue = isRelativeBundle ? `${JSON.stringify(publicFiles)}.map((file) => ({...file, src: new URL(file.src, window.location.href).pathname}))` : JSON.stringify(publicFiles);
+  const publicFolderExistsValue = isRelativeBundle && publicFolderExists ? `new URL(${JSON.stringify(publicFolderExists)}, window.location.href).pathname` : JSON.stringify(publicFolderExists);
+  return `
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		${includeFavicon ? `<link id="__remotion_favicon" rel="icon" type="image/png" href="${publicPath}favicon.ico" />` : ""}
+		<title>${title}</title>
+	</head>
+	<body>
+		<script>window.remotion_numberOfAudioTags = ${numberOfAudioTags};</script>
+		<script>window.remotion_audioLatencyHint = "${audioLatencyHint}";</script>
+		<script>window.remotion_sampleRate = ${sampleRate};</script>
+		<script>window.remotion_previewSampleRate = ${sampleRate};</script>
+		${mode === "dev" ? `<script>window.remotion_logLevel = "${logLevel}";</script>` : ""}
+		<script>window.remotion_staticBase = ${staticBaseValue};</script>
+		${editorName ? `<script>window.remotion_editorName = "${editorName}";</script>` : "<script>window.remotion_editorName = null;</script>"}
+		<script>window.remotion_projectName = ${JSON.stringify(projectName)};</script>
+		<script>window.remotion_publicPath = ${JSON.stringify(publicPath)};</script>
+		<script>window.remotion_audioEnabled = true;</script>
+		<script>window.remotion_videoEnabled = true;</script>
+		<script>window.remotion_studioConfig = ${JSON.stringify(studioRuntimeConfig ?? null)};</script>
+		<script>window.remotion_renderDefaults = ${JSON.stringify(renderDefaults)};</script>
+		<script>window.remotion_cwd = ${JSON.stringify(remotionRoot)};</script>
+		<script>window.remotion_fileSystemPlatform = ${JSON.stringify(fileSystemPlatform)};</script>
+		<script>window.remotion_studioServerCommand = ${studioServerCommand ? JSON.stringify(studioServerCommand) : "null"};</script>
+		${inputProps ? `<script>window.remotion_inputProps = ${JSON.stringify(JSON.stringify(inputProps))};</script>` : ""}
+		${renderQueue ? `<script>window.remotion_initialRenderQueue = ${JSON.stringify(renderQueue)};</script>` : ""}
+		${completedClientRenders ? `<script>window.remotion_initialClientRenders = ${JSON.stringify(completedClientRenders)};</script>` : ""}
+		${envVariables ? `<script>window.process = {env: ${JSON.stringify(envVariables)}};</script>` : ""}
+		${gitSource ? `<script>window.remotion_gitSource = ${JSON.stringify(gitSource)};</script>` : ""}
+		${mode === "dev" ? `
+		<script>window.remotion_isStudio = true;</script>
+		<script>window.remotion_isReadOnlyStudio = ${readOnlyStudio ? "true" : "false"};</script>`.trimStart() : ""}
+		<script>window.remotion_staticFiles = ${staticFilesValue}</script>
+		<script>window.remotion_installedPackages = ${JSON.stringify(installedDependencies)}</script>
+		<script>window.remotion_packageManager = ${JSON.stringify(packageManager)}</script>
+		<script>window.remotion_publicFolderExists = ${publicFolderExistsValue};</script>
+		<script>
+				// Increment this value when the generated bundle format or behavior changes
+				// in a backwards-incompatible way. It is not the Remotion package version
+				// and should not be bumped for every generated HTML change.
+				// Keep it synchronized with requiredVersion in
+				// packages/renderer/src/set-props-and-env.ts by incrementing both values.
+				window.siteVersion = '11';
+				window.remotion_version = '${VERSION2}';
+		</script>
+		
+		<div id="video-container"></div>
+		<div id="${Internals3.REMOTION_STUDIO_CONTAINER_ELEMENT}"></div>
+		<div id="remotion-error-overlay"></div>
+		<div id="server-disconnected-overlay"></div>
+		<div id="menuportal-0"></div>
+		<div id="menuportal-1"></div>
+		<div id="menuportal-2"></div>
+		<div id="menuportal-3"></div>
+		<div id="menuportal-4"></div>
+		<div id="menuportal-5"></div>
+		<script src="${scriptUrl}"></script>
+	</body>
+</html>
+`.trim();
+};
+// src/optimistic-add-keyframe.ts
+var getEasingIndexToDuplicate = ({
+  insertedKeyframeIndex,
+  easingLength,
+  keyframeCount
+}) => {
+  const isSplittingExistingSegment = insertedKeyframeIndex > 0 && insertedKeyframeIndex < keyframeCount - 1;
+  if (!isSplittingExistingSegment || easingLength === 0) {
+    return null;
+  }
+  return Math.min(insertedKeyframeIndex - 1, easingLength - 1);
+};
+var addKeyframeToPropStatus = ({
+  status,
+  fieldKey,
+  frame,
+  value,
+  schema
+}) => {
+  if (status.status === "keyframed") {
+    const existingIndex = status.keyframes.findIndex((kf) => kf.frame === frame);
+    if (existingIndex !== -1) {
+      const updatedKeyframes = status.keyframes.map((keyframe, index) => index === existingIndex ? { frame, value } : keyframe);
+      return {
+        ...status,
+        keyframes: updatedKeyframes
+      };
+    }
+    const keyframes = [...status.keyframes, { frame, value }].sort((first, second) => first.frame - second.frame);
+    const easing = [...status.easing];
+    const insertedKeyframeIndex = keyframes.findIndex((keyframe) => keyframe.frame === frame);
+    const easingIndexToDuplicate = getEasingIndexToDuplicate({
+      insertedKeyframeIndex,
+      easingLength: easing.length,
+      keyframeCount: keyframes.length
+    });
+    const easingToDuplicate = easingIndexToDuplicate === null ? LINEAR_KEYFRAME_EASING : easing[easingIndexToDuplicate];
+    easing.splice(insertedKeyframeIndex, 0, easingToDuplicate);
+    while (easing.length < keyframes.length - 1) {
+      easing.push(LINEAR_KEYFRAME_EASING);
+    }
+    return {
+      ...status,
+      keyframes,
+      easing
+    };
+  }
+  if (status.status === "static") {
+    const staticValue = status.codeValue ?? value;
+    return {
+      status: "keyframed",
+      interpolationFunction: getKeyframeInterpolationFunction({
+        schema,
+        key: fieldKey,
+        staticValue,
+        newValue: value
+      }),
+      keyframes: [{ frame, value }],
+      easing: [],
+      clamping: { left: "clamp", right: "clamp" },
+      posterize: undefined,
+      output: undefined
+    };
+  }
+  return status;
+};
+var findFieldInSchema2 = (schema, key) => {
+  if (key in schema) {
+    return schema[key];
+  }
+  for (const field of Object.values(schema)) {
+    if (field.type !== "enum") {
+      continue;
+    }
+    for (const variant of Object.values(field.variants)) {
+      const found = findFieldInSchema2(variant, key);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return;
+};
+var getMissingPropStatus = ({
+  schema,
+  fieldKey
+}) => {
+  const field = schema ? findFieldInSchema2(schema, fieldKey) : undefined;
+  if (field && field.type !== "hidden" && field.default !== undefined) {
+    return {
+      status: "static",
+      codeValue: field.default
+    };
+  }
+  return {
+    status: "static",
+    codeValue: undefined
+  };
+};
+var optimisticAddSequenceKeyframe = ({
+  previous,
+  fieldKey,
+  frame,
+  value,
+  schema
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  if (!isSchemaFieldKeyframable({ schema: schema ?? null, key: fieldKey })) {
+    return previous;
+  }
+  const status = previous.props[fieldKey] ?? getMissingPropStatus({ schema: schema ?? null, fieldKey });
+  return {
+    ...previous,
+    props: {
+      ...previous.props,
+      [fieldKey]: addKeyframeToPropStatus({
+        status,
+        fieldKey,
+        frame,
+        value,
+        schema: schema ?? null
+      })
+    }
+  };
+};
+var optimisticAddEffectKeyframe = ({
+  previous,
+  effectIndex,
+  fieldKey,
+  frame,
+  value,
+  schema
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  if (!isSchemaFieldKeyframable({ schema: schema ?? null, key: fieldKey })) {
+    return previous;
+  }
+  const targetIndex = previous.effects.findIndex((e) => e.effectIndex === effectIndex);
+  if (targetIndex === -1) {
+    return previous;
+  }
+  const target = previous.effects[targetIndex];
+  if (!target.canUpdate) {
+    return previous;
+  }
+  const status = target.props[fieldKey] ?? getMissingPropStatus({ schema: schema ?? null, fieldKey });
+  const updatedEffect = {
+    ...target,
+    props: {
+      ...target.props,
+      [fieldKey]: addKeyframeToPropStatus({
+        status,
+        fieldKey,
+        frame,
+        value,
+        schema: schema ?? null
+      })
+    }
+  };
+  const effects = [...previous.effects];
+  effects[targetIndex] = updatedEffect;
+  return {
+    ...previous,
+    effects
+  };
+};
+// src/optimistic-delete-keyframe.ts
+var getEasingIndexToRemove = ({
+  removedKeyframeIndex,
+  keyframeCountBeforeRemoval
+}) => {
+  if (removedKeyframeIndex === 0) {
+    return 0;
+  }
+  if (removedKeyframeIndex === keyframeCountBeforeRemoval - 1) {
+    return removedKeyframeIndex - 1;
+  }
+  return removedKeyframeIndex;
+};
+var removeKeyframeFromPropStatus = ({
+  status,
+  frame,
+  valueWhenLastKeyframeDeleted
+}) => {
+  if (status.status !== "keyframed") {
+    return status;
+  }
+  const index = status.keyframes.findIndex((kf) => kf.frame === frame);
+  if (index === -1) {
+    return status;
+  }
+  const keyframes = status.keyframes.filter((_, i) => i !== index);
+  if (keyframes.length === 0) {
+    return {
+      status: "static",
+      codeValue: valueWhenLastKeyframeDeleted === null ? status.keyframes[index].value : valueWhenLastKeyframeDeleted
+    };
+  }
+  const easing = [...status.easing];
+  if (easing.length > 0) {
+    const easingIndexToRemove = getEasingIndexToRemove({
+      removedKeyframeIndex: index,
+      keyframeCountBeforeRemoval: status.keyframes.length
+    });
+    easing.splice(easingIndexToRemove, 1);
+  }
+  return {
+    ...status,
+    keyframes,
+    easing
+  };
+};
+var optimisticDeleteSequenceKeyframe = ({
+  previous,
+  fieldKey,
+  frame,
+  valueWhenLastKeyframeDeleted
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const status = previous.props[fieldKey];
+  if (!status) {
+    return previous;
+  }
+  return {
+    ...previous,
+    props: {
+      ...previous.props,
+      [fieldKey]: removeKeyframeFromPropStatus({
+        status,
+        frame,
+        valueWhenLastKeyframeDeleted: valueWhenLastKeyframeDeleted ?? null
+      })
+    }
+  };
+};
+var optimisticDeleteSequenceKeyframes = ({
+  previous,
+  keyframes
+}) => {
+  return keyframes.reduce((current, keyframe) => optimisticDeleteSequenceKeyframe({
+    previous: current,
+    fieldKey: keyframe.fieldKey,
+    frame: keyframe.frame,
+    valueWhenLastKeyframeDeleted: keyframe.valueWhenLastKeyframeDeleted
+  }), previous);
+};
+var optimisticDeleteEffectKeyframe = ({
+  previous,
+  effectIndex,
+  fieldKey,
+  frame,
+  valueWhenLastKeyframeDeleted
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const targetIndex = previous.effects.findIndex((e) => e.effectIndex === effectIndex);
+  if (targetIndex === -1) {
+    return previous;
+  }
+  const target = previous.effects[targetIndex];
+  if (!target.canUpdate) {
+    return previous;
+  }
+  const status = target.props[fieldKey];
+  if (!status) {
+    return previous;
+  }
+  const updatedEffect = {
+    ...target,
+    props: {
+      ...target.props,
+      [fieldKey]: removeKeyframeFromPropStatus({
+        status,
+        frame,
+        valueWhenLastKeyframeDeleted: valueWhenLastKeyframeDeleted ?? null
+      })
+    }
+  };
+  const effects = [...previous.effects];
+  effects[targetIndex] = updatedEffect;
+  return {
+    ...previous,
+    effects
+  };
+};
+var optimisticDeleteEffectKeyframes = ({
+  previous,
+  keyframes
+}) => {
+  return keyframes.reduce((current, keyframe) => optimisticDeleteEffectKeyframe({
+    previous: current,
+    effectIndex: keyframe.effectIndex,
+    fieldKey: keyframe.fieldKey,
+    frame: keyframe.frame,
+    valueWhenLastKeyframeDeleted: keyframe.valueWhenLastKeyframeDeleted
+  }), previous);
+};
+// src/optimistic-move-keyframe.ts
+var getMoveMap = (moves) => {
+  const moveMap = new Map;
+  for (const move of moves) {
+    if (move.fromFrame === move.toFrame) {
+      continue;
+    }
+    if (moveMap.has(move.fromFrame)) {
+      return null;
+    }
+    moveMap.set(move.fromFrame, move.toFrame);
+  }
+  return moveMap;
+};
+var getMovedKeyframes = ({
+  status,
+  moves
+}) => {
+  if (status.status !== "keyframed") {
+    return null;
+  }
+  const moveMap = getMoveMap(moves);
+  if (moveMap === null) {
+    return null;
+  }
+  if (moveMap.size === 0) {
+    return { keyframes: status.keyframes, removedKeyframeIndexes: [] };
+  }
+  const frames = new Set(status.keyframes.map((keyframe) => keyframe.frame));
+  for (const fromFrame of moveMap.keys()) {
+    if (!frames.has(fromFrame)) {
+      return null;
+    }
+  }
+  const movedFromFrames = new Set(moveMap.keys());
+  const movedToFrames = new Set(moveMap.values());
+  const removedKeyframeIndexes = [];
+  const nextKeyframes = status.keyframes.flatMap((keyframe, index) => {
+    const movedFrame = moveMap.get(keyframe.frame);
+    if (movedFrame !== undefined) {
+      return [{ ...keyframe, frame: movedFrame }];
+    }
+    if (movedToFrames.has(keyframe.frame) && !movedFromFrames.has(keyframe.frame)) {
+      removedKeyframeIndexes.push(index);
+      return [];
+    }
+    return [keyframe];
+  });
+  const nextFrames = new Set;
+  for (const keyframe of nextKeyframes) {
+    if (nextFrames.has(keyframe.frame)) {
+      return null;
+    }
+    nextFrames.add(keyframe.frame);
+  }
+  return {
+    keyframes: nextKeyframes.sort((a, b) => a.frame - b.frame),
+    removedKeyframeIndexes
+  };
+};
+var removeEasingForRemovedKeyframes = ({
+  easing,
+  removedKeyframeIndexes
+}) => {
+  const nextEasing = [...easing];
+  for (const removedKeyframeIndex of [...removedKeyframeIndexes].sort((a, b) => b - a)) {
+    if (nextEasing.length === 0) {
+      break;
+    }
+    const easingIndexToRemove = removedKeyframeIndex === 0 ? 0 : removedKeyframeIndex - 1;
+    nextEasing.splice(easingIndexToRemove, 1);
+  }
+  return nextEasing;
+};
+var canMoveKeyframesWithoutCollisions = ({
+  status,
+  moves
+}) => {
+  return getMovedKeyframes({ status, moves }) !== null;
+};
+var moveKeyframesInPropStatus = ({
+  status,
+  moves
+}) => {
+  if (status.status !== "keyframed") {
+    return status;
+  }
+  const moved = getMovedKeyframes({ status, moves });
+  if (moved === null || moved.removedKeyframeIndexes.length === 0 && moved.keyframes === status.keyframes) {
+    return status;
+  }
+  const easing = removeEasingForRemovedKeyframes({
+    easing: status.easing,
+    removedKeyframeIndexes: moved.removedKeyframeIndexes
+  });
+  return {
+    ...status,
+    keyframes: moved.keyframes,
+    easing
+  };
+};
+var optimisticMoveSequenceKeyframes = ({
+  previous,
+  keyframes
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const movesByField = new Map;
+  for (const keyframe of keyframes) {
+    const moves = movesByField.get(keyframe.fieldKey) ?? [];
+    moves.push(keyframe);
+    movesByField.set(keyframe.fieldKey, moves);
+  }
+  const props = { ...previous.props };
+  for (const [fieldKey, moves] of movesByField) {
+    const status = props[fieldKey];
+    if (!status) {
+      continue;
+    }
+    props[fieldKey] = moveKeyframesInPropStatus({ status, moves });
+  }
+  return {
+    ...previous,
+    props
+  };
+};
+var optimisticMoveEffectKeyframes = ({
+  previous,
+  keyframes
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const movesByEffect = new Map;
+  for (const keyframe of keyframes) {
+    const moves = movesByEffect.get(keyframe.effectIndex) ?? [];
+    moves.push(keyframe);
+    movesByEffect.set(keyframe.effectIndex, moves);
+  }
+  const effects = previous.effects.map((effect) => {
+    if (!effect.canUpdate) {
+      return effect;
+    }
+    const movesForEffect = movesByEffect.get(effect.effectIndex);
+    if (!movesForEffect) {
+      return effect;
+    }
+    const props = { ...effect.props };
+    const movesByField = new Map;
+    for (const move of movesForEffect) {
+      const moves = movesByField.get(move.fieldKey) ?? [];
+      moves.push(move);
+      movesByField.set(move.fieldKey, moves);
+    }
+    for (const [fieldKey, moves] of movesByField) {
+      const status = props[fieldKey];
+      if (!status) {
+        continue;
+      }
+      props[fieldKey] = moveKeyframesInPropStatus({ status, moves });
+    }
+    return {
+      ...effect,
+      props
+    };
+  });
+  return {
+    ...previous,
+    effects
+  };
+};
+// src/optimistic-update-for-effect-prop-statuses.ts
+import { NoReactInternals as NoReactInternals4 } from "remotion/no-react";
+var optimisticUpdateForEffectPropStatuses = ({
+  previous,
+  effectIndex,
+  fieldKey,
+  value,
+  schema
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const targetIndex = previous.effects.findIndex((e) => e.effectIndex === effectIndex);
+  if (targetIndex === -1) {
+    return previous;
+  }
+  const target = previous.effects[targetIndex];
+  if (!target.canUpdate) {
+    return previous;
+  }
+  const props = {
+    ...target.props,
+    [fieldKey]: { status: "static", codeValue: value }
+  };
+  if (schema[fieldKey]?.type === "enum") {
+    const propsToDelete = NoReactInternals4.findPropsToDelete({
+      schema,
+      key: fieldKey,
+      value
+    });
+    for (const propToDelete of propsToDelete) {
+      delete props[propToDelete];
+    }
+  }
+  const updatedEffect = {
+    ...target,
+    props
+  };
+  const effects = [...previous.effects];
+  effects[targetIndex] = updatedEffect;
+  return {
+    ...previous,
+    effects
+  };
+};
+// src/optimistic-update-for-prop-statuses.ts
+import { NoReactInternals as NoReactInternals5 } from "remotion/no-react";
+var optimisticUpdateForPropStatuses = ({
+  previous,
+  fieldKey,
+  value,
+  defaultValue,
+  schema
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const serializedValue = JSON.stringify(value);
+  const optimisticValue = defaultValue !== null && defaultValue === serializedValue ? undefined : value;
+  const props = {
+    ...previous.props,
+    [fieldKey]: { status: "static", codeValue: optimisticValue }
+  };
+  if (schema[fieldKey]?.type === "enum") {
+    const propsToDelete = NoReactInternals5.findPropsToDelete({
+      schema,
+      key: fieldKey,
+      value
+    });
+    for (const propToDelete of propsToDelete) {
+      delete props[propToDelete];
+    }
+  }
+  return {
+    canUpdate: true,
+    props,
+    effects: previous.effects
+  };
+};
+// src/optimistic-update-keyframe-settings.ts
+var updateEasing = ({
+  easing,
+  segmentCount,
+  segmentIndex,
+  value
+}) => {
+  if (!Number.isInteger(segmentIndex) || segmentIndex < 0 || segmentIndex >= segmentCount) {
+    throw new Error("Cannot update easing: segment index out of range");
+  }
+  const nextEasing = Array.from({ length: segmentCount }, (_, index) => {
+    return easing[index] ?? LINEAR_KEYFRAME_EASING;
+  });
+  nextEasing[segmentIndex] = value;
+  return nextEasing;
+};
+var applySettingsToStatus = (status, settings) => {
+  if (!status || status.status !== "keyframed") {
+    throw new Error("Expected keyframed status");
+  }
+  return {
+    ...status,
+    ...settings.type === "settings" && settings.clamping ? { clamping: settings.clamping } : {},
+    ...settings.type === "settings" ? { posterize: settings.posterize } : {},
+    ...settings.type === "settings" ? { output: settings.output } : {},
+    ...settings.type === "easing" ? {
+      easing: updateEasing({
+        easing: status.easing,
+        segmentCount: Math.max(0, status.keyframes.length - 1),
+        segmentIndex: settings.segmentIndex,
+        value: settings.easing
+      })
+    } : {}
+  };
+};
+var optimisticUpdateSequenceKeyframeSettings = ({
+  previous,
+  fieldKey,
+  settings
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const status = previous.props[fieldKey];
+  if (!status || status.status !== "keyframed") {
+    return previous;
+  }
+  return {
+    ...previous,
+    props: {
+      ...previous.props,
+      [fieldKey]: applySettingsToStatus(status, settings)
+    }
+  };
+};
+var optimisticUpdateEffectKeyframeSettings = ({
+  previous,
+  effectIndex,
+  fieldKey,
+  settings
+}) => {
+  if (!previous.canUpdate) {
+    return previous;
+  }
+  const targetIndex = previous.effects.findIndex((effect) => effect.effectIndex === effectIndex);
+  if (targetIndex === -1) {
+    return previous;
+  }
+  const target = previous.effects[targetIndex];
+  if (!target.canUpdate) {
+    return previous;
+  }
+  const status = target.props[fieldKey];
+  if (!status || status.status !== "keyframed") {
+    return previous;
+  }
+  const effects = [...previous.effects];
+  effects[targetIndex] = {
+    ...target,
+    props: {
+      ...target.props,
+      [fieldKey]: applySettingsToStatus(status, settings)
+    }
+  };
+  return {
+    ...previous,
+    effects
+  };
+};
+// src/stringify-sequence-subscription-key.ts
+var stringifySequenceSubscriptionKey = (key) => {
+  return `${key.absolutePath}:${JSON.stringify(key.nodePath)}:${key.sequenceKeys.join("\x00")}:${key.effectKeys.map((keys) => keys.join("\x00")).join("\x00\x00")}`;
+};
+var stringifySequenceExpandedRowKey = (key) => {
+  return `${key.absolutePath}:${JSON.stringify(key.nodePath)}:${key.sequenceKeys.join("\x00")}`;
+};
+// src/url.ts
+var isUrl = (value) => {
+  try {
+    const parsed = new URL(value);
+    return parsed.href.length > 0;
+  } catch {
+    return false;
+  }
+};
+export {
+  studioHtml,
+  stripAnsi,
+  stringifySequenceSubscriptionKey,
+  stringifySequenceExpandedRowKey,
+  stringifyDefaultProps,
+  splitAnsi,
+  parseSpringEasingConfig,
+  parseKeyframeClipboardDataResult,
+  parseKeyframeClipboardData,
+  parseEffectPropClipboardDataResult,
+  parseEffectPropClipboardData,
+  parseEffectClipboardDataResult,
+  parseEffectClipboardData,
+  parseEasingClipboardDataResult,
+  parseEasingClipboardData,
+  packages,
+  optimisticUpdateSequenceKeyframeSettings,
+  optimisticUpdateForPropStatuses,
+  optimisticUpdateForEffectPropStatuses,
+  optimisticUpdateEffectKeyframeSettings,
+  optimisticMoveSequenceKeyframes,
+  optimisticMoveEffectKeyframes,
+  optimisticDeleteSequenceKeyframes,
+  optimisticDeleteSequenceKeyframe,
+  optimisticDeleteEffectKeyframes,
+  optimisticDeleteEffectKeyframe,
+  optimisticAddSequenceKeyframe,
+  optimisticAddEffectKeyframe,
+  moveKeyframesInPropStatus,
+  keyframeInterpolationFunctions,
+  isValidPackageName,
+  isUrl,
+  isSchemaFieldKeyframable,
+  isKeyframeInterpolationFunction,
+  isKeyframeClipboardFieldType,
+  isInteractivitySchemaFieldKeyframable,
+  isImageFileType,
+  installableMap,
+  hotMiddlewareOptions,
+  getStylePropertyLonghandKeys,
+  getStudioEntryPoints,
+  getSchemaFieldGroup,
+  getRequiredPackageForInsertableElement,
+  getRequiredPackageForEffectImportPath,
+  getProjectName,
+  getPolyKeyframeEasing,
+  getOutKeyframeEasing,
+  getLocationFromBuildError,
+  getKeyframeInterpolationFunctionForSchemaField,
+  getKeyframeInterpolationFunction,
+  getFieldsToShow,
+  getEffectPreviewSource,
+  getEffectPreviewAlt,
+  getEffectFieldsToShow,
+  getEffectDocumentationPath,
+  getEffectDocumentationLink,
+  getEffectCatalogCategories,
+  getDefaultOutLocation,
+  getBackKeyframeEasing,
+  getAssetSchemaKeys,
+  getAllSchemaKeys,
+  formatBytes,
+  extraPackages,
+  detectFileType,
+  descriptions,
+  compositionDragDataToSymbolicatedStack,
+  canMoveKeyframesWithoutCollisions,
+  canEditEasingForInterpolationFunction,
+  apiDocs,
+  SCHEMA_FIELD_ROW_HEIGHT,
+  SCHEMA_FIELD_GROUPS,
+  QUAD_KEYFRAME_EASING,
+  LINEAR_KEYFRAME_EASING,
+  KEYFRAME_EASING_PRESETS,
+  EFFECT_CATALOG,
+  EASE_KEYFRAME_EASING,
+  DEFAULT_TIMELINE_TRACKS,
+  DEFAULT_SPRING_EASING,
+  DEFAULT_BUFFER_STATE_DELAY_IN_MILLISECONDS,
+  CUBIC_KEYFRAME_EASING,
+  BORDER_RADIUS_SHORTHAND_KEY,
+  BORDER_RADIUS_LONGHAND_KEYS
+};