@remotion/effects 4.0.539 → 4.0.540

package/dist/esm/sphere.mjs

@@ -1,201 +1,22 @@
+import {
+  setupWebGlProjection,
+  applyWebGlProjection,
+  cleanupWebGlProjection,
+  cleanupWebGpuProjection,
+  setupWebGpuProjection,
+  applyWebGpuProjection
+} from "./index-vp56k1gj.mjs";
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval
+} from "./index-wxhvgv2s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
 // src/sphere/index.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/webgpu-projection-runtime.ts
-var cleanupWebGpuProjection = (state) => {
-  state.resources?.texture.destroy();
-  state.resources?.uniforms.destroy();
-  state.resources = null;
-  state.context.unconfigure();
-};
-var setupWebGpuProjection = (target, label) => {
-  const context = target.getContext("webgpu");
-  if (!context) {
-    throw new Error(`WebGPU is not available for the ${label} effect`);
-  }
-  return { context, resources: null };
-};
-var applyWebGpuProjection = ({
-  state,
-  source,
-  width,
-  height,
-  device,
-  shader,
-  uniformData
-}) => {
-  if (state.resources && (state.resources.device !== device || state.resources.width !== width || state.resources.height !== height)) {
-    cleanupWebGpuProjection(state);
-  }
-  if (!state.resources) {
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    state.context.configure({ device, format, alphaMode: "premultiplied" });
-    const module = device.createShaderModule({ code: shader });
-    const pipeline = device.createRenderPipeline({
-      layout: "auto",
-      vertex: { module, entryPoint: "vertex" },
-      fragment: { module, entryPoint: "fragment", targets: [{ format }] },
-      primitive: { topology: "triangle-list" }
-    });
-    const uniforms = device.createBuffer({
-      size: uniformData.byteLength,
-      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-    });
-    const sampler = device.createSampler({
-      addressModeU: "repeat",
-      magFilter: "linear",
-      minFilter: "linear"
-    });
-    const texture = device.createTexture({
-      size: [width, height],
-      format: "rgba8unorm",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
-    });
-    const bindGroup = device.createBindGroup({
-      layout: pipeline.getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: texture.createView() },
-        { binding: 1, resource: sampler },
-        { binding: 2, resource: { buffer: uniforms } }
-      ]
-    });
-    state.resources = {
-      device,
-      pipeline,
-      uniforms,
-      sampler,
-      texture,
-      bindGroup,
-      width,
-      height
-    };
-  }
-  const { resources } = state;
-  device.queue.copyExternalImageToTexture({ source }, { texture: resources.texture, premultipliedAlpha: true }, [width, height]);
-  device.queue.writeBuffer(resources.uniforms, 0, uniformData);
-  const encoder = device.createCommandEncoder();
-  const pass = encoder.beginRenderPass({
-    colorAttachments: [
-      {
-        view: state.context.getCurrentTexture().createView(),
-        clearValue: { r: 0, g: 0, b: 0, a: 0 },
-        loadOp: "clear",
-        storeOp: "store"
-      }
-    ]
-  });
-  pass.setPipeline(resources.pipeline);
-  pass.setBindGroup(0, resources.bindGroup);
-  pass.draw(3);
-  pass.end();
-  device.queue.submit([encoder.finish()]);
-};
-
 // src/sphere/shader.ts
 var SPHERE_SHADER = `
 struct Params {
@@ -245,6 +66,43 @@ fn sampleFace(normal: vec3f, inverse: mat3x3f) -> vec4f {
 }
 `;
 
+// src/sphere/webgl-shader.ts
+var SPHERE_WEBGL_SHADER = `#version 300 es
+precision highp float;
+uniform sampler2D uSource;
+uniform vec4 uParams[3];
+out vec4 fragColor;
+vec4 sampleFace(vec3 normal, mat3 inverseRotation) {
+  vec3 local = inverseRotation * normal;
+  // Longitude wraps at the seam; latitude spans the complete image height.
+  vec2 uv = vec2(fract(atan(local.x, local.z) / 6.28318530718 + 0.5), asin(clamp(local.y, -1.0, 1.0)) / 3.14159265359 + 0.5);
+  vec4 color = textureLod(uSource, vec2(uv.x, 1.0 - uv.y), 0.0);
+  float shade = mix(1.0, abs(normal.z), uParams[1].z);
+  return vec4(color.rgb * shade, color.a);
+}
+
+vec4 project(vec2 position) {
+  vec2 p = (position - uParams[0].zw) / uParams[1].x;
+  float distanceSquared = dot(p, p);
+  float coverage = 1.0 - smoothstep(1.0 - fwidth(distanceSquared), 1.0, distanceSquared);
+  if (distanceSquared >= 1.0) { return vec4(0); }
+  float z = sqrt(1.0 - distanceSquared);
+  vec3 s = sin(uParams[2].xyz);
+  vec3 c = cos(uParams[2].xyz);
+  mat3 rx = mat3(vec3(1, 0, 0), vec3(0, c.x, s.x), vec3(0, -s.x, c.x));
+  mat3 ry = mat3(vec3(c.y, 0, -s.y), vec3(0, 1, 0), vec3(s.y, 0, c.y));
+  mat3 rz = mat3(vec3(c.z, s.z, 0), vec3(-s.z, c.z, 0), vec3(0, 0, 1));
+  mat3 inverseRotation = transpose(rz * ry * rx);
+  vec4 front = sampleFace(vec3(p, z), inverseRotation);
+  vec4 back = sampleFace(vec3(p, -z), inverseRotation);
+  if (uParams[1].w == 1.0) { return front * coverage; }
+  if (uParams[1].w == 2.0) { return back * coverage; }
+  return (front + back * (1.0 - front.a)) * coverage;
+}
+
+void main() { fragColor = project(vec2(gl_FragCoord.x, uParams[0].y - gl_FragCoord.y)); }
+`;
+
 // src/sphere/index.ts
 var DEFAULT_RADIUS = 250;
 var DEFAULT_ROTATION = 0;
