@remotion/effects 4.0.539 → 4.0.541

package/dist/esm/index-wy95a41r.mjs

@@ -0,0 +1,407 @@
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/light-leak.ts
+import { Internals } from "remotion";
+
+// src/light-leak-webgpu-shader.ts
+var LIGHT_LEAK_WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+
+struct Params { size: vec2f, progress: f32, seed: f32, hue: f32, }
+fn computePattern(uv: vec2f, s: f32, t: f32) -> vec3f {
+  var p = uv * 0.8 + vec2f(sin(s * 1.61803) * 5.0, cos(s * 2.71828) * 5.0);
+  for (var i = 1; i < 5; i++) {
+    var newp = p;
+    let fi = f32(i);
+    let 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 * f32(i + 10) + phase) - 20.0 + 15.0;
+    p = newp;
+  }
+  let v1 = 0.5 * sin(2.0 * p.x) + 0.5;
+  let v2 = 0.5 * sin(2.0 * p.y) + 0.5;
+  let blend = sin(p.x + p.y) * 0.5 + 0.5;
+  let brightness = v1 * 0.5 + v2 * 0.5;
+  return vec3f(brightness, blend, brightness * 0.6 + blend * 0.4);
+}
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+  let evolveProgress = min(1.0, params.progress * 2.0);
+  let retractProgress = max(0.0, params.progress * 2.0 - 1.0);
+  let refScale = 1.92;
+  let uv = (vec2f(input.position.x, params.size.y - input.position.y) / params.size) * vec2f(refScale, refScale * params.size.y / params.size.x);
+  let patA = computePattern(uv, params.seed, evolveProgress * 3.14159);
+  let threshA = 1.0 - evolveProgress;
+  let revealAlpha = smoothstep(threshA, threshA + 0.3, patA.z);
+  let maxUv = vec2f(refScale, refScale * params.size.y / params.size.x);
+  let patB = computePattern(maxUv - uv, params.seed + 42.0, retractProgress * 3.14159);
+  let threshB = 1.0 - retractProgress;
+  let eraseAlpha = smoothstep(threshB, threshB + 0.3, patB.z);
+  let alpha = revealAlpha * (1.0 - eraseAlpha);
+  var col = mix(vec3f(1.0, 0.85, 0.2), vec3f(1.0, 0.5, 0.05), patA.y) * (0.6 + 0.6 * patA.x);
+  let angle = params.hue * 3.14159 / 180.0;
+  let a = cos(angle);
+  let b = sin(angle) * 0.57735;
+  let c = (1.0 - a) / 3.0;
+  let hueRot = mat3x3f(vec3f(a+c,c-b,c+b),vec3f(c+b,a+c,c-b),vec3f(c-b,c+b,a+c));
+  col = clamp(hueRot * col, vec3f(0), vec3f(1));
+  let color = textureSampleLevel(source, sourceSampler, input.uv, 0);
+  return vec4f(col * alpha, alpha) + color * (1.0 - alpha);
+}
+
+`;
+
+// src/light-leak.ts
+var { createEffect, createWebGL2ContextError } = Internals;
+var DEFAULT_SEED = 0;
+var DEFAULT_HUE_SHIFT = 0;
+var DEFAULT_PROGRESS = 0.5;
+var lightLeakEffectSchema2 = {
+  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 resolve = (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 } = resolve(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 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(`Light leak 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(`Light leak program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var lightLeak2 = createEffect({
+  type: "remotion/light-leak",
+  label: "lightLeak()",
+  documentationLink: "https://www.remotion.dev/docs/effects/light-leak",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `light-leak-${r.seed}-${r.hueShift}-${r.progress}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "light-leak"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for the light-leak effect");
+        const r = resolve(params);
+        const uniformData = new Float32Array([
+          width,
+          height,
+          r.progress,
+          r.seed,
+          r.hueShift,
+          0,
+          0,
+          0
+        ]);
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: LIGHT_LEAK_WEBGPU_SHADER,
+          uniformData
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => {
+        const gl = target.getContext("webgl2", {
+          premultipliedAlpha: true,
+          alpha: true,
+          preserveDrawingBuffer: true
+        });
+        if (!gl) {
+          throw createWebGL2ContextError("light leak effect");
+        }
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        const vs = compileShader(gl, gl.VERTEX_SHADER, LIGHT_LEAK_VS);
+        const fs = compileShader(gl, gl.FRAGMENT_SHADER, LIGHT_LEAK_FS);
+        const program = linkProgram(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 = resolve(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.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.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: lightLeakEffectSchema2,
+  validateParams: validateLightLeakParams
+});
+
+export { lightLeakEffectSchema2, lightLeak2 };

package/dist/esm/index-ysnwfc4t.mjs

@@ -0,0 +1,306 @@
+import {
+  setupSinglePass,
+  prepareSinglePassSource,
+  drawSinglePass,
+  cleanupSinglePass
+} from "./index-8p04sssx.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject,
+  assertOptionalBoolean
+} from "./index-4fvp93ps.mjs";
+
+// src/tile.ts
+import { Internals as Internals2 } from "remotion";
+
+// src/tile-gpu-runtime.ts
+import { Internals } from "remotion";
+var WEBGL_SHADER = `#version 300 es
+precision highp float;
+in vec2 vUv;
+out vec4 fragColor;
+uniform sampler2D uSource;
+uniform vec4 uBounds;
+uniform vec4 uOptions;
+void main() {
+	vec2 p = vec2(gl_FragCoord.x, uOptions.y - gl_FragCoord.y);
+	if (uOptions.z == 0.0 && uOptions.w == 0.0) {
+		fragColor = texture(uSource, vUv);
+		return;
+	}
+	if (uBounds.z <= 0.0 || uBounds.w <= 0.0) { fragColor = vec4(0.0); return; }
+	vec2 q = (p - uBounds.xy) / uBounds.zw;
+	if ((uOptions.z == 0.0 && (q.x < 0.0 || q.x >= 1.0)) || (uOptions.w == 0.0 && (q.y < 0.0 || q.y >= 1.0))) { fragColor = vec4(0.0); return; }
+	vec2 local = mix(fract(q), 1.0 - fract(q), mod(floor(q), 2.0));
+	vec2 samplePosition = uBounds.xy + local * uBounds.zw;
+	vec2 sourceSize = vec2(textureSize(uSource, 0));
+	if (any(lessThan(samplePosition, vec2(0.0))) || any(greaterThanEqual(samplePosition, sourceSize))) { fragColor = vec4(0.0); return; }
+	vec2 uv = samplePosition / sourceSize;
+	fragColor = texture(uSource, vec2(uv.x, 1.0 - uv.y));
+}
+`;
+var WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+struct Params { bounds: vec4f, options: vec4f }
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+	let p = input.position.xy;
+	if (params.options.z == 0.0 && params.options.w == 0.0) {
+		return textureSampleLevel(source, sourceSampler, input.uv, 0);
+	}
+	if (params.bounds.z <= 0.0 || params.bounds.w <= 0.0) { return vec4f(0); }
+	let q = (p - params.bounds.xy) / params.bounds.zw;
+	if ((params.options.z == 0.0 && (q.x < 0.0 || q.x >= 1.0)) || (params.options.w == 0.0 && (q.y < 0.0 || q.y >= 1.0))) { return vec4f(0); }
+	let tile = floor(q);
+	let mirror = tile - 2.0 * floor(tile / 2.0);
+	let local = mix(fract(q), vec2f(1) - fract(q), mirror);
+	let samplePosition = params.bounds.xy + local * params.bounds.zw;
+	let sourceSize = vec2f(textureDimensions(source));
+	if (any(samplePosition < vec2f(0)) || any(samplePosition >= sourceSize)) { return vec4f(0); }
+	return textureSampleLevel(source, sourceSampler, samplePosition / sourceSize, 0);
+}
+`;
+var createTileGpuImplementations = ({
+  setupBounds,
+  getBounds,
+  resolve
+}) => ({
+  webgl2: Internals.createEffectImplementation({
+    setup: (target) => ({
+      bounds: setupBounds(target),
+      render: setupSinglePass(target, WEBGL_SHADER, "tile", [
+        "uBounds",
+        "uOptions"
+      ])
+    }),
+    apply: ({ source, width, height, params, state, flipSourceY }) => {
+      const r = resolve(params);
+      const bounds = r.horizontal || r.vertical ? getBounds({ source, width, height, params, state: state.bounds }) : null;
+      prepareSinglePassSource({
+        state: state.render,
+        source,
+        width,
+        height,
+        flipSourceY
+      });
+      const { gl, uniforms } = state.render;
+      gl.uniform4f(uniforms.uBounds, bounds?.left ?? 0, bounds?.top ?? 0, bounds?.width ?? 0, bounds?.height ?? 0);
+      gl.uniform4f(uniforms.uOptions, width, height, Number(r.horizontal), Number(r.vertical));
+      drawSinglePass(state.render);
+    },
+    cleanup: (state) => cleanupSinglePass(state.render)
+  }),
+  webgpu: Internals.createEffectImplementation({
+    setup: (target) => ({
+      bounds: setupBounds(target),
+      render: setupWebGpuSinglePass(target, "tile")
+    }),
+    apply: ({ source, width, height, params, state, gpuDevice }) => {
+      if (!gpuDevice) {
+        throw new Error("A WebGPU device is required for the tile effect");
+      }
+      const r = resolve(params);
+      const bounds = r.horizontal || r.vertical ? getBounds({ source, width, height, params, state: state.bounds }) : null;
+      applyWebGpuSinglePass({
+        state: state.render,
+        source,
+        width,
+        height,
+        device: gpuDevice,
+        shader: WEBGPU_SHADER,
+        uniformData: new Float32Array([
+          bounds?.left ?? 0,
+          bounds?.top ?? 0,
+          bounds?.width ?? 0,
+          bounds?.height ?? 0,
+          width,
+          height,
+          Number(r.horizontal),
+          Number(r.vertical)
+        ])
+      });
+    },
+    cleanup: (state) => cleanupWebGpuSinglePass(state.render)
+  })
+});
+
+// src/tile.ts
+var { createEffect } = Internals2;
+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 resolve = (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 setupTile = (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 };
+};
+var getTileBounds = ({
+  source,
+  width,
+  height,
+  params,
+  state
+}) => {
+  const r = resolve(params);
+  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) {
+    return null;
+  }
+  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--;
+    }
+  }
+  return { left, top, width: right - left + 1, height: bottom - top + 1 };
+};
+var tile2 = createEffect({
+  type: "dev.remotion.effects.tile",
+  label: "tile()",
+  documentationLink: "https://www.remotion.dev/docs/effects/tile",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `tile-${r.horizontal}-${r.vertical}`;
+  },
+  implementations: {
+    ...createTileGpuImplementations({
+      setupBounds: setupTile,
+      getBounds: getTileBounds,
+      resolve
+    }),
+    "2d": Internals2.createEffectImplementation({
+      setup: setupTile,
+      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 = resolve(params);
+        context.clearRect(0, 0, width, height);
+        if (!r.horizontal && !r.vertical) {
+          context.drawImage(source, 0, 0, width, height);
+          return;
+        }
+        const bounds = getTileBounds({ source, width, height, params, state });
+        if (!bounds)
+          return;
+        const { left, top } = bounds;
+        const tileWidth = bounds.width;
+        const tileHeight = bounds.height;
+        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
+});
+
+export { tile2 };