@remotion/effects 4.0.498 → 4.0.500

package/dist/esm/index.mjs

@@ -1376,9 +1376,661 @@ var rings = createEffect3({
   validateParams: validateRingsParams
 });
 
-// src/gridlines.ts
+// src/starburst.ts
 import { Internals as Internals4 } from "remotion";
+import { NoReactInternals } from "remotion/no-react";
 var { createEffect: createEffect4, createWebGL2ContextError: createWebGL2ContextError4 } = Internals4;
+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 resolve4 = (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 = resolve4(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 = createEffect4({
+  type: "remotion/starburst",
+  label: "starburst()",
+  documentationLink: "https://www.remotion.dev/docs/effects/starburst",
+  backend: "webgl2",
+  calculateKey: (params) => {
+    const r = resolve4(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 = resolve4(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 Internals5 } from "remotion";
+var { createEffect: createEffect5, createWebGL2ContextError: createWebGL2ContextError5 } = Internals5;
+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 resolve5 = (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 } = resolve5(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 = createEffect5({
+  type: "remotion/light-leak",
+  label: "lightLeak()",
+  documentationLink: "https://www.remotion.dev/docs/effects/light-leak",
+  backend: "webgl2",
+  calculateKey: (params) => {
+    const r = resolve5(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 = resolve5(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 Internals6 } from "remotion";
+var { createEffect: createEffect6, createWebGL2ContextError: createWebGL2ContextError6 } = Internals6;
 var DEFAULT_GRID_SIZE = 64;
 var DEFAULT_LINE_WIDTH = 2;
 var DEFAULT_LINE_COLOR = "#ffffff";
@@ -1476,7 +2128,7 @@ var gridlinesSchema = {
     description: "Mask to source alpha"
   }
 };
-var resolve4 = (p) => ({
+var resolve6 = (p) => ({
   gridSize: p.gridSize ?? DEFAULT_GRID_SIZE,
   lineWidth: p.lineWidth ?? DEFAULT_LINE_WIDTH,
   lineColor: p.lineColor ?? DEFAULT_LINE_COLOR,
@@ -1642,7 +2294,7 @@ void main() {
 	fragColor = sourceOver(sourceOver(texColor, background), line);
 }
 `;
-var compileShader4 = (gl, type, source) => {
+var compileShader6 = (gl, type, source) => {
   const shader = gl.createShader(type);
   if (!shader) {
     throw new Error("Failed to create WebGL shader");
@@ -1656,7 +2308,7 @@ var compileShader4 = (gl, type, source) => {
   }
   return shader;
 };
-var linkProgram4 = (gl, vs, fs) => {
+var linkProgram6 = (gl, vs, fs) => {
   const program = gl.createProgram();
   if (!program) {
     throw new Error("Failed to create WebGL program");
@@ -1676,13 +2328,13 @@ var rgbaToUniform = (rgba) => {
   const alpha = a / 255;
   return [r / 255 * alpha, g / 255 * alpha, b / 255 * alpha, alpha];
 };
-var gridlines = createEffect4({
+var gridlines = createEffect6({
   type: "remotion/gridlines",
   label: "gridlines()",
   documentationLink: "https://www.remotion.dev/docs/effects/gridlines",
   backend: "webgl2",
   calculateKey: (params) => {
-    const r = resolve4(params);
+    const r = resolve6(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}`;
   },
@@ -1693,12 +2345,12 @@ var gridlines = createEffect4({
       preserveDrawingBuffer: true
     });
     if (!gl) {
-      throw createWebGL2ContextError4("gridlines effect");
+      throw createWebGL2ContextError6("gridlines effect");
     }
     gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader4(gl, gl.VERTEX_SHADER, GRIDLINES_VS);
-    const fs = compileShader4(gl, gl.FRAGMENT_SHADER, GRIDLINES_FS);
-    const program = linkProgram4(gl, vs, fs);
+    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();
@@ -1782,7 +2434,7 @@ var gridlines = createEffect4({
     };
   },
   apply: ({ source, width, height, params, state, flipSourceY }) => {
-    const r = resolve4(params);
+    const r = resolve6(params);
     const { gl, program, vao, texture, uniforms } = state;
     if (state.cachedLineColorStr !== r.lineColor) {
       state.cachedLineColorStr = r.lineColor;
@@ -1844,8 +2496,8 @@ var gridlines = createEffect4({
 });
 
 // src/zigzag.ts
-import { Internals as Internals5 } from "remotion";
-var { createEffect: createEffect5, createWebGL2ContextError: createWebGL2ContextError5 } = Internals5;
+import { Internals as Internals7 } from "remotion";
+var { createEffect: createEffect7, createWebGL2ContextError: createWebGL2ContextError7 } = Internals7;
 var ZIGZAG_DIRECTIONS = ["horizontal", "vertical"];
 var DEFAULT_COLORS3 = ["#dff4ff", "#7cc6ff"];
 var DEFAULT_DIRECTION = "horizontal";
@@ -1932,7 +2584,7 @@ var zigzagSchema = {
     description: "Mask to source alpha"
   }
 };
-var resolve5 = (p) => {
+var resolve7 = (p) => {
   const thickness = p.thickness ?? DEFAULT_THICKNESS2;
   const gap = p.gap ?? DEFAULT_GAP4;
   return {
@@ -2078,7 +2730,7 @@ void main() {
 	);
 }
 `;
-var compileShader5 = (gl, type, source) => {
+var compileShader7 = (gl, type, source) => {
   const shader = gl.createShader(type);
   if (!shader) {
     throw new Error("Failed to create WebGL shader");
@@ -2092,7 +2744,7 @@ var compileShader5 = (gl, type, source) => {
   }
   return shader;
 };
-var linkProgram5 = (gl, vs, fs) => {
+var linkProgram7 = (gl, vs, fs) => {
   const program = gl.createProgram();
   if (!program) {
     throw new Error("Failed to create WebGL program");
@@ -2108,9 +2760,9 @@ var linkProgram5 = (gl, vs, fs) => {
   return program;
 };
 var createProgram3 = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader5(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader5(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram5(gl, vs, fs);
+  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;
@@ -2135,7 +2787,7 @@ var setupZigzag = (target) => {
     preserveDrawingBuffer: true
   });
   if (!gl) {
-    throw createWebGL2ContextError5("zigzag effect");
+    throw createWebGL2ContextError7("zigzag effect");
   }
   gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
   const program = createProgram3(gl, ZIGZAG_VS, ZIGZAG_FS);
@@ -2229,19 +2881,19 @@ var updatePalette3 = (state, colors) => {
   }
   return true;
 };
-var zigzag = createEffect5({
+var zigzag = createEffect7({
   type: "dev.remotion.effects.zigzag",
   label: "zigzag()",
   documentationLink: "https://www.remotion.dev/docs/effects/zigzag",
   backend: "webgl2",
   calculateKey: (params) => {
-    const r = resolve5(params);
+    const r = resolve7(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 = resolve5(params);
+    const r = resolve7(params);
     const paletteDirty = updatePalette3(state, r.colors);
     const { gl, program, sourceTexture, paletteTexture, uniforms, vao } = state;
     gl.viewport(0, 0, width, height);
@@ -2311,8 +2963,8 @@ var zigzag = createEffect5({
 });
 
 // src/linear-gradient.ts
-import { Internals as Internals6 } from "remotion";
-var { createEffect: createEffect6, createWebGL2ContextError: createWebGL2ContextError6 } = Internals6;
+import { Internals as Internals8 } from "remotion";
+var { createEffect: createEffect8, createWebGL2ContextError: createWebGL2ContextError8 } = Internals8;
 var DEFAULT_START = [0, 0.5];
 var DEFAULT_END = [1, 0.5];
 var DEFAULT_START_COLOR = "#000000";
@@ -2349,7 +3001,7 @@ var linearGradientSchema = {
     description: "End color"
   }
 };
-var resolve6 = (p) => ({
+var resolve8 = (p) => ({
   start: [...p.start ?? DEFAULT_START],
   end: [...p.end ?? DEFAULT_END],
   startColor: p.startColor ?? DEFAULT_START_COLOR,
@@ -2407,7 +3059,7 @@ void main() {
 	fragColor = vec4(color.rgb * color.a, color.a);
 }
 `;
-var compileShader6 = (gl, type, source) => {
+var compileShader8 = (gl, type, source) => {
   const shader = gl.createShader(type);
   if (!shader) {
     throw new Error("Failed to create WebGL shader");
@@ -2422,8 +3074,8 @@ var compileShader6 = (gl, type, source) => {
   return shader;
 };
 var createProgram4 = (gl) => {
-  const vs = compileShader6(gl, gl.VERTEX_SHADER, VERTEX_SHADER);
-  const fs = compileShader6(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
+  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");
@@ -2447,7 +3099,7 @@ var setupLinearGradient = (target) => {
     preserveDrawingBuffer: true
   });
   if (!gl) {
-    throw createWebGL2ContextError6("linear gradient effect");
+    throw createWebGL2ContextError8("linear gradient effect");
   }
   const program = createProgram4(gl);
   const vao = gl.createVertexArray();
@@ -2528,18 +3180,18 @@ var getParsedColors = (state, resolved) => {
     end: state.cachedEndColorRgba
   };
 };
-var linearGradient = createEffect6({
+var linearGradient = createEffect8({
   type: "dev.remotion.effects.linearGradient",
   label: "linearGradient()",
   documentationLink: "https://www.remotion.dev/docs/effects/linear-gradient",
   backend: "webgl2",
   calculateKey: (params) => {
-    const r = resolve6(params);
+    const r = resolve8(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 = resolve6(params);
+    const r = resolve8(params);
     const { start, end } = getParsedColors(state, r);
     const [sr, sg, sb, sa] = normalizedRgba(start);
     const [er, eg, eb, ea] = normalizedRgba(end);
@@ -2574,8 +3226,8 @@ var linearGradient = createEffect6({
 });
 
 // src/linear-gradient-tint.ts
-import { Internals as Internals7 } from "remotion";
-var { createEffect: createEffect7, createWebGL2ContextError: createWebGL2ContextError7 } = Internals7;
+import { Internals as Internals9 } from "remotion";
+var { createEffect: createEffect9, createWebGL2ContextError: createWebGL2ContextError9 } = Internals9;
 var DEFAULT_START2 = [0, 0.5];
 var DEFAULT_END2 = [1, 0.5];
 var DEFAULT_START_COLOR2 = "#000000";
@@ -2622,7 +3274,7 @@ var linearGradientTintSchema = {
     hiddenFromList: false
   }
 };
-var resolve7 = (p) => ({
+var resolve9 = (p) => ({
   start: [...p.start ?? DEFAULT_START2],
   end: [...p.end ?? DEFAULT_END2],
   startColor: p.startColor ?? DEFAULT_START_COLOR2,
@@ -2644,7 +3296,7 @@ var validateLinearGradientTintParams = (params) => {
   assertOptionalColor(params.startColor, "startColor");
   assertOptionalColor(params.endColor, "endColor");
   assertOptionalFiniteNumber(params.amount, "amount");
-  validateUnitInterval(resolve7(params).amount, "amount");
+  validateUnitInterval(resolve9(params).amount, "amount");
 };
 var VERTEX_SHADER2 = `#version 300 es
 in vec2 aPos;
@@ -2696,7 +3348,7 @@ void main() {
 	fragColor = vec4(blended * alpha, alpha);
 }
 `;
-var compileShader7 = (gl, type, source) => {
+var compileShader9 = (gl, type, source) => {
   const shader = gl.createShader(type);
   if (!shader) {
     throw new Error("Failed to create WebGL shader");
@@ -2711,8 +3363,8 @@ var compileShader7 = (gl, type, source) => {
   return shader;
 };
 var createProgram5 = (gl) => {
-  const vs = compileShader7(gl, gl.VERTEX_SHADER, VERTEX_SHADER2);
-  const fs = compileShader7(gl, gl.FRAGMENT_SHADER, FRAGMENT_SHADER2);
+  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");
@@ -2749,7 +3401,7 @@ var setupLinearGradientTint = (target) => {
     preserveDrawingBuffer: true
   });
   if (!gl) {
-    throw createWebGL2ContextError7("linear gradient tint effect");
+    throw createWebGL2ContextError9("linear gradient tint effect");
   }
   gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
   const program = createProgram5(gl);
@@ -2835,18 +3487,18 @@ var getParsedColors2 = (state, resolved) => {
     end: state.cachedEndColorRgba
   };
 };
-var linearGradientTint = createEffect7({
+var linearGradientTint = createEffect9({
   type: "dev.remotion.effects.linearGradientTint",
   label: "linearGradientTint()",
   documentationLink: "https://www.remotion.dev/docs/effects/linear-gradient-tint",
   backend: "webgl2",
   calculateKey: (params) => {
-    const r = resolve7(params);
+    const r = resolve9(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 = resolve7(params);
+    const r = resolve9(params);
     const { start, end } = getParsedColors2(state, r);
     const [sr, sg, sb, sa] = normalizedRgba2(start);
     const [er, eg, eb, ea] = normalizedRgba2(end);
@@ -2890,10 +3542,10 @@ var linearGradientTint = createEffect7({
   validateParams: validateLinearGradientTintParams
 });
 // src/corner-pin/index.ts
-import { Internals as Internals9 } from "remotion";
+import { Internals as Internals11 } from "remotion";
 
 // src/corner-pin/corner-pin-runtime.ts
-import { Internals as Internals8 } from "remotion";
+import { Internals as Internals10 } from "remotion";
 
 // src/corner-pin/corner-pin-shaders.ts
 var CORNER_PIN_VS = `#version 300 es
@@ -2991,8 +3643,8 @@ void main() {
 `;
 
 // src/corner-pin/corner-pin-runtime.ts
-var { createWebGL2ContextError: createWebGL2ContextError8 } = Internals8;
-var compileShader8 = (gl, type, source) => {
+var { createWebGL2ContextError: createWebGL2ContextError10 } = Internals10;
+var compileShader10 = (gl, type, source) => {
   const shader = gl.createShader(type);
   if (!shader) {
     throw new Error("Failed to create WebGL shader");
@@ -3006,7 +3658,7 @@ var compileShader8 = (gl, type, source) => {
   }
   return shader;
 };
-var linkProgram6 = (gl, vs, fs) => {
+var linkProgram8 = (gl, vs, fs) => {
   const program = gl.createProgram();
   if (!program) {
     throw new Error("Failed to create WebGL program");
@@ -3022,9 +3674,9 @@ var linkProgram6 = (gl, vs, fs) => {
   return program;
 };
 var createProgram6 = (gl, vertexSource, fragmentSource) => {
-  const vs = compileShader8(gl, gl.VERTEX_SHADER, vertexSource);
-  const fs = compileShader8(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  const program = linkProgram6(gl, vs, fs);
+  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;
@@ -3049,7 +3701,7 @@ var setupCornerPin = (target) => {
     preserveDrawingBuffer: true
   });
   if (!gl) {
-    throw createWebGL2ContextError8("corner pin effect");
+    throw createWebGL2ContextError10("corner pin effect");
   }
   gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
   const program = createProgram6(gl, CORNER_PIN_VS, CORNER_PIN_FS);
@@ -3158,7 +3810,7 @@ var applyCornerPin = ({
 };
 
 // src/corner-pin/index.ts
-var { createEffect: createEffect8 } = Internals9;
+var { createEffect: createEffect10 } = Internals11;
 var DEFAULT_TOP_LEFT = [0, 0];
 var DEFAULT_TOP_RIGHT = [1, 0];
 var DEFAULT_BOTTOM_RIGHT = [1, 1];
@@ -3189,7 +3841,7 @@ var cornerPinSchema = {
     description: "Bottom left"
   }
 };
-var resolve8 = (p) => ({
+var resolve10 = (p) => ({
   topLeft: [...p.topLeft ?? DEFAULT_TOP_LEFT],
   topRight: [...p.topRight ?? DEFAULT_TOP_RIGHT],
   bottomRight: [
@@ -3214,18 +3866,18 @@ var validateCornerPinParams = (params) => {
   assertOptionalUvCoordinate4(params.bottomRight, "bottomRight");
   assertOptionalUvCoordinate4(params.bottomLeft, "bottomLeft");
 };
-var cornerPin = createEffect8({
+var cornerPin = createEffect10({
   type: "dev.remotion.effects.cornerPin",
   label: "cornerPin()",
   documentationLink: "https://www.remotion.dev/docs/effects/corner-pin",
   backend: "webgl2",
   calculateKey: (params) => {
-    const r = resolve8(params);
+    const r = resolve10(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 = resolve8(params);
+    const r = resolve10(params);
     applyCornerPin({
       state,
       source,
@@ -3244,10 +3896,14 @@ var cornerPin = createEffect8({
 });
 export {
   zigzag,
+  starburstEffectSchema,
+  starburst,
   rings,
   pattern,
   linearGradientTint,
   linearGradient,
+  lightLeakEffectSchema,
+  lightLeak,
   gridlines,
   cornerPin,
   checkerboard