@remotion/effects 4.0.539 → 4.0.540

package/dist/esm/index.mjs

@@ -1,4055 +1,51 @@
-// src/checkerboard.ts
-import { Internals } from "remotion";
-
-// src/validate-effect-param.ts
-var assertEffectParamsObject = (params, effectLabel) => {
-  if (params === null || typeof params !== "object") {
-    throw new TypeError(`${effectLabel} effect requires a parameters object, but got ${JSON.stringify(params)}`);
-  }
-};
-var assertRequiredFiniteNumber = (value, name) => {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new TypeError(`"${name}" must be a finite number, but got ${JSON.stringify(value)}`);
-  }
-};
-var assertRequiredColor = (value, name) => {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`"${name}" must be a non-empty string, but got ${JSON.stringify(value)}`);
-  }
-};
-var assertOptionalColor = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  assertRequiredColor(value, name);
-};
-var assertOptionalBoolean = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "boolean") {
-    throw new TypeError(`"${name}" must be a boolean, but got ${JSON.stringify(value)}`);
-  }
-};
-
-// src/color-utils.ts
-var DEFAULT_AMOUNT = 1;
-var DEFAULT_BRIGHTNESS_AMOUNT = 0;
-var DEFAULT_HUE_DEGREES = 0;
-var colorAmountSchema = {
-  type: "number",
-  min: 0,
-  max: 1,
-  step: 0.01,
-  default: DEFAULT_AMOUNT,
-  description: "Amount",
-  hiddenFromList: false
-};
-var colorMultiplierSchema = {
-  type: "number",
-  min: 0,
-  step: 0.01,
-  default: DEFAULT_AMOUNT,
-  description: "Amount",
-  hiddenFromList: false
-};
-var brightnessAmountSchema = {
-  type: "number",
-  min: -1,
-  max: 1,
-  step: 0.01,
-  default: DEFAULT_BRIGHTNESS_AMOUNT,
-  description: "Amount",
-  hiddenFromList: false
-};
-var hueDegreesSchema = {
-  type: "rotation-degrees",
-  step: 1,
-  default: DEFAULT_HUE_DEGREES,
-  description: "Degrees"
-};
-var assertOptionalFiniteNumber = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  assertRequiredFiniteNumber(value, name);
-};
-var validateUnitInterval = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be >= 0, but got ${JSON.stringify(value)}`);
-  }
-  if (value > 1) {
-    throw new TypeError(`"${name}" must be <= 1, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateNonNegative = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be >= 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateSignedUnitInterval = (value, name) => {
-  if (value < -1) {
-    throw new TypeError(`"${name}" must be >= -1, but got ${JSON.stringify(value)}`);
-  }
-  if (value > 1) {
-    throw new TypeError(`"${name}" must be <= 1, but got ${JSON.stringify(value)}`);
-  }
-};
-var clampColorChannel = (value) => {
-  return Math.max(0, Math.min(255, value));
-};
-var parseColorRgba = (ctx, color) => {
-  ctx.clearRect(0, 0, 1, 1);
-  ctx.fillStyle = color;
-  ctx.fillRect(0, 0, 1, 1);
-  const { data } = ctx.getImageData(0, 0, 1, 1);
-  return [data[0], data[1], data[2], data[3]];
-};
-
-// src/checkerboard.ts
-var { createEffect, createWebGL2ContextError } = Internals;
-var DEFAULT_COLORS = ["#dff4ff", "#7cc6ff"];
-var DEFAULT_CELL_SIZE = 80;
-var DEFAULT_GAP = 0;
-var DEFAULT_ANGLE = 0;
-var DEFAULT_OFFSET_X = 0;
-var DEFAULT_OFFSET_Y = 0;
-var DEFAULT_MASK_TO_SOURCE_ALPHA = false;
-var checkerboardSchema = {
-  colors: {
-    type: "array",
-    item: {
-      type: "color"
-    },
-    default: DEFAULT_COLORS,
-    minLength: 2,
-    newItemDefault: "#ff0000",
-    description: "Colors",
-    keyframable: false
-  },
-  cellSize: {
-    type: "number",
-    min: 0.1,
-    max: 800,
-    step: 0.1,
-    default: DEFAULT_CELL_SIZE,
-    description: "Cell size",
-    hiddenFromList: false
-  },
-  gap: {
-    type: "number",
-    min: 0,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_GAP,
-    description: "Gap",
-    hiddenFromList: false
-  },
-  angle: {
-    type: "rotation-degrees",
-    step: 1,
-    default: DEFAULT_ANGLE,
-    description: "Angle"
-  },
-  offsetX: {
-    type: "number",
-    step: 0.1,
-    default: DEFAULT_OFFSET_X,
-    description: "Offset X",
-    hiddenFromList: false
-  },
-  offsetY: {
-    type: "number",
-    step: 0.1,
-    default: DEFAULT_OFFSET_Y,
-    description: "Offset Y",
-    hiddenFromList: false
-  },
-  maskToSourceAlpha: {
-    type: "boolean",
-    default: DEFAULT_MASK_TO_SOURCE_ALPHA,
-    description: "Mask to source alpha"
-  }
-};
-var resolve = (p) => {
-  const cellSize = p.cellSize ?? DEFAULT_CELL_SIZE;
-  const gap = p.gap ?? DEFAULT_GAP;
-  return {
-    colors: p.colors ?? DEFAULT_COLORS,
-    cellSize,
-    spacing: cellSize + gap,
-    angle: p.angle ?? DEFAULT_ANGLE,
-    offsetX: p.offsetX ?? DEFAULT_OFFSET_X,
-    offsetY: p.offsetY ?? DEFAULT_OFFSET_Y,
-    maskToSourceAlpha: p.maskToSourceAlpha ?? DEFAULT_MASK_TO_SOURCE_ALPHA
-  };
-};
-var validatePositive = (value, name) => {
-  if (value <= 0) {
-    throw new TypeError(`"${name}" must be greater than 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateNonNegative2 = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be greater than or equal to 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateColors = (colors) => {
-  if (colors === undefined) {
-    return;
-  }
-  if (!Array.isArray(colors) || colors.length < 2) {
-    throw new TypeError(`"colors" must be an array with at least 2 colors, but got ${JSON.stringify(colors)}`);
-  }
-  for (let i = 0;i < colors.length; i++) {
-    assertRequiredColor(colors[i], `colors[${i}]`);
-  }
-};
-var validateCheckerboardParams = (params) => {
-  assertEffectParamsObject(params, "Checkerboard");
-  validateColors(params.colors);
-  assertOptionalFiniteNumber(params.cellSize, "cellSize");
-  assertOptionalFiniteNumber(params.gap, "gap");
-  assertOptionalFiniteNumber(params.angle, "angle");
-  assertOptionalFiniteNumber(params.offsetX, "offsetX");
-  assertOptionalFiniteNumber(params.offsetY, "offsetY");
-  assertOptionalBoolean(params.maskToSourceAlpha, "maskToSourceAlpha");
-  const cellSize = params.cellSize ?? DEFAULT_CELL_SIZE;
-  const gap = params.gap ?? DEFAULT_GAP;
-  validatePositive(cellSize, "cellSize");
-  validateNonNegative2(gap, "gap");
-};
-var CHECKERBOARD_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var CHECKERBOARD_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform sampler2D uPalette;
-uniform vec2 uResolution;
-uniform float uNumColors;
-uniform float uCellSize;
-uniform float uSpacing;
-uniform float uAngle;
-uniform vec2 uOffset;
-uniform bool uMaskToSourceAlpha;
-
-void main() {
-	vec4 texColor = texture(uSource, vUv);
-	float cellSize = max(uCellSize, 0.001);
-	float spacing = max(uSpacing, 0.001);
-	vec2 centered = vUv * uResolution - uResolution * 0.5;
-	float s = sin(uAngle);
-	float c = cos(uAngle);
-	vec2 rotated = vec2(
-		centered.x * c - centered.y * s,
-		centered.x * s + centered.y * c
-	);
-	vec2 position = rotated + uOffset;
-	vec2 localPosition = mod(position, spacing);
-	if (localPosition.x < 0.0) {
-		localPosition.x += spacing;
-	}
-	if (localPosition.y < 0.0) {
-		localPosition.y += spacing;
-	}
-
-	if (localPosition.x > cellSize || localPosition.y > cellSize) {
-		fragColor = texColor;
-		return;
-	}
-
-	vec2 cell = floor(position / spacing);
-	float colorIndex = mod(cell.x + cell.y, uNumColors);
-	if (colorIndex < 0.0) {
-		colorIndex += uNumColors;
-	}
-
-	float texCoord = (colorIndex + 0.5) / uNumColors;
-	vec4 checkerColor = texture(uPalette, vec2(texCoord, 0.5));
-	float checkerAlpha = checkerColor.a;
-	vec3 premultipliedChecker = checkerColor.rgb * checkerAlpha;
-
-	if (uMaskToSourceAlpha) {
-		fragColor = vec4(
-			premultipliedChecker * texColor.a + texColor.rgb * (1.0 - checkerAlpha),
-			texColor.a
-		);
-		return;
-	}
-
-	fragColor = vec4(
-		premultipliedChecker + texColor.rgb * (1.0 - checkerAlpha),
-		checkerAlpha + texColor.a * (1.0 - checkerAlpha)
-	);
-}
-`;
-var compileShader = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Checkerboard shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Checkerboard program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var createProgram = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram(gl, vs, fs);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  return program;
-};
-var createTexture = (gl, filter) => {
-  const texture = gl.createTexture();
-  if (!texture) {
-    throw new Error("Failed to create WebGL texture");
-  }
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  return texture;
-};
-var setupCheckerboard = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError("checkerboard effect");
-  }
-  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-  const program = createProgram(gl, CHECKERBOARD_VS, CHECKERBOARD_FS);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  const aPos = gl.getAttribLocation(program, "aPos");
-  const aUv = gl.getAttribLocation(program, "aUv");
-  gl.enableVertexAttribArray(aPos);
-  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(aUv);
-  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const colorCanvas = document.createElement("canvas");
-  colorCanvas.width = 1;
-  colorCanvas.height = 1;
-  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-  if (!colorCtx) {
-    throw new Error("Failed to acquire 2D context for color parsing");
-  }
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    sourceTexture: createTexture(gl, gl.LINEAR),
-    paletteTexture: createTexture(gl, gl.NEAREST),
-    colorCtx,
-    uniforms: {
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uPalette: gl.getUniformLocation(program, "uPalette"),
-      uResolution: gl.getUniformLocation(program, "uResolution"),
-      uNumColors: gl.getUniformLocation(program, "uNumColors"),
-      uCellSize: gl.getUniformLocation(program, "uCellSize"),
-      uSpacing: gl.getUniformLocation(program, "uSpacing"),
-      uAngle: gl.getUniformLocation(program, "uAngle"),
-      uOffset: gl.getUniformLocation(program, "uOffset"),
-      uMaskToSourceAlpha: gl.getUniformLocation(program, "uMaskToSourceAlpha")
-    },
-    cachedPaletteKey: "",
-    palettePixelData: new Uint8Array(0)
-  };
-};
-var updatePalette = (state, colors) => {
-  const paletteKey = colors.join("|");
-  const paletteDirty = state.cachedPaletteKey !== paletteKey;
-  if (!paletteDirty) {
-    return false;
-  }
-  state.cachedPaletteKey = paletteKey;
-  const len = colors.length * 4;
-  if (state.palettePixelData.length !== len) {
-    state.palettePixelData = new Uint8Array(len);
-  }
-  const { palettePixelData } = state;
-  for (let i = 0;i < colors.length; i++) {
-    const color = parseColorRgba(state.colorCtx, colors[i]);
-    palettePixelData[i * 4] = color[0];
-    palettePixelData[i * 4 + 1] = color[1];
-    palettePixelData[i * 4 + 2] = color[2];
-    palettePixelData[i * 4 + 3] = color[3];
-  }
-  return true;
-};
-var checkerboard = createEffect({
-  type: "remotion/checkerboard",
-  label: "checkerboard()",
-  documentationLink: "https://www.remotion.dev/docs/effects/checkerboard",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve(params);
-    const maskSuffix = r.maskToSourceAlpha ? "-mask-to-source-alpha" : "";
-    return `checkerboard-${r.colors.join("|")}-${r.cellSize}-${r.spacing}-${r.angle}-${r.offsetX}-${r.offsetY}${maskSuffix}`;
-  },
-  setup: (target) => setupCheckerboard(target),
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve(params);
-    const paletteDirty = updatePalette(state, r.colors);
-    const { gl, program, sourceTexture, paletteTexture, uniforms, vao } = state;
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, sourceTexture);
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    gl.activeTexture(gl.TEXTURE1);
-    gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
-    if (paletteDirty) {
-      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, r.colors.length, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, state.palettePixelData);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    }
-    gl.useProgram(program);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uPalette)
-      gl.uniform1i(uniforms.uPalette, 1);
-    if (uniforms.uResolution)
-      gl.uniform2f(uniforms.uResolution, width, height);
-    if (uniforms.uNumColors)
-      gl.uniform1f(uniforms.uNumColors, r.colors.length);
-    if (uniforms.uCellSize)
-      gl.uniform1f(uniforms.uCellSize, r.cellSize);
-    if (uniforms.uSpacing)
-      gl.uniform1f(uniforms.uSpacing, r.spacing);
-    if (uniforms.uAngle)
-      gl.uniform1f(uniforms.uAngle, r.angle * Math.PI / 180);
-    if (uniforms.uOffset)
-      gl.uniform2f(uniforms.uOffset, r.offsetX, r.offsetY);
-    if (uniforms.uMaskToSourceAlpha)
-      gl.uniform1i(uniforms.uMaskToSourceAlpha, r.maskToSourceAlpha ? 1 : 0);
-    gl.bindVertexArray(vao);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, sourceTexture, paletteTexture }) => {
-    gl.deleteTexture(sourceTexture);
-    gl.deleteTexture(paletteTexture);
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-  },
-  schema: checkerboardSchema,
-  validateParams: validateCheckerboardParams
-});
-// src/pattern.ts
-import { Internals as Internals2 } from "remotion";
-var { createEffect: createEffect2, createWebGL2ContextError: createWebGL2ContextError2 } = Internals2;
-var DEFAULT_SCALE = 0.1;
-var DEFAULT_CROP = 0;
-var DEFAULT_GAP2 = 0;
-var DEFAULT_OFFSET = 0;
-var DEFAULT_OFFSET_EVERY = 0;
-var DEFAULT_ORIGIN = [0, 0];
-var DEFAULT_WRAP = true;
-var patternSchema = {
-  scale: {
-    type: "number",
-    min: 0.001,
-    max: 2,
-    step: 0.01,
-    default: DEFAULT_SCALE,
-    description: "Scale",
-    hiddenFromList: false
-  },
-  cropLeft: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_CROP,
-    description: "Crop left",
-    hiddenFromList: false
-  },
-  cropTop: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_CROP,
-    description: "Crop top",
-    hiddenFromList: false
-  },
-  cropRight: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_CROP,
-    description: "Crop right",
-    hiddenFromList: false
-  },
-  cropBottom: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_CROP,
-    description: "Crop bottom",
-    hiddenFromList: false
-  },
-  gapX: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_GAP2,
-    description: "Gap X",
-    hiddenFromList: false
-  },
-  gapY: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_GAP2,
-    description: "Gap Y",
-    hiddenFromList: false
-  },
-  offsetU: {
-    type: "number",
-    step: 0.01,
-    default: DEFAULT_OFFSET,
-    description: "Offset U",
-    hiddenFromList: false
-  },
-  offsetV: {
-    type: "number",
-    step: 0.01,
-    default: DEFAULT_OFFSET,
-    description: "Offset V",
-    hiddenFromList: false
-  },
-  rowOffset: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_OFFSET,
-    description: "Row offset",
-    hiddenFromList: false
-  },
-  rowOffsetEvery: {
-    type: "number",
-    min: 0,
-    step: 1,
-    integer: true,
-    default: DEFAULT_OFFSET_EVERY,
-    description: "Row offset every",
-    hiddenFromList: false
-  },
-  columnOffset: {
-    type: "number",
-    step: 1,
-    default: DEFAULT_OFFSET,
-    description: "Column offset",
-    hiddenFromList: false
-  },
-  columnOffsetEvery: {
-    type: "number",
-    min: 0,
-    step: 1,
-    integer: true,
-    default: DEFAULT_OFFSET_EVERY,
-    description: "Column offset every",
-    hiddenFromList: false
-  },
-  origin: {
-    type: "uv-coordinate",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: DEFAULT_ORIGIN,
-    description: "Origin"
-  },
-  wrap: {
-    type: "boolean",
-    default: DEFAULT_WRAP,
-    description: "Wrap"
-  }
-};
-var resolve2 = (p) => ({
-  scale: p.scale ?? DEFAULT_SCALE,
-  cropLeft: p.cropLeft ?? DEFAULT_CROP,
-  cropTop: p.cropTop ?? DEFAULT_CROP,
-  cropRight: p.cropRight ?? DEFAULT_CROP,
-  cropBottom: p.cropBottom ?? DEFAULT_CROP,
-  gapX: p.gapX ?? DEFAULT_GAP2,
-  gapY: p.gapY ?? DEFAULT_GAP2,
-  offsetU: p.offsetU ?? DEFAULT_OFFSET,
-  offsetV: p.offsetV ?? DEFAULT_OFFSET,
-  rowOffset: p.rowOffset ?? DEFAULT_OFFSET,
-  rowOffsetEvery: p.rowOffsetEvery ?? DEFAULT_OFFSET_EVERY,
-  columnOffset: p.columnOffset ?? DEFAULT_OFFSET,
-  columnOffsetEvery: p.columnOffsetEvery ?? DEFAULT_OFFSET_EVERY,
-  origin: [...p.origin ?? DEFAULT_ORIGIN],
-  wrap: p.wrap ?? DEFAULT_WRAP
-});
-var assertOptionalUvCoordinate = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
-    throw new TypeError(`"${name}" must be a [number, number] tuple`);
-  }
-};
-var assertOptionalInteger = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Number.isInteger(value)) {
-    throw new TypeError(`"${name}" must be an integer, but got ${JSON.stringify(value)}`);
-  }
-};
-var validatePositive2 = (value, name) => {
-  if (value <= 0) {
-    throw new TypeError(`"${name}" must be > 0`);
-  }
-};
-var validateAtLeast = (value, min, name) => {
-  if (value < min) {
-    throw new TypeError(`"${name}" must be >= ${min}, but got ${JSON.stringify(value)}`);
-  }
-};
-var validatePatternParams = (params) => {
-  assertEffectParamsObject(params, "Pattern");
-  assertOptionalFiniteNumber(params.scale, "scale");
-  assertOptionalFiniteNumber(params.cropLeft, "cropLeft");
-  assertOptionalFiniteNumber(params.cropTop, "cropTop");
-  assertOptionalFiniteNumber(params.cropRight, "cropRight");
-  assertOptionalFiniteNumber(params.cropBottom, "cropBottom");
-  assertOptionalFiniteNumber(params.gapX, "gapX");
-  assertOptionalFiniteNumber(params.gapY, "gapY");
-  assertOptionalFiniteNumber(params.offsetU, "offsetU");
-  assertOptionalFiniteNumber(params.offsetV, "offsetV");
-  assertOptionalFiniteNumber(params.rowOffset, "rowOffset");
-  assertOptionalFiniteNumber(params.rowOffsetEvery, "rowOffsetEvery");
-  assertOptionalFiniteNumber(params.columnOffset, "columnOffset");
-  assertOptionalFiniteNumber(params.columnOffsetEvery, "columnOffsetEvery");
-  assertOptionalUvCoordinate(params.origin, "origin");
-  assertOptionalBoolean(params.wrap, "wrap");
-  assertOptionalInteger(params.rowOffsetEvery, "rowOffsetEvery");
-  assertOptionalInteger(params.columnOffsetEvery, "columnOffsetEvery");
-  const r = resolve2(params);
-  validatePositive2(r.scale, "scale");
-  validateAtLeast(r.rowOffsetEvery, 0, "rowOffsetEvery");
-  validateAtLeast(r.columnOffsetEvery, 0, "columnOffsetEvery");
-  validateUnitInterval(r.origin[0], "origin[0]");
-  validateUnitInterval(r.origin[1], "origin[1]");
-};
-var PATTERN_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var PATTERN_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform vec2 uResolution;
-uniform float uScale;
-uniform vec4 uCrop;
-uniform vec2 uGap;
-uniform vec2 uOffset;
-uniform vec2 uRowOffset;
-uniform vec2 uColumnOffset;
-uniform vec2 uOrigin;
-uniform bool uWrap;
-
-float positiveModulo(float value, float modulo) {
-	return mod(mod(value, modulo) + modulo, modulo);
-}
-
-float getPhase(float index, float every) {
-	if (every == 0.0) {
-		return index;
-	}
-
-	return positiveModulo(index, every);
-}
-
-bool sampleCell(vec2 cell, vec2 fragPx, vec2 cropStart, vec2 tileSize, vec2 pitch, vec2 originPx, out vec4 color) {
-	if (!uWrap && (cell.x < 0.0 || cell.y < 0.0)) {
-		return false;
-	}
-
-	float rowPhase = getPhase(cell.y, uRowOffset.y);
-	float columnPhase = getPhase(cell.x, uColumnOffset.y);
-	vec2 stagger = vec2(rowPhase * uRowOffset.x, columnPhase * uColumnOffset.x);
-	vec2 localPx = fragPx - originPx - stagger - cell * pitch;
-
-	if (localPx.x < 0.0 || localPx.y < 0.0 || localPx.x >= tileSize.x || localPx.y >= tileSize.y) {
-		return false;
-	}
-
-	vec2 sourcePx = cropStart + localPx / uScale;
-	vec2 sourceUv = vec2(sourcePx.x / uResolution.x, 1.0 - sourcePx.y / uResolution.y);
-
-	if (sourceUv.x < 0.0 || sourceUv.y < 0.0 || sourceUv.x > 1.0 || sourceUv.y > 1.0) {
-		return false;
-	}
-
-	color = texture(uSource, sourceUv);
-	return true;
-}
-
-void main() {
-	vec2 cropStart = uCrop.xy;
-	vec2 cropEnd = uResolution - uCrop.zw;
-	vec2 cropSize = max(cropEnd - cropStart, vec2(0.001));
-	vec2 tileSize = max(cropSize * uScale, vec2(0.001));
-	vec2 pitch = max(tileSize + uGap, vec2(0.001));
-	vec2 patternUv = vec2(vUv.x, 1.0 - vUv.y);
-	vec2 originPx = (uOrigin + uOffset) * uResolution;
-	vec2 fragPx = patternUv * uResolution;
-
-	vec2 gridPx = fragPx - originPx;
-	vec2 cell = floor(gridPx / pitch);
-
-	for (int i = 0; i < 4; i++) {
-		float rowPhase = getPhase(cell.y, uRowOffset.y);
-		float columnPhase = getPhase(cell.x, uColumnOffset.y);
-		vec2 stagger = vec2(rowPhase * uRowOffset.x, columnPhase * uColumnOffset.x);
-		vec2 adjustedGridPx = fragPx - originPx - stagger;
-		vec2 nextCell = floor(adjustedGridPx / pitch);
-
-		if (all(equal(nextCell, cell))) {
-			break;
-		}
-
-		cell = nextCell;
-	}
-
-	vec4 color = vec4(0.0);
-	for (int y = -4; y <= 4; y++) {
-		for (int x = -4; x <= 4; x++) {
-			if (sampleCell(cell + vec2(float(x), float(y)), fragPx, cropStart, tileSize, pitch, originPx, color)) {
-				fragColor = color;
-				return;
-			}
-		}
-	}
-
-	fragColor = vec4(0.0);
-}
-`;
-var compileShader2 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Pattern shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram2 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Pattern program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var pattern = createEffect2({
-  type: "dev.remotion.effects.pattern",
-  label: "pattern()",
-  documentationLink: "https://www.remotion.dev/docs/effects/pattern",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve2(params);
-    return `pattern-${r.scale}-${r.cropLeft}-${r.cropTop}-${r.cropRight}-${r.cropBottom}-${r.gapX}-${r.gapY}-${r.offsetU}-${r.offsetV}-${r.rowOffset}-${r.rowOffsetEvery}-${r.columnOffset}-${r.columnOffsetEvery}-${r.origin[0]}-${r.origin[1]}-${r.wrap ? 1 : 0}`;
-  },
-  setup: (target) => {
-    const gl = target.getContext("webgl2", {
-      premultipliedAlpha: true,
-      alpha: true,
-      preserveDrawingBuffer: true
-    });
-    if (!gl) {
-      throw createWebGL2ContextError2("pattern effect");
-    }
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader2(gl, gl.VERTEX_SHADER, PATTERN_VS);
-    const fs = compileShader2(gl, gl.FRAGMENT_SHADER, PATTERN_FS);
-    const program = linkProgram2(gl, vs, fs);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    const vao = gl.createVertexArray();
-    if (!vao) {
-      throw new Error("Failed to create WebGL vertex array");
-    }
-    gl.bindVertexArray(vao);
-    const data = new Float32Array([
-      -1,
-      -1,
-      0,
-      0,
-      1,
-      -1,
-      1,
-      0,
-      -1,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1
-    ]);
-    const vbo = gl.createBuffer();
-    if (!vbo) {
-      throw new Error("Failed to create WebGL buffer");
-    }
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    const aPos = gl.getAttribLocation(program, "aPos");
-    const aUv = gl.getAttribLocation(program, "aUv");
-    gl.enableVertexAttribArray(aPos);
-    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-    gl.enableVertexAttribArray(aUv);
-    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-    gl.bindVertexArray(null);
-    const texture = gl.createTexture();
-    if (!texture) {
-      throw new Error("Failed to create WebGL texture");
-    }
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    return {
-      gl,
-      program,
-      vao,
-      vbo,
-      texture,
-      uniforms: {
-        uSource: gl.getUniformLocation(program, "uSource"),
-        uResolution: gl.getUniformLocation(program, "uResolution"),
-        uScale: gl.getUniformLocation(program, "uScale"),
-        uCrop: gl.getUniformLocation(program, "uCrop"),
-        uGap: gl.getUniformLocation(program, "uGap"),
-        uOffset: gl.getUniformLocation(program, "uOffset"),
-        uRowOffset: gl.getUniformLocation(program, "uRowOffset"),
-        uColumnOffset: gl.getUniformLocation(program, "uColumnOffset"),
-        uOrigin: gl.getUniformLocation(program, "uOrigin"),
-        uWrap: gl.getUniformLocation(program, "uWrap")
-      }
-    };
-  },
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve2(params);
-    const { gl, program, vao, texture, uniforms } = state;
-    gl.viewport(0, 0, width, height);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.useProgram(program);
-    gl.bindVertexArray(vao);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uResolution)
-      gl.uniform2f(uniforms.uResolution, width, height);
-    if (uniforms.uScale)
-      gl.uniform1f(uniforms.uScale, r.scale);
-    if (uniforms.uCrop)
-      gl.uniform4f(uniforms.uCrop, r.cropLeft, r.cropTop, r.cropRight, r.cropBottom);
-    if (uniforms.uGap)
-      gl.uniform2f(uniforms.uGap, r.gapX, r.gapY);
-    if (uniforms.uOffset)
-      gl.uniform2f(uniforms.uOffset, r.offsetU, r.offsetV);
-    if (uniforms.uRowOffset)
-      gl.uniform2f(uniforms.uRowOffset, r.rowOffset, r.rowOffsetEvery);
-    if (uniforms.uColumnOffset)
-      gl.uniform2f(uniforms.uColumnOffset, r.columnOffset, r.columnOffsetEvery);
-    if (uniforms.uOrigin)
-      gl.uniform2f(uniforms.uOrigin, r.origin[0], r.origin[1]);
-    if (uniforms.uWrap)
-      gl.uniform1i(uniforms.uWrap, r.wrap ? 1 : 0);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, texture }) => {
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-    gl.deleteTexture(texture);
-  },
-  schema: patternSchema,
-  validateParams: validatePatternParams
-});
-// src/tile.ts
-import { Internals as Internals3 } from "remotion";
-var { createEffect: createEffect3 } = Internals3;
-var DEFAULT_HORIZONTAL = true;
-var DEFAULT_VERTICAL = true;
-var tileSchema = {
-  horizontal: {
-    type: "boolean",
-    default: DEFAULT_HORIZONTAL,
-    description: "Horizontal"
-  },
-  vertical: {
-    type: "boolean",
-    default: DEFAULT_VERTICAL,
-    description: "Vertical"
-  }
-};
-var resolve3 = (params) => ({
-  horizontal: params.horizontal ?? DEFAULT_HORIZONTAL,
-  vertical: params.vertical ?? DEFAULT_VERTICAL
-});
-var validateTileParams = (params) => {
-  assertEffectParamsObject(params, "Tile");
-  assertOptionalBoolean(params.horizontal, "horizontal");
-  assertOptionalBoolean(params.vertical, "vertical");
-};
-var tile = createEffect3({
-  type: "dev.remotion.effects.tile",
-  label: "tile()",
-  documentationLink: "https://www.remotion.dev/docs/effects/tile",
-  backend: "2d",
-  calculateKey: (params) => {
-    const r = resolve3(params);
-    return `tile-${r.horizontal}-${r.vertical}`;
-  },
-  setup: (target) => {
-    const boundsCanvas = target.ownerDocument.createElement("canvas");
-    const boundsContext = boundsCanvas.getContext("2d", {
-      colorSpace: "srgb",
-      willReadFrequently: true
-    });
-    if (!boundsContext) {
-      throw new Error("Failed to acquire 2D context for tile effect.");
-    }
-    const tileCanvas = target.ownerDocument.createElement("canvas");
-    const tileContext = tileCanvas.getContext("2d");
-    if (!tileContext) {
-      throw new Error("Failed to acquire 2D context for tile effect.");
-    }
-    return { boundsCanvas, boundsContext, tileCanvas, tileContext };
-  },
-  apply: ({ source, target, width, height, params, state }) => {
-    const context = target.getContext("2d");
-    if (!context) {
-      throw new Error("Failed to acquire 2D context for tile effect. The canvas may have been assigned a different context type.");
-    }
-    const r = resolve3(params);
-    context.clearRect(0, 0, width, height);
-    if (!r.horizontal && !r.vertical) {
-      context.drawImage(source, 0, 0, width, height);
-      return;
-    }
-    if (state.boundsCanvas.width !== width || state.boundsCanvas.height !== height) {
-      state.boundsCanvas.width = width;
-      state.boundsCanvas.height = height;
-    }
-    state.boundsContext.clearRect(0, 0, width, height);
-    state.boundsContext.drawImage(source, 0, 0, width, height);
-    const pixels = state.boundsContext.getImageData(0, 0, width, height).data;
-    const rowMaximumAlpha = (y) => {
-      let maximumAlpha = 0;
-      for (let x = 0;x < width; x++) {
-        maximumAlpha = Math.max(maximumAlpha, pixels[(y * width + x) * 4 + 3]);
-      }
-      return maximumAlpha;
-    };
-    const columnMaximumAlpha = (x, visibleTop, visibleBottom) => {
-      let maximumAlpha = 0;
-      for (let y = visibleTop;y <= visibleBottom; y++) {
-        maximumAlpha = Math.max(maximumAlpha, pixels[(y * width + x) * 4 + 3]);
-      }
-      return maximumAlpha;
-    };
-    let top = 0;
-    while (top < height && rowMaximumAlpha(top) === 0) {
-      top++;
-    }
-    if (top === height) {
-      context.clearRect(0, 0, width, height);
-      return;
-    }
-    let bottom = height - 1;
-    while (bottom > top && rowMaximumAlpha(bottom) === 0) {
-      bottom--;
-    }
-    let left = 0;
-    while (left < width && columnMaximumAlpha(left, top, bottom) === 0) {
-      left++;
-    }
-    let right = width - 1;
-    while (right > left && columnMaximumAlpha(right, top, bottom) === 0) {
-      right--;
-    }
-    if (r.vertical && top < bottom) {
-      if (rowMaximumAlpha(top) < rowMaximumAlpha(top + 1)) {
-        top++;
-      }
-      if (rowMaximumAlpha(bottom) < rowMaximumAlpha(bottom - 1)) {
-        bottom--;
-      }
-    }
-    if (r.horizontal && left < right) {
-      if (columnMaximumAlpha(left, top, bottom) < columnMaximumAlpha(left + 1, top, bottom)) {
-        left++;
-      }
-      if (columnMaximumAlpha(right, top, bottom) < columnMaximumAlpha(right - 1, top, bottom)) {
-        right--;
-      }
-    }
-    const tileWidth = right - left + 1;
-    const tileHeight = bottom - top + 1;
-    state.tileCanvas.width = tileWidth;
-    state.tileCanvas.height = tileHeight;
-    state.tileContext.clearRect(0, 0, tileWidth, tileHeight);
-    state.tileContext.drawImage(source, left, top, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
-    context.clearRect(0, 0, width, height);
-    const startX = r.horizontal ? left - Math.ceil(left / tileWidth) * tileWidth : left;
-    const startY = r.vertical ? top - Math.ceil(top / tileHeight) * tileHeight : top;
-    const endX = r.horizontal ? width : left + tileWidth;
-    const endY = r.vertical ? height : top + tileHeight;
-    for (let y = startY;y < endY; y += tileHeight) {
-      const tileY = Math.round((y - top) / tileHeight);
-      const mirrorY = r.vertical && Math.abs(tileY) % 2 === 1;
-      for (let x = startX;x < endX; x += tileWidth) {
-        const tileX = Math.round((x - left) / tileWidth);
-        const mirrorX = r.horizontal && Math.abs(tileX) % 2 === 1;
-        context.save();
-        context.translate(mirrorX ? x + tileWidth : x, mirrorY ? y + tileHeight : y);
-        context.scale(mirrorX ? -1 : 1, mirrorY ? -1 : 1);
-        context.drawImage(state.tileCanvas, 0, 0);
-        context.restore();
-      }
-    }
-  },
-  cleanup: () => {
-    return;
-  },
-  schema: tileSchema,
-  validateParams: validateTileParams
-});
-// src/rings.ts
-import { Internals as Internals4 } from "remotion";
-
-// src/uv-coordinate.ts
-var publicUvToShaderUv = (uv) => {
-  return [uv[0], 1 - uv[1]];
-};
-
-// src/rings.ts
-var { createEffect: createEffect4, createWebGL2ContextError: createWebGL2ContextError3 } = Internals4;
-var DEFAULT_COLORS2 = ["#dff4ff", "#7cc6ff"];
-var DEFAULT_CENTER = [0.5, 0.5];
-var DEFAULT_THICKNESS = 40;
-var DEFAULT_GAP3 = 0;
-var DEFAULT_OFFSET2 = 0;
-var DEFAULT_MASK_TO_SOURCE_ALPHA2 = false;
-var ringsSchema = {
-  colors: {
-    type: "array",
-    item: {
-      type: "color"
-    },
-    default: DEFAULT_COLORS2,
-    minLength: 2,
-    newItemDefault: "#ff0000",
-    description: "Colors",
-    keyframable: false
-  },
-  center: {
-    type: "uv-coordinate",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: DEFAULT_CENTER,
-    description: "Center"
-  },
-  thickness: {
-    type: "number",
-    min: 0.1,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_THICKNESS,
-    description: "Thickness",
-    hiddenFromList: false
-  },
-  gap: {
-    type: "number",
-    min: 0,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_GAP3,
-    description: "Gap",
-    hiddenFromList: false
-  },
-  offset: {
-    type: "number",
-    step: 0.1,
-    default: DEFAULT_OFFSET2,
-    description: "Offset",
-    hiddenFromList: false
-  },
-  maskToSourceAlpha: {
-    type: "boolean",
-    default: DEFAULT_MASK_TO_SOURCE_ALPHA2,
-    description: "Mask to source alpha"
-  }
-};
-var resolve4 = (p) => {
-  const thickness = p.thickness ?? DEFAULT_THICKNESS;
-  const gap = p.gap ?? DEFAULT_GAP3;
-  return {
-    colors: p.colors ?? DEFAULT_COLORS2,
-    center: [...p.center ?? DEFAULT_CENTER],
-    thickness,
-    spacing: thickness + gap,
-    offset: p.offset ?? DEFAULT_OFFSET2,
-    maskToSourceAlpha: p.maskToSourceAlpha ?? DEFAULT_MASK_TO_SOURCE_ALPHA2
-  };
-};
-var validatePositive3 = (value, name) => {
-  if (value <= 0) {
-    throw new TypeError(`"${name}" must be greater than 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateNonNegative3 = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be greater than or equal to 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateColors2 = (colors) => {
-  if (colors === undefined) {
-    return;
-  }
-  if (!Array.isArray(colors) || colors.length < 2) {
-    throw new TypeError(`"colors" must be an array with at least 2 colors, but got ${JSON.stringify(colors)}`);
-  }
-  for (let i = 0;i < colors.length; i++) {
-    assertRequiredColor(colors[i], `colors[${i}]`);
-  }
-};
-var assertOptionalCenter = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
-    throw new TypeError(`"${name}" must be a [number, number] tuple`);
-  }
-  validateUnitInterval(value[0], `${name}[0]`);
-  validateUnitInterval(value[1], `${name}[1]`);
-};
-var validateRingsParams = (params) => {
-  assertEffectParamsObject(params, "Rings");
-  validateColors2(params.colors);
-  assertOptionalCenter(params.center, "center");
-  assertOptionalFiniteNumber(params.thickness, "thickness");
-  assertOptionalFiniteNumber(params.gap, "gap");
-  assertOptionalFiniteNumber(params.offset, "offset");
-  assertOptionalBoolean(params.maskToSourceAlpha, "maskToSourceAlpha");
-  const thickness = params.thickness ?? DEFAULT_THICKNESS;
-  const gap = params.gap ?? DEFAULT_GAP3;
-  validatePositive3(thickness, "thickness");
-  validateNonNegative3(gap, "gap");
-};
-var RINGS_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var RINGS_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform sampler2D uPalette;
-uniform vec2 uResolution;
-uniform float uNumColors;
-uniform vec2 uCenter;
-uniform float uThickness;
-uniform float uSpacing;
-uniform float uOffset;
-uniform bool uMaskToSourceAlpha;
-
-void main() {
-	vec4 texColor = texture(uSource, vUv);
-	float thickness = max(uThickness, 0.001);
-	float spacing = max(uSpacing, 0.001);
-	float cycle = spacing * uNumColors;
-	vec2 pixelPosition = vUv * uResolution;
-	vec2 centerPosition = uCenter * uResolution;
-	float radius = length(pixelPosition - centerPosition);
-	float position = mod(radius + uOffset, cycle);
-	if (position < 0.0) {
-		position += cycle;
-	}
-
-	float colorIndex = floor(position / spacing);
-	float inStripe = mod(position, spacing);
-	if (inStripe > thickness) {
-		fragColor = texColor;
-		return;
-	}
-
-	float texCoord = (colorIndex + 0.5) / uNumColors;
-	vec4 ringColor = texture(uPalette, vec2(texCoord, 0.5));
-	float ringAlpha = ringColor.a;
-	vec3 premultipliedRing = ringColor.rgb * ringAlpha;
-
-	if (uMaskToSourceAlpha) {
-		fragColor = vec4(
-			premultipliedRing * texColor.a + texColor.rgb * (1.0 - ringAlpha),
-			texColor.a
-		);
-		return;
-	}
-
-	fragColor = vec4(
-		premultipliedRing + texColor.rgb * (1.0 - ringAlpha),
-		ringAlpha + texColor.a * (1.0 - ringAlpha)
-	);
-}
-`;
-var compileShader3 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Rings shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram3 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Rings program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var createProgram2 = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader3(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader3(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram3(gl, vs, fs);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  return program;
-};
-var createTexture2 = (gl, filter) => {
-  const texture = gl.createTexture();
-  if (!texture) {
-    throw new Error("Failed to create WebGL texture");
-  }
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  return texture;
-};
-var setupRings = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError3("rings effect");
-  }
-  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-  const program = createProgram2(gl, RINGS_VS, RINGS_FS);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  const aPos = gl.getAttribLocation(program, "aPos");
-  const aUv = gl.getAttribLocation(program, "aUv");
-  gl.enableVertexAttribArray(aPos);
-  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(aUv);
-  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const colorCanvas = document.createElement("canvas");
-  colorCanvas.width = 1;
-  colorCanvas.height = 1;
-  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-  if (!colorCtx) {
-    throw new Error("Failed to acquire 2D context for color parsing");
-  }
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    sourceTexture: createTexture2(gl, gl.LINEAR),
-    paletteTexture: createTexture2(gl, gl.NEAREST),
-    colorCtx,
-    uniforms: {
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uPalette: gl.getUniformLocation(program, "uPalette"),
-      uResolution: gl.getUniformLocation(program, "uResolution"),
-      uNumColors: gl.getUniformLocation(program, "uNumColors"),
-      uCenter: gl.getUniformLocation(program, "uCenter"),
-      uThickness: gl.getUniformLocation(program, "uThickness"),
-      uSpacing: gl.getUniformLocation(program, "uSpacing"),
-      uOffset: gl.getUniformLocation(program, "uOffset"),
-      uMaskToSourceAlpha: gl.getUniformLocation(program, "uMaskToSourceAlpha")
-    },
-    cachedPaletteKey: "",
-    palettePixelData: new Uint8Array(0)
-  };
-};
-var updatePalette2 = (state, colors) => {
-  const paletteKey = colors.join("|");
-  const paletteDirty = state.cachedPaletteKey !== paletteKey;
-  if (!paletteDirty) {
-    return false;
-  }
-  state.cachedPaletteKey = paletteKey;
-  const len = colors.length * 4;
-  if (state.palettePixelData.length !== len) {
-    state.palettePixelData = new Uint8Array(len);
-  }
-  const { palettePixelData } = state;
-  for (let i = 0;i < colors.length; i++) {
-    const color = parseColorRgba(state.colorCtx, colors[i]);
-    palettePixelData[i * 4] = color[0];
-    palettePixelData[i * 4 + 1] = color[1];
-    palettePixelData[i * 4 + 2] = color[2];
-    palettePixelData[i * 4 + 3] = color[3];
-  }
-  return true;
-};
-var rings = createEffect4({
-  type: "dev.remotion.effects.rings",
-  label: "rings()",
-  documentationLink: "https://www.remotion.dev/docs/effects/rings",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve4(params);
-    const maskSuffix = r.maskToSourceAlpha ? "-mask-to-source-alpha" : "";
-    return `rings-${r.colors.join("|")}-${r.center.join(":")}-${r.thickness}-${r.spacing}-${r.offset}${maskSuffix}`;
-  },
-  setup: (target) => setupRings(target),
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve4(params);
-    const paletteDirty = updatePalette2(state, r.colors);
-    const { gl, program, sourceTexture, paletteTexture, uniforms, vao } = state;
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, sourceTexture);
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    gl.activeTexture(gl.TEXTURE1);
-    gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
-    if (paletteDirty) {
-      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, r.colors.length, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, state.palettePixelData);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    }
-    gl.useProgram(program);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uPalette)
-      gl.uniform1i(uniforms.uPalette, 1);
-    if (uniforms.uResolution)
-      gl.uniform2f(uniforms.uResolution, width, height);
-    if (uniforms.uNumColors)
-      gl.uniform1f(uniforms.uNumColors, r.colors.length);
-    if (uniforms.uCenter) {
-      const shaderCenter = publicUvToShaderUv(r.center);
-      gl.uniform2f(uniforms.uCenter, shaderCenter[0], shaderCenter[1]);
-    }
-    if (uniforms.uThickness)
-      gl.uniform1f(uniforms.uThickness, r.thickness);
-    if (uniforms.uSpacing)
-      gl.uniform1f(uniforms.uSpacing, r.spacing);
-    if (uniforms.uOffset)
-      gl.uniform1f(uniforms.uOffset, r.offset);
-    if (uniforms.uMaskToSourceAlpha)
-      gl.uniform1i(uniforms.uMaskToSourceAlpha, r.maskToSourceAlpha ? 1 : 0);
-    gl.bindVertexArray(vao);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, sourceTexture, paletteTexture }) => {
-    gl.deleteTexture(sourceTexture);
-    gl.deleteTexture(paletteTexture);
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-  },
-  schema: ringsSchema,
-  validateParams: validateRingsParams
-});
-// src/starburst.ts
-import { Internals as Internals5 } from "remotion";
-import { NoReactInternals } from "remotion/no-react";
-var { createEffect: createEffect5, createWebGL2ContextError: createWebGL2ContextError4 } = Internals5;
-var colorToRgb = (color) => {
-  const packed = NoReactInternals.processColor(color);
-  return [packed >>> 16 & 255, packed >>> 8 & 255, packed & 255];
-};
-var DEFAULT_ORIGIN2 = [0.5, 0.5];
-var starburstEffectSchema = {
-  rays: {
-    type: "number",
-    min: 2,
-    max: 100,
-    step: 1,
-    default: undefined,
-    description: "Number of Rays",
-    hiddenFromList: false
-  },
-  colors: {
-    type: "array",
-    item: {
-      type: "color"
-    },
-    default: undefined,
-    minLength: 2,
-    newItemDefault: "#ff0000",
-    description: "Colors",
-    keyframable: false
-  },
-  rotation: {
-    type: "number",
-    min: 0,
-    max: 360,
-    step: 1,
-    default: 0,
-    description: "Rotation",
-    hiddenFromList: false
-  },
-  smoothness: {
-    type: "number",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: 0,
-    description: "Edge Smoothness",
-    hiddenFromList: false
-  },
-  origin: {
-    type: "uv-coordinate",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: DEFAULT_ORIGIN2,
-    description: "Origin"
-  }
-};
-var resolve5 = (p) => ({
-  rays: p.rays,
-  colors: p.colors,
-  rotation: p.rotation ?? 0,
-  smoothness: p.smoothness ?? 0,
-  origin: p.origin ?? DEFAULT_ORIGIN2
-});
-var validateStarburstEffectParams = (params) => {
-  if (params === null || typeof params !== "object") {
-    throw new TypeError(`Starburst effect requires a parameters object, but got ${JSON.stringify(params)}`);
-  }
-  const { rays, colors } = params;
-  if (typeof rays !== "number" || !Number.isFinite(rays)) {
-    throw new TypeError(`"rays" must be a finite number, but got ${JSON.stringify(rays)}`);
-  }
-  if (rays < 2 || rays > 100) {
-    throw new RangeError(`"rays" must be between 2 and 100, but got ${rays}`);
-  }
-  if (!Array.isArray(colors) || colors.length < 2) {
-    throw new TypeError(`"colors" must be an array with at least 2 colors, but got ${JSON.stringify(colors)}`);
-  }
-  const r = resolve5(params);
-  if (typeof r.rotation !== "number" || !Number.isFinite(r.rotation)) {
-    throw new TypeError(`"rotation" must be a finite number, but got ${JSON.stringify(params.rotation)}`);
-  }
-  if (typeof r.smoothness !== "number" || !Number.isFinite(r.smoothness)) {
-    throw new TypeError(`"smoothness" must be a finite number, but got ${JSON.stringify(params.smoothness)}`);
-  }
-  if (r.smoothness < 0 || r.smoothness > 1) {
-    throw new RangeError(`"smoothness" must be between 0 and 1, but got ${r.smoothness}`);
-  }
-  if (!Array.isArray(r.origin) || r.origin.length !== 2 || r.origin.some((coordinate) => {
-    return typeof coordinate !== "number" || !Number.isFinite(coordinate);
-  })) {
-    throw new TypeError('"origin" must be a [number, number] tuple');
-  }
-  if (r.origin.some((coordinate) => coordinate < 0 || coordinate > 1)) {
-    throw new RangeError(`"origin" must contain coordinates between 0 and 1, but got ${JSON.stringify(r.origin)}`);
-  }
-  for (const c of r.colors) {
-    colorToRgb(c);
-  }
-};
-var STARBURST_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var STARBURST_FS = `#version 300 es
-precision highp float;
-
-uniform sampler2D colorPalette;
-uniform float numRays;
-uniform float rotationOffset;
-uniform float smoothEdge;
-uniform vec2 resolution;
-uniform float numColors;
-uniform vec2 origin;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-const float Pi = 3.14159265359;
-
-void main() {
-	vec2 uv = vUv;
-	vec2 center = uv - origin;
-	center.x *= resolution.x / resolution.y;
-
-	float angle = atan(center.y, center.x) + rotationOffset;
-	float normalizedAngle = (angle + Pi) / (2.0 * Pi);
-	float sector = normalizedAngle * numRays;
-	float rayIndex = mod(floor(sector), numRays);
-
-	float colorIndex = mod(rayIndex, numColors);
-	float texCoord = (colorIndex + 0.5) / numColors;
-	vec3 col = texture(colorPalette, vec2(texCoord, 0.5)).rgb;
-
-	float fractSector = fract(sector);
-	float edgeSmooth = smoothEdge * 0.5;
-	float nextColorIndex = mod(rayIndex + 1.0, numColors);
-	float nextTexCoord = (nextColorIndex + 0.5) / numColors;
-	vec3 nextCol = texture(colorPalette, vec2(nextTexCoord, 0.5)).rgb;
-
-	float blend = smoothstep(1.0 - edgeSmooth, 1.0, fractSector);
-	col = mix(col, nextCol, blend);
-	float blendStart = smoothstep(edgeSmooth, 0.0, fractSector);
-	float prevColorIndex = mod(rayIndex - 1.0 + numColors, numColors);
-	float prevTexCoord = (prevColorIndex + 0.5) / numColors;
-	vec3 prevCol = texture(colorPalette, vec2(prevTexCoord, 0.5)).rgb;
-	col = mix(col, prevCol, blendStart);
-
-	fragColor = vec4(col, 1.0);
-}
-`;
-var compileShader4 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Starburst shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram4 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Starburst program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var starburst = createEffect5({
-  type: "remotion/starburst",
-  label: "starburst()",
-  documentationLink: "https://www.remotion.dev/docs/effects/starburst",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve5(params);
-    return `starburst-${r.rays}-${r.colors.join("|")}-${r.rotation}-${r.smoothness}-${r.origin.join(":")}`;
-  },
-  setup: (target) => {
-    const gl = target.getContext("webgl2", {
-      premultipliedAlpha: true,
-      alpha: true,
-      preserveDrawingBuffer: true
-    });
-    if (!gl) {
-      throw createWebGL2ContextError4("starburst effect");
-    }
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader4(gl, gl.VERTEX_SHADER, STARBURST_VS);
-    const fs = compileShader4(gl, gl.FRAGMENT_SHADER, STARBURST_FS);
-    const program = linkProgram4(gl, vs, fs);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    const vao = gl.createVertexArray();
-    if (!vao) {
-      throw new Error("Failed to create WebGL vertex array");
-    }
-    gl.bindVertexArray(vao);
-    const data = new Float32Array([
-      -1,
-      -1,
-      0,
-      0,
-      1,
-      -1,
-      1,
-      0,
-      -1,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1
-    ]);
-    const vbo = gl.createBuffer();
-    if (!vbo) {
-      throw new Error("Failed to create WebGL buffer");
-    }
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    const aPos = gl.getAttribLocation(program, "aPos");
-    const aUv = gl.getAttribLocation(program, "aUv");
-    gl.enableVertexAttribArray(aPos);
-    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-    gl.enableVertexAttribArray(aUv);
-    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-    gl.bindVertexArray(null);
-    const paletteTexture = gl.createTexture();
-    if (!paletteTexture) {
-      throw new Error("Failed to create WebGL palette texture");
-    }
-    gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    return {
-      gl,
-      program,
-      vao,
-      vbo,
-      paletteTexture,
-      uColorPalette: gl.getUniformLocation(program, "colorPalette"),
-      uNumRays: gl.getUniformLocation(program, "numRays"),
-      uRotationOffset: gl.getUniformLocation(program, "rotationOffset"),
-      uSmoothEdge: gl.getUniformLocation(program, "smoothEdge"),
-      uResolution: gl.getUniformLocation(program, "resolution"),
-      uNumColors: gl.getUniformLocation(program, "numColors"),
-      uOrigin: gl.getUniformLocation(program, "origin"),
-      cachedPaletteKey: "",
-      palettePixelData: new Uint8Array(0)
-    };
-  },
-  apply: ({ width, height, params, state }) => {
-    const r = resolve5(params);
-    const {
-      gl,
-      program,
-      vao,
-      paletteTexture,
-      uColorPalette,
-      uNumRays,
-      uRotationOffset,
-      uSmoothEdge,
-      uResolution,
-      uNumColors,
-      uOrigin
-    } = state;
-    const rotationRad = r.rotation * Math.PI / 180;
-    const paletteKey = r.colors.join("|");
-    const paletteDirty = state.cachedPaletteKey !== paletteKey;
-    if (paletteDirty) {
-      state.cachedPaletteKey = paletteKey;
-      const len = r.colors.length * 4;
-      if (state.palettePixelData.length !== len) {
-        state.palettePixelData = new Uint8Array(len);
-      }
-      const { palettePixelData } = state;
-      for (let i = 0;i < r.colors.length; i++) {
-        const rgb = colorToRgb(r.colors[i]);
-        palettePixelData[i * 4] = rgb[0];
-        palettePixelData[i * 4 + 1] = rgb[1];
-        palettePixelData[i * 4 + 2] = rgb[2];
-        palettePixelData[i * 4 + 3] = 255;
-      }
-    }
-    gl.viewport(0, 0, width, height);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.useProgram(program);
-    gl.bindVertexArray(vao);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
-    if (paletteDirty) {
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, r.colors.length, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, state.palettePixelData);
-    }
-    if (uColorPalette)
-      gl.uniform1i(uColorPalette, 0);
-    if (uNumRays)
-      gl.uniform1f(uNumRays, r.rays);
-    if (uNumColors)
-      gl.uniform1f(uNumColors, r.colors.length);
-    if (uRotationOffset)
-      gl.uniform1f(uRotationOffset, rotationRad);
-    if (uSmoothEdge)
-      gl.uniform1f(uSmoothEdge, r.smoothness);
-    if (uOrigin)
-      gl.uniform2f(uOrigin, r.origin[0], 1 - r.origin[1]);
-    if (uResolution)
-      gl.uniform2f(uResolution, width, height);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, paletteTexture }) => {
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-    gl.deleteTexture(paletteTexture);
-  },
-  schema: starburstEffectSchema,
-  validateParams: validateStarburstEffectParams
-});
-// src/light-leak.ts
-import { Internals as Internals6 } from "remotion";
-var { createEffect: createEffect6, createWebGL2ContextError: createWebGL2ContextError5 } = Internals6;
-var DEFAULT_SEED = 0;
-var DEFAULT_HUE_SHIFT = 0;
-var DEFAULT_PROGRESS = 0.5;
-var lightLeakEffectSchema = {
-  seed: {
-    type: "number",
-    default: DEFAULT_SEED,
-    description: "Seed",
-    hiddenFromList: false
-  },
-  hueShift: {
-    type: "number",
-    min: 0,
-    max: 360,
-    default: DEFAULT_HUE_SHIFT,
-    description: "Hue Shift",
-    hiddenFromList: false
-  },
-  progress: {
-    type: "number",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: DEFAULT_PROGRESS,
-    description: "Progress",
-    hiddenFromList: false
-  }
-};
-var resolve6 = (p) => ({
-  seed: p.seed ?? DEFAULT_SEED,
-  hueShift: p.hueShift ?? DEFAULT_HUE_SHIFT,
-  progress: p.progress ?? DEFAULT_PROGRESS
-});
-var validateLightLeakParams = (params) => {
-  assertEffectParamsObject(params, "lightLeak()");
-  assertOptionalFiniteNumber(params.seed, "seed");
-  assertOptionalFiniteNumber(params.hueShift, "hueShift");
-  assertOptionalFiniteNumber(params.progress, "progress");
-  const { hueShift, progress } = resolve6(params);
-  if (hueShift < 0) {
-    throw new TypeError(`"hueShift" must be >= 0, but got ${hueShift}`);
-  }
-  if (hueShift > 360) {
-    throw new TypeError(`"hueShift" must be <= 360, but got ${hueShift}`);
-  }
-  validateUnitInterval(progress, "progress");
-};
-var LIGHT_LEAK_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var LIGHT_LEAK_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform float evolveProgress;
-uniform float retractProgress;
-uniform float seed;
-uniform float retractSeed;
-uniform float hueShift;
-uniform vec2 resolution;
-
-const float Pi = 3.14159;
-
-vec3 computePattern(vec2 uv, float s, float t) {
-	vec2 p = uv * 0.8;
-	p += vec2(sin(s * 1.61803) * 5.0, cos(s * 2.71828) * 5.0);
-
-	for (int i = 1; i < 5; i++) {
-		vec2 newp = p;
-		float fi = float(i);
-		float phase = s * 0.7 * fi;
-		newp.x += 0.6 / fi * cos(fi * p.y + t * 0.7 + 0.3 * fi + phase) + 20.0;
-		newp.y += 0.6 / fi * cos(fi * p.x + t * 0.7 + 0.3 * float(i + 10) + phase) - 20.0 + 15.0;
-		p = newp;
-	}
-
-	float v1 = 0.5 * sin(2.0 * p.x) + 0.5;
-	float v2 = 0.5 * sin(2.0 * p.y) + 0.5;
-	float blend = sin(p.x + p.y) * 0.5 + 0.5;
-	float brightness = v1 * 0.5 + v2 * 0.5;
-	float patternValue = brightness * 0.6 + blend * 0.4;
-
-	return vec3(brightness, blend, patternValue);
-}
-
-void main() {
-	float refScale = 1.92;
-	vec2 uv = (gl_FragCoord.xy / resolution) * vec2(refScale, refScale * resolution.y / resolution.x);
-
-	vec3 patA = computePattern(uv, seed, evolveProgress * Pi);
-	float threshA = 1.0 - evolveProgress;
-	float revealAlpha = smoothstep(threshA, threshA + 0.3, patA.z);
-
-	vec2 maxUv = vec2(refScale, refScale * resolution.y / resolution.x);
-	vec2 retractUv = maxUv - uv;
-	vec3 patB = computePattern(retractUv, retractSeed, retractProgress * Pi);
-	float threshB = 1.0 - retractProgress;
-	float eraseAlpha = smoothstep(threshB, threshB + 0.3, patB.z);
-
-	float alpha = revealAlpha * (1.0 - eraseAlpha);
-
-	vec3 yellow = vec3(1.0, 0.85, 0.2);
-	vec3 orange = vec3(1.0, 0.5, 0.05);
-	vec3 col = mix(yellow, orange, patA.y);
-	col *= 0.6 + 0.6 * patA.x;
-
-	float angle = hueShift * Pi / 180.0;
-	float cosA = cos(angle);
-	float sinA = sin(angle);
-	mat3 hueRot = mat3(
-		cosA + (1.0 - cosA) / 3.0,
-		(1.0 - cosA) / 3.0 - sinA * 0.57735,
-		(1.0 - cosA) / 3.0 + sinA * 0.57735,
-		(1.0 - cosA) / 3.0 + sinA * 0.57735,
-		cosA + (1.0 - cosA) / 3.0,
-		(1.0 - cosA) / 3.0 - sinA * 0.57735,
-		(1.0 - cosA) / 3.0 - sinA * 0.57735,
-		(1.0 - cosA) / 3.0 + sinA * 0.57735,
-		cosA + (1.0 - cosA) / 3.0
-	);
-	col = clamp(hueRot * col, 0.0, 1.0);
-
-	vec4 src = texture(uSource, vUv);
-	vec4 leakPm = vec4(col * alpha, alpha);
-	fragColor = leakPm + src * (1.0 - alpha);
-}
-`;
-var compileShader5 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Light leak shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram5 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Light leak program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var lightLeak = createEffect6({
-  type: "remotion/light-leak",
-  label: "lightLeak()",
-  documentationLink: "https://www.remotion.dev/docs/effects/light-leak",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve6(params);
-    return `light-leak-${r.seed}-${r.hueShift}-${r.progress}`;
-  },
-  setup: (target) => {
-    const gl = target.getContext("webgl2", {
-      premultipliedAlpha: true,
-      alpha: true,
-      preserveDrawingBuffer: true
-    });
-    if (!gl) {
-      throw createWebGL2ContextError5("light leak effect");
-    }
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader5(gl, gl.VERTEX_SHADER, LIGHT_LEAK_VS);
-    const fs = compileShader5(gl, gl.FRAGMENT_SHADER, LIGHT_LEAK_FS);
-    const program = linkProgram5(gl, vs, fs);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    const vao = gl.createVertexArray();
-    if (!vao) {
-      throw new Error("Failed to create WebGL vertex array");
-    }
-    gl.bindVertexArray(vao);
-    const data = new Float32Array([
-      -1,
-      -1,
-      0,
-      0,
-      1,
-      -1,
-      1,
-      0,
-      -1,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1
-    ]);
-    const vbo = gl.createBuffer();
-    if (!vbo) {
-      throw new Error("Failed to create WebGL buffer");
-    }
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    const aPos = gl.getAttribLocation(program, "aPos");
-    const aUv = gl.getAttribLocation(program, "aUv");
-    gl.enableVertexAttribArray(aPos);
-    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-    gl.enableVertexAttribArray(aUv);
-    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-    gl.bindVertexArray(null);
-    const texture = gl.createTexture();
-    if (!texture) {
-      throw new Error("Failed to create WebGL texture");
-    }
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    return {
-      gl,
-      program,
-      vao,
-      vbo,
-      texture,
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uEvolveProgress: gl.getUniformLocation(program, "evolveProgress"),
-      uRetractProgress: gl.getUniformLocation(program, "retractProgress"),
-      uSeed: gl.getUniformLocation(program, "seed"),
-      uRetractSeed: gl.getUniformLocation(program, "retractSeed"),
-      uHueShift: gl.getUniformLocation(program, "hueShift"),
-      uResolution: gl.getUniformLocation(program, "resolution")
-    };
-  },
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve6(params);
-    const evolveProgress = Math.min(1, r.progress * 2);
-    const retractProgress = Math.max(0, r.progress * 2 - 1);
-    const {
-      gl,
-      program,
-      vao,
-      texture,
-      uSource,
-      uEvolveProgress,
-      uRetractProgress,
-      uSeed,
-      uRetractSeed,
-      uHueShift,
-      uResolution
-    } = state;
-    gl.viewport(0, 0, width, height);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.useProgram(program);
-    gl.bindVertexArray(vao);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    if (uSource)
-      gl.uniform1i(uSource, 0);
-    if (uEvolveProgress)
-      gl.uniform1f(uEvolveProgress, evolveProgress);
-    if (uRetractProgress)
-      gl.uniform1f(uRetractProgress, retractProgress);
-    if (uSeed)
-      gl.uniform1f(uSeed, r.seed);
-    if (uRetractSeed)
-      gl.uniform1f(uRetractSeed, r.seed + 42);
-    if (uHueShift)
-      gl.uniform1f(uHueShift, r.hueShift);
-    if (uResolution)
-      gl.uniform2f(uResolution, width, height);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, texture }) => {
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-    gl.deleteTexture(texture);
-  },
-  schema: lightLeakEffectSchema,
-  validateParams: validateLightLeakParams
-});
-// src/gridlines.ts
-import { Internals as Internals7 } from "remotion";
-var { createEffect: createEffect7, createWebGL2ContextError: createWebGL2ContextError6 } = Internals7;
-var DEFAULT_GRID_SIZE = 64;
-var DEFAULT_LINE_WIDTH = 2;
-var DEFAULT_LINE_COLOR = "#ffffff";
-var DEFAULT_BACKGROUND_COLOR = "transparent";
-var DEFAULT_ROTATION = 0;
-var DEFAULT_ROTATION_X = 0;
-var DEFAULT_ROTATION_Y = 0;
-var DEFAULT_PERSPECTIVE = 0;
-var DEFAULT_OFFSET_X2 = 0;
-var DEFAULT_OFFSET_Y2 = 0;
-var DEFAULT_MASK_TO_SOURCE_ALPHA3 = false;
-var gridlinesSchema = {
-  gridSize: {
-    type: "number",
-    min: 1,
-    max: 400,
-    step: 1,
-    default: DEFAULT_GRID_SIZE,
-    description: "Grid size",
-    hiddenFromList: false
-  },
-  lineWidth: {
-    type: "number",
-    min: 0,
-    max: 100,
-    step: 0.1,
-    default: DEFAULT_LINE_WIDTH,
-    description: "Line width",
-    hiddenFromList: false
-  },
-  lineColor: {
-    type: "color",
-    default: DEFAULT_LINE_COLOR,
-    description: "Line color"
-  },
-  backgroundColor: {
-    type: "color",
-    default: DEFAULT_BACKGROUND_COLOR,
-    description: "Background color"
-  },
-  rotation: {
-    type: "rotation-degrees",
-    min: -180,
-    max: 180,
-    step: 1,
-    default: DEFAULT_ROTATION,
-    description: "Rotation"
-  },
-  rotationX: {
-    type: "rotation-degrees",
-    min: -180,
-    max: 180,
-    step: 0.1,
-    default: DEFAULT_ROTATION_X,
-    description: "Rotation X"
-  },
-  rotationY: {
-    type: "rotation-degrees",
-    min: -180,
-    max: 180,
-    step: 0.1,
-    default: DEFAULT_ROTATION_Y,
-    description: "Rotation Y"
-  },
-  perspective: {
-    type: "number",
-    min: 0,
-    max: 4000,
-    step: 1,
-    default: DEFAULT_PERSPECTIVE,
-    description: "Perspective",
-    hiddenFromList: false
-  },
-  offsetX: {
-    type: "number",
-    min: -400,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_OFFSET_X2,
-    description: "Offset X",
-    hiddenFromList: false
-  },
-  offsetY: {
-    type: "number",
-    min: -400,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_OFFSET_Y2,
-    description: "Offset Y",
-    hiddenFromList: false
-  },
-  maskToSourceAlpha: {
-    type: "boolean",
-    default: DEFAULT_MASK_TO_SOURCE_ALPHA3,
-    description: "Mask to source alpha"
-  }
-};
-var resolve7 = (p) => ({
-  gridSize: p.gridSize ?? DEFAULT_GRID_SIZE,
-  lineWidth: p.lineWidth ?? DEFAULT_LINE_WIDTH,
-  lineColor: p.lineColor ?? DEFAULT_LINE_COLOR,
-  backgroundColor: p.backgroundColor ?? DEFAULT_BACKGROUND_COLOR,
-  rotation: p.rotation ?? DEFAULT_ROTATION,
-  rotationX: p.rotationX ?? DEFAULT_ROTATION_X,
-  rotationY: p.rotationY ?? DEFAULT_ROTATION_Y,
-  perspective: p.perspective ?? DEFAULT_PERSPECTIVE,
-  offsetX: p.offsetX ?? DEFAULT_OFFSET_X2,
-  offsetY: p.offsetY ?? DEFAULT_OFFSET_Y2,
-  maskToSourceAlpha: p.maskToSourceAlpha ?? DEFAULT_MASK_TO_SOURCE_ALPHA3
-});
-var validatePositive4 = (value, name) => {
-  if (value <= 0) {
-    throw new TypeError(`"${name}" must be greater than 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateNonNegative4 = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be greater than or equal to 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateGridlinesParams = (params) => {
-  assertEffectParamsObject(params, "Gridlines");
-  assertOptionalFiniteNumber(params.gridSize, "gridSize");
-  assertOptionalFiniteNumber(params.lineWidth, "lineWidth");
-  assertOptionalFiniteNumber(params.rotation, "rotation");
-  assertOptionalFiniteNumber(params.rotationX, "rotationX");
-  assertOptionalFiniteNumber(params.rotationY, "rotationY");
-  assertOptionalFiniteNumber(params.perspective, "perspective");
-  assertOptionalFiniteNumber(params.offsetX, "offsetX");
-  assertOptionalFiniteNumber(params.offsetY, "offsetY");
-  assertOptionalColor(params.lineColor, "lineColor");
-  assertOptionalColor(params.backgroundColor, "backgroundColor");
-  assertOptionalBoolean(params.maskToSourceAlpha, "maskToSourceAlpha");
-  validatePositive4(params.gridSize ?? DEFAULT_GRID_SIZE, "gridSize");
-  validateNonNegative4(params.lineWidth ?? DEFAULT_LINE_WIDTH, "lineWidth");
-  validateNonNegative4(params.perspective ?? DEFAULT_PERSPECTIVE, "perspective");
-};
-var GRIDLINES_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var GRIDLINES_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform vec2 uResolution;
-uniform float uGridSize;
-uniform float uLineWidth;
-uniform vec4 uLineColor;
-uniform vec4 uBackgroundColor;
-uniform float uRotation;
-uniform float uRotationX;
-uniform float uRotationY;
-uniform float uPerspective;
-uniform vec2 uOffset;
-uniform bool uMaskToSourceAlpha;
-
-vec4 sourceOver(vec4 backdrop, vec4 overlay) {
-	return overlay + backdrop * (1.0 - overlay.a);
-}
-
-vec4 sourceAtop(vec4 backdrop, vec4 overlay) {
-	return vec4(
-		overlay.rgb * backdrop.a + backdrop.rgb * (1.0 - overlay.a),
-		backdrop.a
-	);
-}
-
-mat3 rotationMatrix(float rotationX, float rotationY, float rotationZ) {
-	float sx = sin(rotationX);
-	float cx = cos(rotationX);
-	float sy = sin(rotationY);
-	float cy = cos(rotationY);
-	float sz = sin(rotationZ);
-	float cz = cos(rotationZ);
-
-	mat3 rx = mat3(
-		1.0, 0.0, 0.0,
-		0.0, cx, sx,
-		0.0, -sx, cx
-	);
-	mat3 ry = mat3(
-		cy, 0.0, -sy,
-		0.0, 1.0, 0.0,
-		sy, 0.0, cy
-	);
-	mat3 rz = mat3(
-		cz, sz, 0.0,
-		-sz, cz, 0.0,
-		0.0, 0.0, 1.0
-	);
-
-	return rz * ry * rx;
-}
-
-void main() {
-	vec4 texColor = texture(uSource, vUv);
-	vec2 centered = vUv * uResolution - uResolution * 0.5;
-	mat3 rotation = rotationMatrix(uRotationX, uRotationY, uRotation);
-	vec2 gridCoord;
-
-	if (uPerspective <= 0.0) {
-		vec3 rotated = rotation * vec3(centered, 0.0);
-		gridCoord = rotated.xy + uOffset;
-	} else {
-		vec3 camera = vec3(0.0, 0.0, uPerspective);
-		vec3 ray = normalize(vec3(centered, -uPerspective));
-		vec3 normal = rotation * vec3(0.0, 0.0, 1.0);
-		float denominator = dot(ray, normal);
-		float t = -dot(camera, normal) / denominator;
-
-		if (abs(denominator) < 0.0001 || t <= 0.0) {
-			fragColor = sourceOver(texColor, uBackgroundColor);
-			return;
-		}
-
-		vec3 worldPosition = camera + ray * t;
-		vec3 localPosition = transpose(rotation) * worldPosition;
-		gridCoord = localPosition.xy + uOffset;
-	}
-
-	float gridSize = max(uGridSize, 0.001);
-	vec2 cell = abs(fract(gridCoord / gridSize + 0.5) - 0.5) * gridSize;
-	float halfLineWidth = uLineWidth * 0.5;
-	vec2 gridUnitsPerPixel = max(fwidth(gridCoord), vec2(0.001));
-	vec2 halfWidthInGridUnits = halfLineWidth * gridUnitsPerPixel;
-	vec2 antialiasInGridUnits = gridUnitsPerPixel;
-	vec2 projectedCellSize = gridSize / gridUnitsPerPixel;
-	vec2 densityFade = smoothstep(
-		vec2(max(uLineWidth * 1.5, 1.0)),
-		vec2(max(uLineWidth * 4.0, 2.0)),
-		projectedCellSize
-	);
-	vec2 lineCoverage = halfLineWidth <= 0.001
-		? vec2(0.0)
-		: 1.0 - smoothstep(
-			halfWidthInGridUnits - antialiasInGridUnits,
-			halfWidthInGridUnits + antialiasInGridUnits,
-			cell
-		);
-	lineCoverage *= densityFade;
-	float coverage = max(lineCoverage.x, lineCoverage.y);
-
-	vec4 background = uBackgroundColor;
-	vec4 line = uLineColor * coverage;
-
-	if (uMaskToSourceAlpha) {
-		fragColor = sourceAtop(sourceAtop(texColor, background), line);
-		return;
-	}
-
-	fragColor = sourceOver(sourceOver(texColor, background), line);
-}
-`;
-var compileShader6 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Gridlines shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram6 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Gridlines program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var rgbaToUniform = (rgba) => {
-  const [r, g, b, a] = rgba;
-  const alpha = a / 255;
-  return [r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha];
-};
-var gridlines = createEffect7({
-  type: "remotion/gridlines",
-  label: "gridlines()",
-  documentationLink: "https://www.remotion.dev/docs/effects/gridlines",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve7(params);
-    const maskSuffix = r.maskToSourceAlpha ? "-mask-to-source-alpha" : "";
-    return `gridlines-${r.gridSize}-${r.lineWidth}-${r.lineColor}-${r.backgroundColor}-${r.rotation}-${r.rotationX}-${r.rotationY}-${r.perspective}-${r.offsetX}-${r.offsetY}${maskSuffix}`;
-  },
-  setup: (target) => {
-    const gl = target.getContext("webgl2", {
-      premultipliedAlpha: true,
-      alpha: true,
-      preserveDrawingBuffer: true
-    });
-    if (!gl) {
-      throw createWebGL2ContextError6("gridlines effect");
-    }
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader6(gl, gl.VERTEX_SHADER, GRIDLINES_VS);
-    const fs = compileShader6(gl, gl.FRAGMENT_SHADER, GRIDLINES_FS);
-    const program = linkProgram6(gl, vs, fs);
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    const vao = gl.createVertexArray();
-    if (!vao) {
-      throw new Error("Failed to create WebGL vertex array");
-    }
-    gl.bindVertexArray(vao);
-    const data = new Float32Array([
-      -1,
-      -1,
-      0,
-      0,
-      1,
-      -1,
-      1,
-      0,
-      -1,
-      1,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1
-    ]);
-    const vbo = gl.createBuffer();
-    if (!vbo) {
-      throw new Error("Failed to create WebGL buffer");
-    }
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    const aPos = gl.getAttribLocation(program, "aPos");
-    const aUv = gl.getAttribLocation(program, "aUv");
-    gl.enableVertexAttribArray(aPos);
-    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-    gl.enableVertexAttribArray(aUv);
-    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-    gl.bindVertexArray(null);
-    const texture = gl.createTexture();
-    if (!texture) {
-      throw new Error("Failed to create WebGL texture");
-    }
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    const colorCanvas = document.createElement("canvas");
-    colorCanvas.width = 1;
-    colorCanvas.height = 1;
-    const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-    if (!colorCtx) {
-      throw new Error("Failed to acquire 2D context for color parsing");
-    }
-    return {
-      gl,
-      program,
-      vao,
-      vbo,
-      texture,
-      uniforms: {
-        uSource: gl.getUniformLocation(program, "uSource"),
-        uResolution: gl.getUniformLocation(program, "uResolution"),
-        uGridSize: gl.getUniformLocation(program, "uGridSize"),
-        uLineWidth: gl.getUniformLocation(program, "uLineWidth"),
-        uLineColor: gl.getUniformLocation(program, "uLineColor"),
-        uBackgroundColor: gl.getUniformLocation(program, "uBackgroundColor"),
-        uRotation: gl.getUniformLocation(program, "uRotation"),
-        uRotationX: gl.getUniformLocation(program, "uRotationX"),
-        uRotationY: gl.getUniformLocation(program, "uRotationY"),
-        uPerspective: gl.getUniformLocation(program, "uPerspective"),
-        uOffset: gl.getUniformLocation(program, "uOffset"),
-        uMaskToSourceAlpha: gl.getUniformLocation(program, "uMaskToSourceAlpha")
-      },
-      colorCtx,
-      cachedLineColorStr: "",
-      cachedLineColorRgba: [255, 255, 255, 255],
-      cachedBackgroundColorStr: "",
-      cachedBackgroundColorRgba: [0, 0, 0, 0]
-    };
-  },
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve7(params);
-    const { gl, program, vao, texture, uniforms } = state;
-    if (state.cachedLineColorStr !== r.lineColor) {
-      state.cachedLineColorStr = r.lineColor;
-      state.cachedLineColorRgba = parseColorRgba(state.colorCtx, r.lineColor);
-    }
-    if (state.cachedBackgroundColorStr !== r.backgroundColor) {
-      state.cachedBackgroundColorStr = r.backgroundColor;
-      state.cachedBackgroundColorRgba = parseColorRgba(state.colorCtx, r.backgroundColor);
-    }
-    const [lineR, lineG, lineB, lineA] = rgbaToUniform(state.cachedLineColorRgba);
-    const [bgR, bgG, bgB, bgA] = rgbaToUniform(state.cachedBackgroundColorRgba);
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.useProgram(program);
-    gl.bindVertexArray(vao);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uResolution)
-      gl.uniform2f(uniforms.uResolution, width, height);
-    if (uniforms.uGridSize)
-      gl.uniform1f(uniforms.uGridSize, r.gridSize);
-    if (uniforms.uLineWidth)
-      gl.uniform1f(uniforms.uLineWidth, r.lineWidth);
-    if (uniforms.uLineColor)
-      gl.uniform4f(uniforms.uLineColor, lineR, lineG, lineB, lineA);
-    if (uniforms.uBackgroundColor)
-      gl.uniform4f(uniforms.uBackgroundColor, bgR, bgG, bgB, bgA);
-    if (uniforms.uRotation)
-      gl.uniform1f(uniforms.uRotation, r.rotation * Math.PI / 180);
-    if (uniforms.uRotationX)
-      gl.uniform1f(uniforms.uRotationX, r.rotationX * Math.PI / 180);
-    if (uniforms.uRotationY)
-      gl.uniform1f(uniforms.uRotationY, r.rotationY * Math.PI / 180);
-    if (uniforms.uPerspective)
-      gl.uniform1f(uniforms.uPerspective, r.perspective);
-    if (uniforms.uOffset)
-      gl.uniform2f(uniforms.uOffset, r.offsetX, r.offsetY);
-    if (uniforms.uMaskToSourceAlpha)
-      gl.uniform1i(uniforms.uMaskToSourceAlpha, r.maskToSourceAlpha ? 1 : 0);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, texture }) => {
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-    gl.deleteTexture(texture);
-  },
-  schema: gridlinesSchema,
-  validateParams: validateGridlinesParams
-});
-// src/zigzag.ts
-import { Internals as Internals8 } from "remotion";
-var { createEffect: createEffect8, createWebGL2ContextError: createWebGL2ContextError7 } = Internals8;
-var ZIGZAG_DIRECTIONS = ["horizontal", "vertical"];
-var DEFAULT_COLORS3 = ["#dff4ff", "#7cc6ff"];
-var DEFAULT_DIRECTION = "horizontal";
-var DEFAULT_THICKNESS2 = 40;
-var DEFAULT_GAP4 = 0;
-var DEFAULT_ANGLE2 = 0;
-var DEFAULT_OFFSET3 = 0;
-var DEFAULT_AMPLITUDE = 40;
-var DEFAULT_WAVELENGTH = 160;
-var DEFAULT_MASK_TO_SOURCE_ALPHA4 = false;
-var zigzagSchema = {
-  colors: {
-    type: "array",
-    item: {
-      type: "color"
-    },
-    default: DEFAULT_COLORS3,
-    minLength: 2,
-    newItemDefault: "#ff0000",
-    description: "Colors",
-    keyframable: false
-  },
-  direction: {
-    type: "enum",
-    variants: {
-      horizontal: {},
-      vertical: {}
-    },
-    default: DEFAULT_DIRECTION,
-    description: "Direction"
-  },
-  thickness: {
-    type: "number",
-    min: 0.1,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_THICKNESS2,
-    description: "Thickness",
-    hiddenFromList: false
-  },
-  gap: {
-    type: "number",
-    min: 0,
-    max: 400,
-    step: 0.1,
-    default: DEFAULT_GAP4,
-    description: "Gap",
-    hiddenFromList: false
-  },
-  angle: {
-    type: "rotation-degrees",
-    step: 1,
-    default: DEFAULT_ANGLE2,
-    description: "Angle"
-  },
-  offset: {
-    type: "number",
-    step: 0.1,
-    default: DEFAULT_OFFSET3,
-    description: "Offset",
-    hiddenFromList: false
-  },
-  amplitude: {
-    type: "number",
-    min: 0,
-    max: 500,
-    step: 0.1,
-    default: DEFAULT_AMPLITUDE,
-    description: "Amplitude",
-    hiddenFromList: false
-  },
-  wavelength: {
-    type: "number",
-    min: 1,
-    max: 2000,
-    step: 1,
-    default: DEFAULT_WAVELENGTH,
-    description: "Wavelength",
-    hiddenFromList: false
-  },
-  maskToSourceAlpha: {
-    type: "boolean",
-    default: DEFAULT_MASK_TO_SOURCE_ALPHA4,
-    description: "Mask to source alpha"
-  }
-};
-var resolve8 = (p) => {
-  const thickness = p.thickness ?? DEFAULT_THICKNESS2;
-  const gap = p.gap ?? DEFAULT_GAP4;
-  return {
-    colors: p.colors ?? DEFAULT_COLORS3,
-    direction: p.direction ?? DEFAULT_DIRECTION,
-    thickness,
-    spacing: thickness + gap,
-    angle: p.angle ?? DEFAULT_ANGLE2,
-    offset: p.offset ?? DEFAULT_OFFSET3,
-    amplitude: p.amplitude ?? DEFAULT_AMPLITUDE,
-    wavelength: p.wavelength ?? DEFAULT_WAVELENGTH,
-    maskToSourceAlpha: p.maskToSourceAlpha ?? DEFAULT_MASK_TO_SOURCE_ALPHA4
-  };
-};
-var formatEnum = (variants) => {
-  if (variants.length === 2) {
-    return `"${variants[0]}" or "${variants[1]}"`;
-  }
-  return `${variants.slice(0, -1).map((variant) => `"${variant}"`).join(", ")} or "${variants[variants.length - 1]}"`;
-};
-var validatePositive5 = (value, name) => {
-  if (value <= 0) {
-    throw new TypeError(`"${name}" must be greater than 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateNonNegative5 = (value, name) => {
-  if (value < 0) {
-    throw new TypeError(`"${name}" must be greater than or equal to 0, but got ${JSON.stringify(value)}`);
-  }
-};
-var validateColors3 = (colors) => {
-  if (colors === undefined) {
-    return;
-  }
-  if (!Array.isArray(colors) || colors.length < 2) {
-    throw new TypeError(`"colors" must be an array with at least 2 colors, but got ${JSON.stringify(colors)}`);
-  }
-  for (let i = 0;i < colors.length; i++) {
-    assertRequiredColor(colors[i], `colors[${i}]`);
-  }
-};
-var validateDirection = (direction) => {
-  if (direction === undefined) {
-    return;
-  }
-  if (typeof direction !== "string" || !ZIGZAG_DIRECTIONS.includes(direction)) {
-    throw new TypeError(`"direction" must be ${formatEnum(ZIGZAG_DIRECTIONS)}, but got ${JSON.stringify(direction)}`);
-  }
-};
-var validateZigzagParams = (params) => {
-  assertEffectParamsObject(params, "Zigzag");
-  validateColors3(params.colors);
-  validateDirection(params.direction);
-  assertOptionalFiniteNumber(params.thickness, "thickness");
-  assertOptionalFiniteNumber(params.gap, "gap");
-  assertOptionalFiniteNumber(params.angle, "angle");
-  assertOptionalFiniteNumber(params.offset, "offset");
-  assertOptionalFiniteNumber(params.amplitude, "amplitude");
-  assertOptionalFiniteNumber(params.wavelength, "wavelength");
-  assertOptionalBoolean(params.maskToSourceAlpha, "maskToSourceAlpha");
-  const thickness = params.thickness ?? DEFAULT_THICKNESS2;
-  const gap = params.gap ?? DEFAULT_GAP4;
-  const amplitude = params.amplitude ?? DEFAULT_AMPLITUDE;
-  const wavelength = params.wavelength ?? DEFAULT_WAVELENGTH;
-  validatePositive5(thickness, "thickness");
-  validateNonNegative5(gap, "gap");
-  validateNonNegative5(amplitude, "amplitude");
-  validatePositive5(wavelength, "wavelength");
-};
-var ZIGZAG_VS = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var ZIGZAG_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform sampler2D uPalette;
-uniform vec2 uResolution;
-uniform float uNumColors;
-uniform int uDirection;
-uniform float uThickness;
-uniform float uSpacing;
-uniform float uAngle;
-uniform float uOffset;
-uniform float uAmplitude;
-uniform float uWavelength;
-uniform bool uMaskToSourceAlpha;
-
-void main() {
-	vec4 texColor = texture(uSource, vUv);
-	float thickness = max(uThickness, 0.001);
-	float spacing = max(uSpacing, 0.001);
-	float cycle = spacing * uNumColors;
-	vec2 centered = vUv * uResolution - uResolution * 0.5;
-	float s = sin(uAngle);
-	float c = cos(uAngle);
-	vec2 rotated = vec2(
-		centered.x * c - centered.y * s,
-		centered.x * s + centered.y * c
-	);
-	float baseAxis = uDirection == 0 ? rotated.y : rotated.x;
-	float zigzagAxis = uDirection == 0 ? rotated.x : rotated.y;
-	float wavePhase = fract(zigzagAxis / max(uWavelength, 0.001));
-	float zigzagOffset = (1.0 - abs(wavePhase * 2.0 - 1.0) * 2.0) * uAmplitude;
-	float position = mod(baseAxis + zigzagOffset + uOffset, cycle);
-	if (position < 0.0) {
-		position += cycle;
-	}
-
-	float colorIndex = floor(position / spacing);
-	float inStripe = mod(position, spacing);
-	if (inStripe > thickness) {
-		fragColor = texColor;
-		return;
-	}
-
-	float texCoord = (colorIndex + 0.5) / uNumColors;
-	vec4 lineColor = texture(uPalette, vec2(texCoord, 0.5));
-	float lineAlpha = lineColor.a;
-	vec3 premultipliedLine = lineColor.rgb * lineAlpha;
-
-	if (uMaskToSourceAlpha) {
-		fragColor = vec4(
-			premultipliedLine * texColor.a + texColor.rgb * (1.0 - lineAlpha),
-			texColor.a
-		);
-		return;
-	}
-
-	fragColor = vec4(
-		premultipliedLine + texColor.rgb * (1.0 - lineAlpha),
-		lineAlpha + texColor.a * (1.0 - lineAlpha)
-	);
-}
-`;
-var compileShader7 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Zigzag shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram7 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Zigzag program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var createProgram3 = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader7(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader7(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram7(gl, vs, fs);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  return program;
-};
-var createTexture3 = (gl, filter) => {
-  const texture = gl.createTexture();
-  if (!texture) {
-    throw new Error("Failed to create WebGL texture");
-  }
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  return texture;
-};
-var setupZigzag = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError7("zigzag effect");
-  }
-  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-  const program = createProgram3(gl, ZIGZAG_VS, ZIGZAG_FS);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  const aPos = gl.getAttribLocation(program, "aPos");
-  const aUv = gl.getAttribLocation(program, "aUv");
-  gl.enableVertexAttribArray(aPos);
-  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(aUv);
-  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const colorCanvas = document.createElement("canvas");
-  colorCanvas.width = 1;
-  colorCanvas.height = 1;
-  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-  if (!colorCtx) {
-    throw new Error("Failed to acquire 2D context for color parsing");
-  }
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    sourceTexture: createTexture3(gl, gl.LINEAR),
-    paletteTexture: createTexture3(gl, gl.NEAREST),
-    colorCtx,
-    uniforms: {
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uPalette: gl.getUniformLocation(program, "uPalette"),
-      uResolution: gl.getUniformLocation(program, "uResolution"),
-      uNumColors: gl.getUniformLocation(program, "uNumColors"),
-      uDirection: gl.getUniformLocation(program, "uDirection"),
-      uThickness: gl.getUniformLocation(program, "uThickness"),
-      uSpacing: gl.getUniformLocation(program, "uSpacing"),
-      uAngle: gl.getUniformLocation(program, "uAngle"),
-      uOffset: gl.getUniformLocation(program, "uOffset"),
-      uAmplitude: gl.getUniformLocation(program, "uAmplitude"),
-      uWavelength: gl.getUniformLocation(program, "uWavelength"),
-      uMaskToSourceAlpha: gl.getUniformLocation(program, "uMaskToSourceAlpha")
-    },
-    cachedPaletteKey: "",
-    palettePixelData: new Uint8Array(0)
-  };
-};
-var updatePalette3 = (state, colors) => {
-  const paletteKey = colors.join("|");
-  const paletteDirty = state.cachedPaletteKey !== paletteKey;
-  if (!paletteDirty) {
-    return false;
-  }
-  state.cachedPaletteKey = paletteKey;
-  const len = colors.length * 4;
-  if (state.palettePixelData.length !== len) {
-    state.palettePixelData = new Uint8Array(len);
-  }
-  const { palettePixelData } = state;
-  for (let i = 0;i < colors.length; i++) {
-    const color = parseColorRgba(state.colorCtx, colors[i]);
-    palettePixelData[i * 4] = color[0];
-    palettePixelData[i * 4 + 1] = color[1];
-    palettePixelData[i * 4 + 2] = color[2];
-    palettePixelData[i * 4 + 3] = color[3];
-  }
-  return true;
-};
-var zigzag = createEffect8({
-  type: "dev.remotion.effects.zigzag",
-  label: "zigzag()",
-  documentationLink: "https://www.remotion.dev/docs/effects/zigzag",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve8(params);
-    const maskSuffix = r.maskToSourceAlpha ? "-mask-to-source-alpha" : "";
-    return `zigzag-${r.colors.join("|")}-${r.direction}-${r.thickness}-${r.spacing}-${r.angle}-${r.offset}-${r.amplitude}-${r.wavelength}${maskSuffix}`;
-  },
-  setup: (target) => setupZigzag(target),
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve8(params);
-    const paletteDirty = updatePalette3(state, r.colors);
-    const { gl, program, sourceTexture, paletteTexture, uniforms, vao } = state;
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, sourceTexture);
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    gl.activeTexture(gl.TEXTURE1);
-    gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
-    if (paletteDirty) {
-      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, r.colors.length, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, state.palettePixelData);
-      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    }
-    gl.useProgram(program);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uPalette)
-      gl.uniform1i(uniforms.uPalette, 1);
-    if (uniforms.uResolution)
-      gl.uniform2f(uniforms.uResolution, width, height);
-    if (uniforms.uNumColors)
-      gl.uniform1f(uniforms.uNumColors, r.colors.length);
-    if (uniforms.uDirection)
-      gl.uniform1i(uniforms.uDirection, r.direction === "horizontal" ? 0 : 1);
-    if (uniforms.uThickness)
-      gl.uniform1f(uniforms.uThickness, r.thickness);
-    if (uniforms.uSpacing)
-      gl.uniform1f(uniforms.uSpacing, r.spacing);
-    if (uniforms.uAngle)
-      gl.uniform1f(uniforms.uAngle, r.angle * Math.PI / 180);
-    if (uniforms.uOffset)
-      gl.uniform1f(uniforms.uOffset, r.offset);
-    if (uniforms.uAmplitude)
-      gl.uniform1f(uniforms.uAmplitude, r.amplitude);
-    if (uniforms.uWavelength)
-      gl.uniform1f(uniforms.uWavelength, r.wavelength);
-    if (uniforms.uMaskToSourceAlpha)
-      gl.uniform1i(uniforms.uMaskToSourceAlpha, r.maskToSourceAlpha ? 1 : 0);
-    gl.bindVertexArray(vao);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({
-    gl,
-    program,
-    vao,
-    vbo,
-    sourceTexture,
-    paletteTexture
-  }) => {
-    gl.deleteTexture(sourceTexture);
-    gl.deleteTexture(paletteTexture);
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-  },
-  schema: zigzagSchema,
-  validateParams: validateZigzagParams
-});
-// src/linear-gradient.ts
-import { Internals as Internals9 } from "remotion";
-var { createEffect: createEffect9, createWebGL2ContextError: createWebGL2ContextError8 } = Internals9;
-var DEFAULT_START = [0, 0.5];
-var DEFAULT_END = [1, 0.5];
-var DEFAULT_START_COLOR = "#000000";
-var DEFAULT_END_COLOR = "#ffffff";
-var linearGradientSchema = {
-  start: {
-    type: "uv-coordinate",
-    min: -1,
-    max: 2,
-    step: 0.01,
-    default: DEFAULT_START,
-    description: "Start",
-    visual: {
-      type: "line",
-      to: "end"
-    }
-  },
-  end: {
-    type: "uv-coordinate",
-    min: -1,
-    max: 2,
-    step: 0.01,
-    default: DEFAULT_END,
-    description: "End"
-  },
-  startColor: {
-    type: "color",
-    default: DEFAULT_START_COLOR,
-    description: "Start color"
-  },
-  endColor: {
-    type: "color",
-    default: DEFAULT_END_COLOR,
-    description: "End color"
-  }
-};
-var resolve9 = (p) => ({
-  start: [...p.start ?? DEFAULT_START],
-  end: [...p.end ?? DEFAULT_END],
-  startColor: p.startColor ?? DEFAULT_START_COLOR,
-  endColor: p.endColor ?? DEFAULT_END_COLOR
-});
-var assertOptionalUvCoordinate2 = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
-    throw new TypeError(`"${name}" must be a [number, number] tuple`);
-  }
-};
-var validateLinearGradientParams = (params) => {
-  assertEffectParamsObject(params, "Linear gradient");
-  assertOptionalUvCoordinate2(params.start, "start");
-  assertOptionalUvCoordinate2(params.end, "end");
-  assertOptionalColor(params.startColor, "startColor");
-  assertOptionalColor(params.endColor, "endColor");
-};
-var VERTEX_SHADER = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var FRAGMENT_SHADER = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform vec2 uStart;
-uniform vec2 uEnd;
-uniform vec4 uStartColor;
-uniform vec4 uEndColor;
-
-float gradientProgress(vec2 uv) {
-	vec2 gradient = uEnd - uStart;
-	float gradientLengthSq = dot(gradient, gradient);
-	if (gradientLengthSq <= 0.0000001) {
-		return 0.0;
-	}
-
-	return clamp(dot(uv - uStart, gradient) / gradientLengthSq, 0.0, 1.0);
-}
-
-void main() {
-	vec2 publicUv = vec2(vUv.x, 1.0 - vUv.y);
-	vec4 color = mix(uStartColor, uEndColor, gradientProgress(publicUv));
-	fragColor = vec4(color.rgb * color.a, color.a);
-}
-`;
-var compileShader8 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Linear gradient shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var createProgram4 = (gl) => {
-  const vs = compileShader8(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
-  const fs = compileShader8(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Linear gradient program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var setupLinearGradient = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError8("linear gradient effect");
-  }
-  const program = createProgram4(gl);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  const aPos = gl.getAttribLocation(program, "aPos");
-  const aUv = gl.getAttribLocation(program, "aUv");
-  gl.enableVertexAttribArray(aPos);
-  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(aUv);
-  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const colorCanvas = document.createElement("canvas");
-  colorCanvas.width = 1;
-  colorCanvas.height = 1;
-  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-  if (!colorCtx) {
-    throw new Error("Failed to acquire 2D context for color parsing");
-  }
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    uniforms: {
-      uStart: gl.getUniformLocation(program, "uStart"),
-      uEnd: gl.getUniformLocation(program, "uEnd"),
-      uStartColor: gl.getUniformLocation(program, "uStartColor"),
-      uEndColor: gl.getUniformLocation(program, "uEndColor")
-    },
-    colorCtx,
-    cachedStartColor: "",
-    cachedStartColorRgba: [0, 0, 0, 255],
-    cachedEndColor: "",
-    cachedEndColorRgba: [255, 255, 255, 255]
-  };
-};
-var normalizedRgba = (color) => {
-  return [color[0] / 255, color[1] / 255, color[2] / 255, color[3] / 255];
-};
-var getParsedColors = (state, resolved) => {
-  if (state.cachedStartColor !== resolved.startColor) {
-    state.cachedStartColor = resolved.startColor;
-    state.cachedStartColorRgba = parseColorRgba(state.colorCtx, resolved.startColor);
-  }
-  if (state.cachedEndColor !== resolved.endColor) {
-    state.cachedEndColor = resolved.endColor;
-    state.cachedEndColorRgba = parseColorRgba(state.colorCtx, resolved.endColor);
-  }
-  return {
-    start: state.cachedStartColorRgba,
-    end: state.cachedEndColorRgba
-  };
-};
-var linearGradient = createEffect9({
-  type: "dev.remotion.effects.linearGradient",
-  label: "linearGradient()",
-  documentationLink: "https://www.remotion.dev/docs/effects/linear-gradient",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve9(params);
-    return `linear-gradient-${r.start.join(":")}-${r.end.join(":")}-${r.startColor}-${r.endColor}`;
-  },
-  setup: (target) => setupLinearGradient(target),
-  apply: ({ width, height, params, state }) => {
-    const r = resolve9(params);
-    const { start, end } = getParsedColors(state, r);
-    const [sr, sg, sb, sa] = normalizedRgba(start);
-    const [er, eg, eb, ea] = normalizedRgba(end);
-    const { gl, program, uniforms, vao } = state;
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.useProgram(program);
-    if (uniforms.uStart)
-      gl.uniform2f(uniforms.uStart, r.start[0], r.start[1]);
-    if (uniforms.uEnd)
-      gl.uniform2f(uniforms.uEnd, r.end[0], r.end[1]);
-    if (uniforms.uStartColor) {
-      gl.uniform4f(uniforms.uStartColor, sr, sg, sb, sa);
-    }
-    if (uniforms.uEndColor) {
-      gl.uniform4f(uniforms.uEndColor, er, eg, eb, ea);
-    }
-    gl.bindVertexArray(vao);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo }) => {
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-  },
-  schema: linearGradientSchema,
-  validateParams: validateLinearGradientParams
-});
-// src/linear-gradient-tint.ts
-import { Internals as Internals10 } from "remotion";
-var { createEffect: createEffect10, createWebGL2ContextError: createWebGL2ContextError9 } = Internals10;
-var DEFAULT_START2 = [0, 0.5];
-var DEFAULT_END2 = [1, 0.5];
-var DEFAULT_START_COLOR2 = "#000000";
-var DEFAULT_END_COLOR2 = "#ffffff";
-var DEFAULT_AMOUNT2 = 0.5;
-var linearGradientTintSchema = {
-  start: {
-    type: "uv-coordinate",
-    min: -1,
-    max: 2,
-    step: 0.01,
-    default: DEFAULT_START2,
-    description: "Start",
-    visual: {
-      type: "line",
-      to: "end"
-    }
-  },
-  end: {
-    type: "uv-coordinate",
-    min: -1,
-    max: 2,
-    step: 0.01,
-    default: DEFAULT_END2,
-    description: "End"
-  },
-  startColor: {
-    type: "color",
-    default: DEFAULT_START_COLOR2,
-    description: "Start color"
-  },
-  endColor: {
-    type: "color",
-    default: DEFAULT_END_COLOR2,
-    description: "End color"
-  },
-  amount: {
-    type: "number",
-    min: 0,
-    max: 1,
-    step: 0.01,
-    default: DEFAULT_AMOUNT2,
-    description: "Amount",
-    hiddenFromList: false
-  }
-};
-var resolve10 = (p) => ({
-  start: [...p.start ?? DEFAULT_START2],
-  end: [...p.end ?? DEFAULT_END2],
-  startColor: p.startColor ?? DEFAULT_START_COLOR2,
-  endColor: p.endColor ?? DEFAULT_END_COLOR2,
-  amount: p.amount ?? DEFAULT_AMOUNT2
-});
-var assertOptionalUvCoordinate3 = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
-    throw new TypeError(`"${name}" must be a [number, number] tuple`);
-  }
-};
-var validateLinearGradientTintParams = (params) => {
-  assertEffectParamsObject(params, "Linear gradient tint");
-  assertOptionalUvCoordinate3(params.start, "start");
-  assertOptionalUvCoordinate3(params.end, "end");
-  assertOptionalColor(params.startColor, "startColor");
-  assertOptionalColor(params.endColor, "endColor");
-  assertOptionalFiniteNumber(params.amount, "amount");
-  validateUnitInterval(resolve10(params).amount, "amount");
-};
-var VERTEX_SHADER2 = `#version 300 es
-in vec2 aPos;
-in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var FRAGMENT_SHADER2 = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform vec2 uStart;
-uniform vec2 uEnd;
-uniform vec4 uStartColor;
-uniform vec4 uEndColor;
-uniform float uAmount;
-
-float gradientProgress(vec2 uv) {
-	vec2 gradient = uEnd - uStart;
-	float gradientLengthSq = dot(gradient, gradient);
-	if (gradientLengthSq <= 0.0000001) {
-		return 0.0;
-	}
-
-	return clamp(dot(uv - uStart, gradient) / gradientLengthSq, 0.0, 1.0);
-}
-
-void main() {
-	vec4 texColor = texture(uSource, vUv);
-	float alpha = texColor.a;
-
-	if (alpha <= 0.001) {
-		fragColor = vec4(0.0);
-		return;
-	}
-
-	vec2 publicUv = vec2(vUv.x, 1.0 - vUv.y);
-	vec4 tintColor = mix(uStartColor, uEndColor, gradientProgress(publicUv));
-	vec3 sourceRgb = texColor.rgb / alpha;
-	vec3 blended = mix(sourceRgb, tintColor.rgb, uAmount * tintColor.a);
-
-	fragColor = vec4(blended * alpha, alpha);
-}
-`;
-var compileShader9 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Linear gradient tint shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var createProgram5 = (gl) => {
-  const vs = compileShader9(gl, gl.VERTEX_SHADER, VERTEX_SHADER2);
-  const fs = compileShader9(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER2);
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Linear gradient tint program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var createRgbaTexture = (gl) => {
-  const texture = gl.createTexture();
-  if (!texture) {
-    throw new Error("Failed to create WebGL texture");
-  }
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  return texture;
-};
-var setupLinearGradientTint = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError9("linear gradient tint effect");
-  }
-  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-  const program = createProgram5(gl);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  const aPos = gl.getAttribLocation(program, "aPos");
-  const aUv = gl.getAttribLocation(program, "aUv");
-  gl.enableVertexAttribArray(aPos);
-  gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(aUv);
-  gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const textureSource = createRgbaTexture(gl);
-  const colorCanvas = document.createElement("canvas");
-  colorCanvas.width = 1;
-  colorCanvas.height = 1;
-  const colorCtx = colorCanvas.getContext("2d", { willReadFrequently: true });
-  if (!colorCtx) {
-    throw new Error("Failed to acquire 2D context for color parsing");
-  }
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    textureSource,
-    uniforms: {
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uStart: gl.getUniformLocation(program, "uStart"),
-      uEnd: gl.getUniformLocation(program, "uEnd"),
-      uStartColor: gl.getUniformLocation(program, "uStartColor"),
-      uEndColor: gl.getUniformLocation(program, "uEndColor"),
-      uAmount: gl.getUniformLocation(program, "uAmount")
-    },
-    colorCtx,
-    cachedStartColor: "",
-    cachedStartColorRgba: [0, 0, 0, 255],
-    cachedEndColor: "",
-    cachedEndColorRgba: [255, 255, 255, 255]
-  };
-};
-var normalizedRgba2 = (color) => {
-  return [color[0] / 255, color[1] / 255, color[2] / 255, color[3] / 255];
-};
-var getParsedColors2 = (state, resolved) => {
-  if (state.cachedStartColor !== resolved.startColor) {
-    state.cachedStartColor = resolved.startColor;
-    state.cachedStartColorRgba = parseColorRgba(state.colorCtx, resolved.startColor);
-  }
-  if (state.cachedEndColor !== resolved.endColor) {
-    state.cachedEndColor = resolved.endColor;
-    state.cachedEndColorRgba = parseColorRgba(state.colorCtx, resolved.endColor);
-  }
-  return {
-    start: state.cachedStartColorRgba,
-    end: state.cachedEndColorRgba
-  };
-};
-var linearGradientTint = createEffect10({
-  type: "dev.remotion.effects.linearGradientTint",
-  label: "linearGradientTint()",
-  documentationLink: "https://www.remotion.dev/docs/effects/linear-gradient-tint",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve10(params);
-    return `linear-gradient-tint-${r.start.join(":")}-${r.end.join(":")}-${r.startColor}-${r.endColor}-${r.amount}`;
-  },
-  setup: (target) => setupLinearGradientTint(target),
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve10(params);
-    const { start, end } = getParsedColors2(state, r);
-    const [sr, sg, sb, sa] = normalizedRgba2(start);
-    const [er, eg, eb, ea] = normalizedRgba2(end);
-    const { gl, program, textureSource, uniforms, vao } = state;
-    gl.viewport(0, 0, width, height);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.clearColor(0, 0, 0, 0);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, textureSource);
-    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-    gl.useProgram(program);
-    if (uniforms.uSource)
-      gl.uniform1i(uniforms.uSource, 0);
-    if (uniforms.uStart)
-      gl.uniform2f(uniforms.uStart, r.start[0], r.start[1]);
-    if (uniforms.uEnd)
-      gl.uniform2f(uniforms.uEnd, r.end[0], r.end[1]);
-    if (uniforms.uStartColor) {
-      gl.uniform4f(uniforms.uStartColor, sr, sg, sb, sa);
-    }
-    if (uniforms.uEndColor) {
-      gl.uniform4f(uniforms.uEndColor, er, eg, eb, ea);
-    }
-    if (uniforms.uAmount)
-      gl.uniform1f(uniforms.uAmount, r.amount);
-    gl.bindVertexArray(vao);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    gl.bindVertexArray(null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    gl.useProgram(null);
-  },
-  cleanup: ({ gl, program, vao, vbo, textureSource }) => {
-    gl.deleteTexture(textureSource);
-    gl.deleteBuffer(vbo);
-    gl.deleteProgram(program);
-    gl.deleteVertexArray(vao);
-  },
-  schema: linearGradientTintSchema,
-  validateParams: validateLinearGradientTintParams
-});
-// src/corner-pin/index.ts
-import { Internals as Internals12 } from "remotion";
-
-// src/corner-pin/corner-pin-runtime.ts
-import { Internals as Internals11 } from "remotion";
-
-// src/corner-pin/corner-pin-shaders.ts
-var CORNER_PIN_VS = `#version 300 es
-layout(location = 0) in vec2 aPos;
-layout(location = 1) in vec2 aUv;
-out vec2 vUv;
-
-void main() {
-	vUv = aUv;
-	gl_Position = vec4(aPos, 0.0, 1.0);
-}
-`;
-var CORNER_PIN_FS = `#version 300 es
-precision highp float;
-
-in vec2 vUv;
-out vec4 fragColor;
-
-uniform sampler2D uSource;
-uniform vec2 uTopLeft;
-uniform vec2 uTopRight;
-uniform vec2 uBottomRight;
-uniform vec2 uBottomLeft;
-
-bool solveProjectiveInverse(vec2 p, out vec2 uv) {
-	vec2 p0 = uBottomLeft;
-	vec2 p1 = uBottomRight;
-	vec2 p2 = uTopRight;
-	vec2 p3 = uTopLeft;
-
-	vec2 dx1 = p1 - p2;
-	vec2 dx2 = p3 - p2;
-	vec2 dx3 = p0 - p1 + p2 - p3;
-
-	float g = 0.0;
-	float h = 0.0;
-
-	if (abs(dx3.x) > 0.000001 || abs(dx3.y) > 0.000001) {
-		float denominator = dx1.x * dx2.y - dx2.x * dx1.y;
-		if (abs(denominator) < 0.000001) {
-			return false;
-		}
-
-		g = (dx3.x * dx2.y - dx2.x * dx3.y) / denominator;
-		h = (dx1.x * dx3.y - dx3.x * dx1.y) / denominator;
-	}
-
-	float a = p1.x - p0.x + g * p1.x;
-	float b = p3.x - p0.x + h * p3.x;
-	float c = p0.x;
-	float d = p1.y - p0.y + g * p1.y;
-	float e = p3.y - p0.y + h * p3.y;
-	float f = p0.y;
-
-	float inverseX =
-		(e - f * h) * p.x +
-		(c * h - b) * p.y +
-		(b * f - c * e);
-	float inverseY =
-		(f * g - d) * p.x +
-		(a - c * g) * p.y +
-		(c * d - a * f);
-	float inverseW =
-		(d * h - e * g) * p.x +
-		(b * g - a * h) * p.y +
-		(a * e - b * d);
-
-	if (abs(inverseW) < 0.000001) {
-		return false;
-	}
-
-	uv = vec2(inverseX / inverseW, inverseY / inverseW);
-	return true;
-}
-
-void main() {
-	vec2 sourceUv;
-	if (!solveProjectiveInverse(vUv, sourceUv)) {
-		fragColor = vec4(0.0);
-		return;
-	}
-
-	if (
-		sourceUv.x < 0.0 ||
-		sourceUv.x > 1.0 ||
-		sourceUv.y < 0.0 ||
-		sourceUv.y > 1.0
-	) {
-		fragColor = vec4(0.0);
-		return;
-	}
-
-	fragColor = texture(uSource, sourceUv);
-}
-`;
-
-// src/corner-pin/corner-pin-runtime.ts
-var { createWebGL2ContextError: createWebGL2ContextError10 } = Internals11;
-var compileShader10 = (gl, type, source) => {
-  const shader = gl.createShader(type);
-  if (!shader) {
-    throw new Error("Failed to create WebGL shader");
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const log = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(`Shader compile failed: ${log ?? "(no log)"}`);
-  }
-  return shader;
-};
-var linkProgram8 = (gl, vs, fs) => {
-  const program = gl.createProgram();
-  if (!program) {
-    throw new Error("Failed to create WebGL program");
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const log = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    throw new Error(`Program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var createProgram6 = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader10(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader10(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram8(gl, vs, fs);
-  gl.deleteShader(vs);
-  gl.deleteShader(fs);
-  return program;
-};
-var createRgbaTexture2 = (gl) => {
-  const texture = gl.createTexture();
-  if (!texture) {
-    throw new Error("Failed to create WebGL texture");
-  }
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  return texture;
-};
-var setupCornerPin = (target) => {
-  const gl = target.getContext("webgl2", {
-    premultipliedAlpha: true,
-    alpha: true,
-    preserveDrawingBuffer: true
-  });
-  if (!gl) {
-    throw createWebGL2ContextError10("corner pin effect");
-  }
-  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-  const program = createProgram6(gl, CORNER_PIN_VS, CORNER_PIN_FS);
-  const vao = gl.createVertexArray();
-  if (!vao) {
-    throw new Error("Failed to create WebGL vertex array");
-  }
-  gl.bindVertexArray(vao);
-  const data = new Float32Array([
-    -1,
-    -1,
-    0,
-    0,
-    1,
-    -1,
-    1,
-    0,
-    -1,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1
-  ]);
-  const vbo = gl.createBuffer();
-  if (!vbo) {
-    throw new Error("Failed to create WebGL buffer");
-  }
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-  gl.enableVertexAttribArray(0);
-  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 16, 0);
-  gl.enableVertexAttribArray(1);
-  gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 16, 8);
-  gl.bindVertexArray(null);
-  const textureSource = createRgbaTexture2(gl);
-  return {
-    gl,
-    program,
-    vao,
-    vbo,
-    textureSource,
-    uniforms: {
-      uSource: gl.getUniformLocation(program, "uSource"),
-      uTopLeft: gl.getUniformLocation(program, "uTopLeft"),
-      uTopRight: gl.getUniformLocation(program, "uTopRight"),
-      uBottomRight: gl.getUniformLocation(program, "uBottomRight"),
-      uBottomLeft: gl.getUniformLocation(program, "uBottomLeft")
-    }
-  };
-};
-var cleanupCornerPin = (state) => {
-  const { gl, program, vao, vbo, textureSource } = state;
-  gl.deleteTexture(textureSource);
-  gl.deleteBuffer(vbo);
-  gl.deleteProgram(program);
-  gl.deleteVertexArray(vao);
-};
-var drawFullscreenQuad = (state) => {
-  const { gl, vao } = state;
-  gl.bindVertexArray(vao);
-  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-  gl.bindVertexArray(null);
-};
-var setUvUniform = (gl, location, uv) => {
-  if (!location) {
-    return;
-  }
-  const shaderUv = publicUvToShaderUv(uv);
-  gl.uniform2f(location, shaderUv[0], shaderUv[1]);
-};
-var applyCornerPin = ({
-  state,
-  source,
-  width,
-  height,
-  topLeft,
-  topRight,
-  bottomRight,
-  bottomLeft,
-  flipSourceY
-}) => {
-  const { gl, program, textureSource, uniforms } = state;
-  gl.viewport(0, 0, width, height);
-  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
-  gl.bindTexture(gl.TEXTURE_2D, textureSource);
-  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-  gl.clearColor(0, 0, 0, 0);
-  gl.clear(gl.COLOR_BUFFER_BIT);
-  gl.useProgram(program);
-  if (uniforms.uSource)
-    gl.uniform1i(uniforms.uSource, 0);
-  setUvUniform(gl, uniforms.uTopLeft, topLeft);
-  setUvUniform(gl, uniforms.uTopRight, topRight);
-  setUvUniform(gl, uniforms.uBottomRight, bottomRight);
-  setUvUniform(gl, uniforms.uBottomLeft, bottomLeft);
-  gl.activeTexture(gl.TEXTURE0);
-  gl.bindTexture(gl.TEXTURE_2D, textureSource);
-  drawFullscreenQuad(state);
-  gl.bindTexture(gl.TEXTURE_2D, null);
-  gl.useProgram(null);
-};
-
-// src/corner-pin/index.ts
-var { createEffect: createEffect11 } = Internals12;
-var DEFAULT_TOP_LEFT = [0, 0];
-var DEFAULT_TOP_RIGHT = [1, 0];
-var DEFAULT_BOTTOM_RIGHT = [1, 1];
-var DEFAULT_BOTTOM_LEFT = [0, 1];
-var cornerSchema = (defaultValue) => ({
-  type: "uv-coordinate",
-  min: -1,
-  max: 2,
-  step: 0.01,
-  default: defaultValue,
-  description: "Corner"
-});
-var cornerPinSchema = {
-  topLeft: {
-    ...cornerSchema(DEFAULT_TOP_LEFT),
-    description: "Top left"
-  },
-  topRight: {
-    ...cornerSchema(DEFAULT_TOP_RIGHT),
-    description: "Top right"
-  },
-  bottomRight: {
-    ...cornerSchema(DEFAULT_BOTTOM_RIGHT),
-    description: "Bottom right"
-  },
-  bottomLeft: {
-    ...cornerSchema(DEFAULT_BOTTOM_LEFT),
-    description: "Bottom left"
-  }
-};
-var resolve11 = (p) => ({
-  topLeft: [...p.topLeft ?? DEFAULT_TOP_LEFT],
-  topRight: [...p.topRight ?? DEFAULT_TOP_RIGHT],
-  bottomRight: [
-    ...p.bottomRight ?? DEFAULT_BOTTOM_RIGHT
-  ],
-  bottomLeft: [
-    ...p.bottomLeft ?? DEFAULT_BOTTOM_LEFT
-  ]
-});
-var assertOptionalUvCoordinate4 = (value, name) => {
-  if (value === undefined) {
-    return;
-  }
-  if (!Array.isArray(value) || value.length !== 2 || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
-    throw new TypeError(`"${name}" must be a [number, number] tuple`);
-  }
-};
-var validateCornerPinParams = (params) => {
-  assertEffectParamsObject(params, "Corner pin");
-  assertOptionalUvCoordinate4(params.topLeft, "topLeft");
-  assertOptionalUvCoordinate4(params.topRight, "topRight");
-  assertOptionalUvCoordinate4(params.bottomRight, "bottomRight");
-  assertOptionalUvCoordinate4(params.bottomLeft, "bottomLeft");
-};
-var cornerPin = createEffect11({
-  type: "dev.remotion.effects.cornerPin",
-  label: "cornerPin()",
-  documentationLink: "https://www.remotion.dev/docs/effects/corner-pin",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve11(params);
-    return `corner-pin-${r.topLeft.join(":")}-${r.topRight.join(":")}-${r.bottomRight.join(":")}-${r.bottomLeft.join(":")}`;
-  },
-  setup: (target) => setupCornerPin(target),
-  apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve11(params);
-    applyCornerPin({
-      state,
-      source,
-      width,
-      height,
-      topLeft: r.topLeft,
-      topRight: r.topRight,
-      bottomRight: r.bottomRight,
-      bottomLeft: r.bottomLeft,
-      flipSourceY
-    });
-  },
-  cleanup: (state) => cleanupCornerPin(state),
-  schema: cornerPinSchema,
-  validateParams: validateCornerPinParams
-});
+import {
+  checkerboard2
+} from "./index-1m1b1ad7.mjs";
+import {
+  pattern2
+} from "./index-cb77qg3g.mjs";
+import"./index-8p04sssx.mjs";
+import {
+  tile2
+} from "./index-ysnwfc4t.mjs";
+import {
+  rings2
+} from "./index-34fxm3ax.mjs";
+import {
+  starburstEffectSchema2,
+  starburst2
+} from "./index-18y0zcy2.mjs";
+import {
+  lightLeakEffectSchema2,
+  lightLeak2
+} from "./index-wy95a41r.mjs";
+import {
+  gridlines2
+} from "./index-8agtsbw4.mjs";
+import {
+  zigzag2
+} from "./index-afdtmrh2.mjs";
+import {
+  linearGradient2
+} from "./index-0w4eqht8.mjs";
+import {
+  linearGradientTint2
+} from "./index-6agxdrvr.mjs";
+import {
+  cornerPin2
+} from "./index-r0v18b2n.mjs";
 export {
-  checkerboard,
-  cornerPin,
-  gridlines,
-  lightLeak,
-  lightLeakEffectSchema,
-  linearGradient,
-  linearGradientTint,
-  pattern,
-  rings,
-  starburst,
-  starburstEffectSchema,
-  tile,
-  zigzag
+  checkerboard2 as checkerboard,
+  cornerPin2 as cornerPin,
+  gridlines2 as gridlines,
+  lightLeak2 as lightLeak,
+  lightLeakEffectSchema2 as lightLeakEffectSchema,
+  linearGradient2 as linearGradient,
+  linearGradientTint2 as linearGradientTint,
+  pattern2 as pattern,
+  rings2 as rings,
+  starburst2 as starburst,
+  starburstEffectSchema2 as starburstEffectSchema,
+  tile2 as tile,
+  zigzag2 as zigzag
 };