@@ -306,11 +164,28 @@ var resolve = (params) => ({
   render: params.render ?? DEFAULT_RENDER,
   shading: params.shading ?? DEFAULT_SHADING
 });
+var getUniformData = (params, width, height) => {
+  const r = resolve(params);
+  const radians = Math.PI / 180;
+  return new Float32Array([
+    width,
+    height,
+    r.position[0] * width,
+    r.position[1] * height,
+    r.radius,
+    0,
+    r.shading,
+    r.render === "front" ? 1 : r.render === "back" ? 2 : 0,
+    r.rotationX % 360 * radians,
+    r.rotationY % 360 * radians,
+    r.rotationZ % 360 * radians,
+    0
+  ]);
+};
 var sphere = Internals.createEffect({
   type: "remotion/sphere",
   label: "sphere()",
   documentationLink: "https://www.remotion.dev/docs/effects/sphere",
-  backend: "webgpu",
   schema: sphereSchema,
   validateParams: (params) => {
     assertEffectParamsObject(params, "Sphere");
@@ -339,37 +214,38 @@ var sphere = Internals.createEffect({
     const r = resolve(params);
     return `sphere-${r.radius}-${r.rotationX}-${r.rotationY}-${r.rotationZ}-${r.position.join(",")}-${r.render}-${r.shading}`;
   },
-  setup: (target) => setupWebGpuProjection(target, "sphere"),
-  apply: ({ source, width, height, params, state, gpuDevice }) => {
-    if (!gpuDevice) {
-      throw new Error("A WebGPU device is required for the sphere effect");
-    }
-    const r = resolve(params);
-    const radians = Math.PI / 180;
-    applyWebGpuProjection({
-      source,
-      width,
-      height,
-      state,
-      device: gpuDevice,
-      shader: SPHERE_SHADER,
-      uniformData: new Float32Array([
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuProjection(target, "sphere"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the sphere effect");
+        }
+        applyWebGpuProjection({
+          source,
+          width,
+          height,
+          state,
+          device: gpuDevice,
+          shader: SPHERE_SHADER,
+          uniformData: getUniformData(params, width, height)
+        });
+      },
+      cleanup: cleanupWebGpuProjection
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupWebGlProjection(target, SPHERE_WEBGL_SHADER),
+      apply: ({ source, width, height, params, state, flipSourceY }) => applyWebGlProjection({
+        source,
         width,
         height,
-        r.position[0] * width,
-        r.position[1] * height,
-        r.radius,
-        0,
-        r.shading,
-        r.render === "front" ? 1 : r.render === "back" ? 2 : 0,
-        r.rotationX % 360 * radians,
-        r.rotationY % 360 * radians,
-        r.rotationZ % 360 * radians,
-        0
-      ])
-    });
-  },
-  cleanup: cleanupWebGpuProjection
+        state,
+        flipSourceY,
+        uniformData: getUniformData(params, width, height)
+      }),
+      cleanup: cleanupWebGlProjection
+    })
+  }
 });
 export {
   sphere

package/dist/esm/starburst.mjs

@@ -1,347 +1,8 @@
-// src/starburst.ts
-import { Internals } from "remotion";
-import { NoReactInternals } from "remotion/no-react";
-var { createEffect, createWebGL2ContextError } = Internals;
-var colorToRgb = (color) => {
-  const packed = NoReactInternals.processColor(color);
-  return [packed >>> 16 & 255, packed >>> 8 & 255, packed & 255];
-};
-var DEFAULT_ORIGIN = [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_ORIGIN,
-    description: "Origin"
-  }
-};
-var resolve = (p) => ({
-  rays: p.rays,
-  colors: p.colors,
-  rotation: p.rotation ?? 0,
-  smoothness: p.smoothness ?? 0,
-  origin: p.origin ?? DEFAULT_ORIGIN
-});
-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 = resolve(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 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(`Starburst 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(`Starburst program link failed: ${log ?? "(no log)"}`);
-  }
-  return program;
-};
-var starburst = createEffect({
-  type: "remotion/starburst",
-  label: "starburst()",
-  documentationLink: "https://www.remotion.dev/docs/effects/starburst",
-  backend: "webgl2",
-  calculateKey: (params) => {
-    const r = resolve(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 createWebGL2ContextError("starburst effect");
-    }
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
-    const vs = compileShader(gl, gl.VERTEX_SHADER, STARBURST_VS);
-    const fs = compileShader(gl, gl.FRAGMENT_SHADER, STARBURST_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 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 = resolve(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
-});
+import {
+  starburstEffectSchema2,
+  starburst2
+} from "./index-18y0zcy2.mjs";
 export {
-  starburst,
-  starburstEffectSchema
+  starburst2 as starburst,
+  starburstEffectSchema2 as starburstEffectSchema
 };