@ansh-ui/core 0.2.0

package/dist/chunk-R7UJ7MWP.cjs

@@ -0,0 +1,2479 @@
+'use strict';
+
+var chunk23GSSIMK_cjs = require('./chunk-23GSSIMK.cjs');
+var chunkDXJ63QAR_cjs = require('./chunk-DXJ63QAR.cjs');
+var chunkFNR35HTL_cjs = require('./chunk-FNR35HTL.cjs');
+var chunkMMO7KO53_cjs = require('./chunk-MMO7KO53.cjs');
+var chunkLGA3N3YJ_cjs = require('./chunk-LGA3N3YJ.cjs');
+var chunkILKUL7GD_cjs = require('./chunk-ILKUL7GD.cjs');
+
+// src/render/surface.ts
+function createSurface(canvas, options = {}) {
+  const maxDpr = Math.max(1, options.maxDevicePixelRatio ?? 2);
+  let resolution = chunkILKUL7GD_cjs.clamp(options.resolution ?? 1, 0.1, 1);
+  const size = {
+    width: 1,
+    height: 1,
+    pixelWidth: 1,
+    pixelHeight: 1,
+    scale: 1
+  };
+  let ctx = null;
+  let isLost = false;
+  let pendingResize = true;
+  let rafHandle = null;
+  let destroyed = false;
+  const acquireContext = () => {
+    ctx = canvas.getContext("2d", {
+      alpha: options.alpha ?? true,
+      willReadFrequently: options.willReadFrequently ?? false
+    });
+    if (!ctx) {
+      console.error(
+        "[ansh] Could not acquire a 2D canvas context. The effect will not render. This usually means too many live canvases on the page."
+      );
+    }
+  };
+  acquireContext();
+  const measure = () => {
+    const host = canvas.parentElement;
+    const rect = host ? host.getBoundingClientRect() : canvas.getBoundingClientRect();
+    const cssWidth = Math.max(1, Math.round(rect.width));
+    const cssHeight = Math.max(1, Math.round(rect.height));
+    const dpr = Math.min(
+      maxDpr,
+      typeof devicePixelRatio === "number" && devicePixelRatio > 0 ? devicePixelRatio : 1
+    );
+    const scale = dpr * resolution;
+    const pixelWidth = Math.max(1, Math.round(cssWidth * scale));
+    const pixelHeight = Math.max(1, Math.round(cssHeight * scale));
+    const changed = size.width !== cssWidth || size.height !== cssHeight || size.pixelWidth !== pixelWidth || size.pixelHeight !== pixelHeight;
+    size.width = cssWidth;
+    size.height = cssHeight;
+    size.pixelWidth = pixelWidth;
+    size.pixelHeight = pixelHeight;
+    size.scale = scale;
+    if (!changed) return;
+    canvas.width = pixelWidth;
+    canvas.height = pixelHeight;
+    canvas.style.width = `${cssWidth}px`;
+    canvas.style.height = `${cssHeight}px`;
+    if (ctx) ctx.setTransform(scale, 0, 0, scale, 0, 0);
+    options.onResize?.({ ...size });
+  };
+  const scheduleResize = () => {
+    pendingResize = true;
+    if (rafHandle !== null || destroyed) return;
+    rafHandle = requestAnimationFrame(() => {
+      rafHandle = null;
+      if (destroyed) return;
+      if (pendingResize) {
+        pendingResize = false;
+        measure();
+      }
+    });
+  };
+  const stopResizeObserver = canvas.parentElement ? chunkMMO7KO53_cjs.observeResize(canvas.parentElement, scheduleResize) : () => {
+  };
+  const onContextLost = (event) => {
+    event.preventDefault();
+    isLost = true;
+  };
+  const onContextRestored = () => {
+    isLost = false;
+    acquireContext();
+    measure();
+    if (ctx) ctx.setTransform(size.scale, 0, 0, size.scale, 0, 0);
+    options.onRestore?.();
+  };
+  canvas.addEventListener("contextlost", onContextLost);
+  canvas.addEventListener("contextrestored", onContextRestored);
+  measure();
+  return {
+    canvas,
+    get ctx() {
+      return ctx;
+    },
+    get size() {
+      return size;
+    },
+    get isLost() {
+      return isLost;
+    },
+    clear() {
+      if (!ctx || isLost) return;
+      ctx.setTransform(1, 0, 0, 1, 0, 0);
+      ctx.clearRect(0, 0, size.pixelWidth, size.pixelHeight);
+      ctx.setTransform(size.scale, 0, 0, size.scale, 0, 0);
+    },
+    setResolution(next) {
+      const clamped = chunkILKUL7GD_cjs.clamp(next, 0.1, 1);
+      if (Math.abs(clamped - resolution) < 0.02) return;
+      resolution = clamped;
+      scheduleResize();
+    },
+    resize: scheduleResize,
+    destroy() {
+      destroyed = true;
+      if (rafHandle !== null) cancelAnimationFrame(rafHandle);
+      stopResizeObserver();
+      canvas.removeEventListener("contextlost", onContextLost);
+      canvas.removeEventListener("contextrestored", onContextRestored);
+      canvas.width = 1;
+      canvas.height = 1;
+      ctx = null;
+    }
+  };
+}
+function supportsOffscreenCanvas() {
+  if (typeof OffscreenCanvas === "undefined") return false;
+  try {
+    const probe = new OffscreenCanvas(1, 1);
+    return probe.getContext("2d") !== null;
+  } catch {
+    return false;
+  }
+}
+function supportsWorkerRendering(canvas) {
+  return supportsOffscreenCanvas() && typeof canvas.transferControlToOffscreen === "function";
+}
+
+// src/render/draw.ts
+var GradientCache = class {
+  constructor(limit = 128) {
+    this.limit = limit;
+  }
+  limit;
+  cache = /* @__PURE__ */ new Map();
+  radial(ctx, radius, stops, key) {
+    const cached = this.cache.get(key);
+    if (cached) return cached;
+    const gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, Math.max(0.01, radius));
+    for (const [offset, color] of stops) gradient.addColorStop(offset, color);
+    if (this.cache.size >= this.limit) this.cache.clear();
+    this.cache.set(key, gradient);
+    return gradient;
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+function drawGlow(ctx, x, y, radius, color, intensity = 1, cache) {
+  if (radius <= 0 || intensity <= 0) return;
+  const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+  const alpha = color.a * intensity;
+  const stops = [
+    [0, `rgba(${rgb},${alpha})`],
+    [0.35, `rgba(${rgb},${alpha * 0.55})`],
+    [0.65, `rgba(${rgb},${alpha * 0.18})`],
+    [1, `rgba(${rgb},0)`]
+  ];
+  ctx.save();
+  ctx.translate(x, y);
+  const gradient = cache ? cache.radial(ctx, radius, stops, `${rgb}|${alpha.toFixed(3)}|${radius.toFixed(1)}`) : buildRadial(ctx, radius, stops);
+  ctx.fillStyle = gradient;
+  ctx.beginPath();
+  ctx.arc(0, 0, radius, 0, chunkILKUL7GD_cjs.TAU);
+  ctx.fill();
+  ctx.restore();
+}
+function buildRadial(ctx, radius, stops) {
+  const gradient = ctx.createRadialGradient(0, 0, 0, 0, 0, Math.max(0.01, radius));
+  for (const [offset, color] of stops) gradient.addColorStop(offset, color);
+  return gradient;
+}
+function drawDot(ctx, x, y, radius, color) {
+  if (radius <= 0) return;
+  ctx.fillStyle = chunk23GSSIMK_cjs.toRgbString(color);
+  ctx.beginPath();
+  ctx.arc(x, y, radius, 0, chunkILKUL7GD_cjs.TAU);
+  ctx.fill();
+}
+function traceClosedSpline(ctx, points, tension = 0.5) {
+  const n = points.length;
+  if (n < 3) {
+    if (n === 2) {
+      ctx.moveTo(points[0].x, points[0].y);
+      ctx.lineTo(points[1].x, points[1].y);
+    }
+    return;
+  }
+  const at = (i) => points[(i % n + n) % n];
+  const k = tension / 3;
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 0; i < n; i++) {
+    const p0 = at(i - 1);
+    const p1 = at(i);
+    const p2 = at(i + 1);
+    const p3 = at(i + 2);
+    ctx.bezierCurveTo(
+      p1.x + (p2.x - p0.x) * k,
+      p1.y + (p2.y - p0.y) * k,
+      p2.x - (p3.x - p1.x) * k,
+      p2.y - (p3.y - p1.y) * k,
+      p2.x,
+      p2.y
+    );
+  }
+  ctx.closePath();
+}
+function traceOpenSpline(ctx, points, tension = 0.5) {
+  const n = points.length;
+  if (n < 2) return;
+  if (n === 2) {
+    ctx.moveTo(points[0].x, points[0].y);
+    ctx.lineTo(points[1].x, points[1].y);
+    return;
+  }
+  const k = tension / 3;
+  const at = (i) => points[Math.max(0, Math.min(n - 1, i))];
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 0; i < n - 1; i++) {
+    const p0 = at(i - 1);
+    const p1 = at(i);
+    const p2 = at(i + 1);
+    const p3 = at(i + 2);
+    ctx.bezierCurveTo(
+      p1.x + (p2.x - p0.x) * k,
+      p1.y + (p2.y - p0.y) * k,
+      p2.x - (p3.x - p1.x) * k,
+      p2.y - (p3.y - p1.y) * k,
+      p2.x,
+      p2.y
+    );
+  }
+}
+function traceRoundRect(ctx, x, y, width, height, radius) {
+  const r = Math.min(radius, width / 2, height / 2);
+  if (typeof ctx.roundRect === "function") {
+    ctx.roundRect(x, y, width, height, r);
+    return;
+  }
+  ctx.moveTo(x + r, y);
+  ctx.lineTo(x + width - r, y);
+  ctx.arcTo(x + width, y, x + width, y + r, r);
+  ctx.lineTo(x + width, y + height - r);
+  ctx.arcTo(x + width, y + height, x + width - r, y + height, r);
+  ctx.lineTo(x + r, y + height);
+  ctx.arcTo(x, y + height, x, y + height - r, r);
+  ctx.lineTo(x, y + r);
+  ctx.arcTo(x, y, x + r, y, r);
+  ctx.closePath();
+}
+var filterSupport = null;
+function supportsCanvasFilter(ctx) {
+  if (filterSupport !== null) return filterSupport;
+  const previous = ctx.filter;
+  try {
+    ctx.filter = "blur(1px)";
+    filterSupport = ctx.filter === "blur(1px)";
+  } catch {
+    filterSupport = false;
+  } finally {
+    ctx.filter = previous;
+  }
+  return filterSupport;
+}
+function resetFilterSupport() {
+  filterSupport = null;
+}
+
+// src/effects/mount.ts
+var CANVAS_STYLE = {
+  position: "absolute",
+  inset: "0",
+  width: "100%",
+  height: "100%",
+  display: "block",
+  // A background canvas must never intercept clicks meant for the content above it.
+  pointerEvents: "none"
+};
+function mountEffect(definition, host, userOptions = {}) {
+  chunkMMO7KO53_cjs.getRegistry().requireCapability(definition.capability ?? "effect:core");
+  let options = { ...definition.defaults, ...stripUndefined(userOptions) };
+  const canvas = document.createElement("canvas");
+  canvas.setAttribute("aria-hidden", "true");
+  canvas.setAttribute("role", "presentation");
+  Object.assign(canvas.style, CANVAS_STYLE);
+  if (getComputedStyle(host).position === "static") host.style.position = "relative";
+  host.appendChild(canvas);
+  let instance = null;
+  let context = null;
+  let pointer = null;
+  let tickerSubscription = null;
+  let intersectionSubscription = null;
+  let reducedMotionSubscription = null;
+  let destroyed = false;
+  let userPaused = options.paused ?? false;
+  let offscreen = false;
+  let motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+  let pendingSingleFrame = false;
+  const ticker = chunkMMO7KO53_cjs.getTicker();
+  const surface = createSurface(canvas, {
+    resolution: options.resolution ?? 1,
+    alpha: true,
+    onResize: (size) => {
+      instance?.resize?.(size);
+      pendingSingleFrame = true;
+    },
+    onRestore: () => {
+      rebuild();
+    }
+  });
+  function buildContext() {
+    const ctx = surface.ctx;
+    if (!ctx) return null;
+    const seed = options.seed ?? 1;
+    const colors = resolveResolvedColors(options.colors, host);
+    return {
+      ctx,
+      surface,
+      size: surface.size,
+      rng: chunkFNR35HTL_cjs.createRng(seed),
+      noise: chunkDXJ63QAR_cjs.createNoise(seed),
+      pointer: pointer ? pointer.state : null,
+      host,
+      colors
+    };
+  }
+  function rebuild() {
+    instance?.destroy?.();
+    instance = null;
+    context = buildContext();
+    if (!context) return;
+    instance = definition.setup(context, options);
+    instance.resize?.(surface.size);
+    pendingSingleFrame = true;
+  }
+  function ensurePointer() {
+    const wants = options.interactive !== false;
+    if (wants && !pointer) {
+      pointer = chunkMMO7KO53_cjs.trackPointer(host);
+    } else if (!wants && pointer) {
+      pointer.destroy();
+      pointer = null;
+    }
+  }
+  ensurePointer();
+  rebuild();
+  const applyQuality = (quality) => {
+    if (options.performance === "high" || options.performance === "low") return;
+    const base = options.resolution ?? 1;
+    surface.setResolution(base * chunkILKUL7GD_cjs.clamp(0.5 + quality * 0.5, 0.5, 1));
+  };
+  const frame = (state) => {
+    if (destroyed || surface.isLost || !instance || !context) return;
+    if ((userPaused || offscreen || !motion.animate) && !pendingSingleFrame) return;
+    pendingSingleFrame = false;
+    const ctx = surface.ctx;
+    if (!ctx) return;
+    applyQuality(state.quality);
+    ctx.save();
+    const opacity = chunkILKUL7GD_cjs.clamp(options.opacity ?? 1, 0, 1);
+    if (opacity < 1) ctx.globalAlpha = opacity;
+    const blur = options.blur ?? 0;
+    if (blur > 0 && supportsCanvasFilter(ctx)) ctx.filter = `blur(${blur}px)`;
+    const speed = (options.speed ?? 1) * motion.timeScale;
+    instance.frame({
+      ...state,
+      time: state.time * speed,
+      delta: state.delta * speed
+    });
+    ctx.restore();
+  };
+  function startTicker() {
+    if (tickerSubscription || destroyed) return;
+    tickerSubscription = ticker.add(frame, { phase: "write", name: `effect:${definition.name}` });
+  }
+  function stopTicker() {
+    tickerSubscription?.();
+    tickerSubscription = null;
+  }
+  if (options.performance === "high") ticker.lockQuality(1);
+  else if (options.performance === "low") ticker.lockQuality(0.4);
+  if (options.pauseOffscreen !== false) {
+    intersectionSubscription = chunkMMO7KO53_cjs.observeIntersection(
+      host,
+      (entry) => {
+        offscreen = !entry.isIntersecting;
+        if (offscreen) stopTicker();
+        else if (!userPaused && motion.animate) startTicker();
+      },
+      // A generous margin means the effect is already warm by the time it scrolls in, rather
+      // than starting from its first frame in view.
+      { rootMargin: "200px" }
+    );
+  }
+  reducedMotionSubscription = chunkMMO7KO53_cjs.onReducedMotionChange(() => {
+    motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+    if (motion.animate && !userPaused && !offscreen) {
+      startTicker();
+    } else {
+      stopTicker();
+      if (motion.renderOnce) renderSingleFrame();
+    }
+  });
+  function renderSingleFrame() {
+    pendingSingleFrame = true;
+    ticker.once((state) => frame(state));
+  }
+  if (motion.animate && !userPaused) startTicker();
+  else if (motion.renderOnce) renderSingleFrame();
+  return {
+    canvas,
+    update(next) {
+      if (destroyed) return;
+      const incoming = stripUndefined(next);
+      const structural = definition.structuralOptions ?? [];
+      const needsRebuild = (
+        // A changed seed changes every stochastic decision; nothing can be salvaged.
+        "seed" in incoming && incoming.seed !== options.seed || structural.some(
+          (key) => key in incoming && incoming[key] !== options[key]
+        ) || // No live-update path means the only correct response is to rebuild.
+        !instance?.update && Object.keys(incoming).length > 0
+      );
+      const previousInteractive = options.interactive;
+      options = { ...options, ...incoming };
+      if (options.interactive !== previousInteractive) {
+        ensurePointer();
+        rebuild();
+      } else if (needsRebuild) {
+        rebuild();
+      } else if (instance?.update && context) {
+        const resolved = resolveResolvedColors(options.colors, host);
+        context.colors = resolved;
+        instance.update(incoming, context);
+        pendingSingleFrame = true;
+      }
+      if (options.resolution !== void 0) surface.setResolution(options.resolution);
+      const wasPaused = userPaused;
+      userPaused = options.paused ?? false;
+      motion = chunkMMO7KO53_cjs.resolveMotion(options.reducedMotion, 0.25);
+      if (wasPaused && !userPaused && motion.animate && !offscreen) startTicker();
+      if (!wasPaused && userPaused) stopTicker();
+      if (!motion.animate && motion.renderOnce) renderSingleFrame();
+    },
+    pause() {
+      userPaused = true;
+      stopTicker();
+    },
+    resume() {
+      userPaused = false;
+      if (motion.animate && !offscreen) startTicker();
+    },
+    renderOnce: renderSingleFrame,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      stopTicker();
+      intersectionSubscription?.();
+      reducedMotionSubscription?.();
+      pointer?.destroy();
+      instance?.destroy?.();
+      surface.destroy();
+      if (canvas.parentNode === host) host.removeChild(canvas);
+      instance = null;
+      context = null;
+      pointer = null;
+    },
+    get isRunning() {
+      return tickerSubscription !== null;
+    }
+  };
+}
+function resolveResolvedColors(colors, host) {
+  if (Array.isArray(colors)) {
+    return colors.map((color) => {
+      if (typeof color === "string" && color.includes("var(")) {
+        const resolved = resolveAgainst(color, host);
+        if (resolved) return resolved;
+      }
+      return chunkLGA3N3YJ_cjs.parseColor(color);
+    });
+  }
+  return chunk23GSSIMK_cjs.resolvePalette(colors);
+}
+function resolveAgainst(value, host) {
+  const probe = document.createElement("span");
+  probe.style.display = "none";
+  probe.style.color = value;
+  host.appendChild(probe);
+  const computed = getComputedStyle(probe).color;
+  host.removeChild(probe);
+  try {
+    return computed ? chunkLGA3N3YJ_cjs.parseColor(computed) : null;
+  } catch {
+    return null;
+  }
+}
+function stripUndefined(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function defineEffect(definition) {
+  const registry = chunkMMO7KO53_cjs.getRegistry();
+  if (!registry.has("effect", definition.name)) {
+    registry.register("effect", definition.name, definition);
+  }
+  return definition;
+}
+
+// src/effects/particles/buffer.ts
+var ParticleBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    const n = Math.max(1, Math.floor(capacity));
+    this.x = new Float32Array(n);
+    this.y = new Float32Array(n);
+    this.vx = new Float32Array(n);
+    this.vy = new Float32Array(n);
+    this.life = new Float32Array(n);
+    this.maxLife = new Float32Array(n);
+    this.size = new Float32Array(n);
+    this.colorIndex = new Uint8Array(n);
+    this.seed = new Float32Array(n);
+    this.extra = new Float32Array(n);
+  }
+  capacity;
+  x;
+  y;
+  vx;
+  vy;
+  /** Remaining life in seconds. `Infinity` for particles that never expire. */
+  life;
+  /** Life the particle started with, for computing normalised age. */
+  maxLife;
+  size;
+  /** Index into the effect's resolved palette. */
+  colorIndex;
+  /** Free-form per-particle scalar — phase, spin, depth, whatever the effect needs. */
+  seed;
+  /** Second free-form scalar. */
+  extra;
+  liveCount = 0;
+  get count() {
+    return this.liveCount;
+  }
+  /**
+   * Claim a slot.
+   * @returns The particle index, or `-1` when the buffer is full. Callers must check.
+   */
+  spawn() {
+    if (this.liveCount >= this.capacity) return -1;
+    return this.liveCount++;
+  }
+  /**
+   * Kill particle `index` by swapping the last live particle into its slot.
+   *
+   * The caller's loop must **not** advance its cursor after calling this, since a new particle
+   * now occupies the current index. Every consumer in this package follows that contract with
+   * a `while` loop rather than a `for`.
+   */
+  kill(index) {
+    const last = --this.liveCount;
+    if (index === last) return;
+    this.x[index] = this.x[last];
+    this.y[index] = this.y[last];
+    this.vx[index] = this.vx[last];
+    this.vy[index] = this.vy[last];
+    this.life[index] = this.life[last];
+    this.maxLife[index] = this.maxLife[last];
+    this.size[index] = this.size[last];
+    this.colorIndex[index] = this.colorIndex[last];
+    this.seed[index] = this.seed[last];
+    this.extra[index] = this.extra[last];
+  }
+  /** Normalised age in `[0, 1]`. `0` for immortal particles. */
+  age(index) {
+    const max = this.maxLife[index];
+    if (!Number.isFinite(max) || max <= 0) return 0;
+    return 1 - this.life[index] / max;
+  }
+  /**
+   * Reduce the live count, keeping the first `target` particles.
+   *
+   * Used by adaptive quality: dropping from 1,200 to 800 particles must not resample or
+   * reshuffle, because a visible reshuffle draws far more attention than the density change.
+   */
+  truncate(target) {
+    this.liveCount = Math.max(0, Math.min(this.liveCount, Math.floor(target)));
+  }
+  clear() {
+    this.liveCount = 0;
+  }
+};
+function integrate(buffer, dt, drag = 0) {
+  const { x, y, vx, vy } = buffer;
+  const count = buffer.count;
+  if (drag > 0) {
+    const retain = Math.pow(1 - Math.min(0.999, drag), dt);
+    for (let i = 0; i < count; i++) {
+      vx[i] *= retain;
+      vy[i] *= retain;
+      x[i] += vx[i] * dt;
+      y[i] += vy[i] * dt;
+    }
+    return;
+  }
+  for (let i = 0; i < count; i++) {
+    x[i] += vx[i] * dt;
+    y[i] += vy[i] * dt;
+  }
+}
+function ageAndCull(buffer, dt) {
+  let i = 0;
+  while (i < buffer.count) {
+    buffer.life[i] -= dt;
+    if (buffer.life[i] <= 0) {
+      buffer.kill(i);
+      continue;
+    }
+    i++;
+  }
+}
+function wrapBounds(buffer, width, height, margin = 0) {
+  const { x, y } = buffer;
+  const count = buffer.count;
+  const left = -margin;
+  const top = -margin;
+  const right = width + margin;
+  const bottom = height + margin;
+  const spanX = right - left;
+  const spanY = bottom - top;
+  for (let i = 0; i < count; i++) {
+    if (x[i] < left) x[i] += spanX;
+    else if (x[i] > right) x[i] -= spanX;
+    if (y[i] < top) y[i] += spanY;
+    else if (y[i] > bottom) y[i] -= spanY;
+  }
+}
+var SpatialGrid = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cellStart = new Int32Array(2);
+    this.items = new Int32Array(Math.max(1, capacity));
+    this.counts = new Int32Array(1);
+  }
+  capacity;
+  cols = 1;
+  rows = 1;
+  cellSize = 1;
+  /** Start index of each cell's run inside `items`. Length `cols * rows + 1`. */
+  cellStart;
+  /** Particle indices, grouped by cell. */
+  items;
+  /** Scratch counters used while building. */
+  counts;
+  /**
+   * Bucket every live particle. Must be called before {@link forEachNeighbour}.
+   * @param cellSize Should equal the query radius — smaller means more cells to scan, larger
+   *                 means more candidates per cell.
+   */
+  build(buffer, width, height, cellSize) {
+    this.cellSize = Math.max(1, cellSize);
+    this.cols = Math.max(1, Math.ceil(width / this.cellSize));
+    this.rows = Math.max(1, Math.ceil(height / this.cellSize));
+    const cellCount = this.cols * this.rows;
+    if (this.counts.length < cellCount) this.counts = new Int32Array(cellCount);
+    else this.counts.fill(0, 0, cellCount);
+    if (this.cellStart.length < cellCount + 1) this.cellStart = new Int32Array(cellCount + 1);
+    if (this.items.length < this.capacity) this.items = new Int32Array(this.capacity);
+    const count = buffer.count;
+    for (let i = 0; i < count; i++) {
+      this.counts[this.cellIndex(buffer.x[i], buffer.y[i])]++;
+    }
+    let running = 0;
+    for (let c = 0; c < cellCount; c++) {
+      this.cellStart[c] = running;
+      running += this.counts[c];
+    }
+    this.cellStart[cellCount] = running;
+    this.counts.fill(0, 0, cellCount);
+    for (let i = 0; i < count; i++) {
+      const cell = this.cellIndex(buffer.x[i], buffer.y[i]);
+      this.items[this.cellStart[cell] + this.counts[cell]++] = i;
+    }
+  }
+  cellIndex(x, y) {
+    const cx = Math.min(this.cols - 1, Math.max(0, Math.floor(x / this.cellSize)));
+    const cy = Math.min(this.rows - 1, Math.max(0, Math.floor(y / this.cellSize)));
+    return cy * this.cols + cx;
+  }
+  /**
+   * Visit candidate neighbours of particle `index` in the 3×3 cell block around it.
+   *
+   * Only pairs where `neighbour > index` are visited, so each pair is reported exactly once —
+   * which halves the work and means the caller doesn't need a "have I drawn this line" check.
+   * The callback still receives candidates outside the radius; the caller does the exact test,
+   * because it usually needs the distance anyway.
+   */
+  forEachNeighbour(buffer, index, visit) {
+    const cx = Math.floor(buffer.x[index] / this.cellSize);
+    const cy = Math.floor(buffer.y[index] / this.cellSize);
+    const minX = Math.max(0, cx - 1);
+    const maxX = Math.min(this.cols - 1, cx + 1);
+    const minY = Math.max(0, cy - 1);
+    const maxY = Math.min(this.rows - 1, cy + 1);
+    for (let y = minY; y <= maxY; y++) {
+      const rowBase = y * this.cols;
+      for (let x = minX; x <= maxX; x++) {
+        const cell = rowBase + x;
+        const start = this.cellStart[cell];
+        const end = this.cellStart[cell + 1];
+        for (let k = start; k < end; k++) {
+          const neighbour = this.items[k];
+          if (neighbour > index) visit(neighbour);
+        }
+      }
+    }
+  }
+};
+
+// src/effects/backgrounds/aurora.ts
+var DEFAULTS = {
+  colors: "aurora",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 24,
+  blend: "lighter",
+  seed: 1,
+  interactive: true,
+  // Aurora is entirely soft-focus. Rendering above half resolution is spending fill rate on
+  // detail the blur immediately destroys.
+  resolution: 0.5,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  curtains: 4,
+  slices: 48,
+  height: 0.75,
+  position: 0.42,
+  detail: 2.4,
+  drift: 0.18,
+  falloff: 0.55,
+  pointerInfluence: 0.35
+};
+var aurora = defineEffect({
+  name: "aurora",
+  defaults: DEFAULTS,
+  // Changing the curtain count rebuilds the whole composition; there is nothing to reconcile.
+  structuralOptions: ["curtains", "slices"],
+  setup(context, options) {
+    let opts = options;
+    let curtains = [];
+    const ridged = context.noise.ridged2D({ octaves: 4, gain: 0.55, lacunarity: 2.2 });
+    const flow = context.noise.fbm2D({ octaves: 2, gain: 0.5 });
+    function build() {
+      const count = Math.max(1, Math.floor(opts.curtains));
+      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const rng = context.rng;
+      curtains = [];
+      for (let i = 0; i < count; i++) {
+        const slot = (i + 0.5) / count;
+        curtains.push({
+          color: palette[i],
+          center: chunkILKUL7GD_cjs.clamp(slot + rng.range(-0.12, 0.12), 0.05, 0.95),
+          width: rng.range(0.28, 0.6),
+          noiseOffset: rng.range(0, 100),
+          speed: rng.range(0.6, 1.4),
+          yOffset: rng.range(-0.08, 0.08),
+          // Later curtains are dimmer, which creates depth ordering without a z-buffer.
+          alpha: chunkILKUL7GD_cjs.lerp(0.95, 0.5, count === 1 ? 0 : i / (count - 1))
+        });
+      }
+    }
+    build();
+    const instance = {
+      frame({ time }) {
+        const { ctx, size, pointer } = context;
+        const { width, height } = size;
+        context.surface.clear();
+        const sliceCount = Math.max(4, Math.floor(opts.slices));
+        const bandHeight = height * chunkILKUL7GD_cjs.clamp(opts.height, 0.05, 2);
+        const bandCenter = height * chunkILKUL7GD_cjs.clamp(opts.position, 0, 1);
+        const intensity = Math.max(0, opts.intensity);
+        const detail = Math.max(0.1, opts.detail);
+        const drift = opts.drift;
+        const falloff = chunkILKUL7GD_cjs.clamp(opts.falloff, 0, 1);
+        const sway = pointer && opts.interactive !== false ? (pointer.smoothNx - 0.5) * width * opts.pointerInfluence : 0;
+        const previousBlend = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        for (const curtain of curtains) {
+          const t = time * curtain.speed;
+          const curtainWidth = width * curtain.width;
+          const centerX = width * curtain.center + sway * curtain.speed * 0.5;
+          const startX = centerX - curtainWidth / 2;
+          const sliceWidth = curtainWidth / sliceCount;
+          const top = bandCenter - bandHeight / 2 + height * curtain.yOffset;
+          const bottom = top + bandHeight;
+          const gradient = ctx.createLinearGradient(0, top, 0, bottom);
+          const rgb = `${Math.round(curtain.color.r * 255)},${Math.round(curtain.color.g * 255)},${Math.round(curtain.color.b * 255)}`;
+          const peak = curtain.alpha * intensity;
+          gradient.addColorStop(0, `rgba(${rgb},0)`);
+          gradient.addColorStop(chunkILKUL7GD_cjs.lerp(0.45, 0.25, falloff), `rgba(${rgb},${peak * 0.75})`);
+          gradient.addColorStop(0.72, `rgba(${rgb},${peak})`);
+          gradient.addColorStop(1, `rgba(${rgb},0)`);
+          ctx.fillStyle = gradient;
+          for (let i = 0; i < sliceCount; i++) {
+            const u = i / sliceCount;
+            const filament = ridged(
+              u * detail * 4 + curtain.noiseOffset,
+              t * 0.12 + curtain.noiseOffset
+            );
+            const fold = flow(u * detail + curtain.noiseOffset, t * 0.18) * width * drift * 0.5;
+            const rise = Math.sin(u * chunkILKUL7GD_cjs.TAU * 1.5 + t * 0.6 + curtain.noiseOffset) * height * 0.03;
+            const alpha = 0.3 + 0.7 * filament * filament;
+            if (alpha < 0.012) continue;
+            ctx.globalAlpha = chunkILKUL7GD_cjs.clamp(alpha, 0, 1);
+            ctx.fillRect(startX + i * sliceWidth + fold, top + rise, sliceWidth + 1, bandHeight);
+          }
+        }
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = previousBlend;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        if ("colors" in next) build();
+      },
+      destroy() {
+        curtains = [];
+      }
+    };
+    return instance;
+  }
+});
+
+// src/effects/backgrounds/mesh-gradient.ts
+var DEFAULTS2 = {
+  colors: "ansh",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 40,
+  blend: "lighter",
+  seed: 7,
+  interactive: true,
+  // Quarter resolution. The output is a heavily blurred gradient field — there is literally no
+  // recoverable detail above this, and it cuts fill cost by 16×.
+  resolution: 0.25,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  points: 5,
+  radius: 0.55,
+  wander: 0.22,
+  pointerInfluence: 0.4,
+  pointerRadius: 0.45,
+  backdrop: true,
+  grain: 0.04
+};
+var meshGradient = defineEffect({
+  name: "mesh-gradient",
+  defaults: DEFAULTS2,
+  structuralOptions: ["points"],
+  setup(context, options) {
+    let opts = options;
+    let points = [];
+    let backdropColor = { r: 0, g: 0, b: 0};
+    let grainTile = null;
+    function build() {
+      const count = Math.max(1, Math.floor(opts.points));
+      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const rng = context.rng;
+      backdropColor = palette.reduce(
+        (darkest, c) => c.r + c.g + c.b < darkest.r + darkest.g + darkest.b ? c : darkest
+      );
+      points = [];
+      for (let i = 0; i < count; i++) {
+        const angle = i / count * chunkILKUL7GD_cjs.TAU + rng.range(-0.4, 0.4);
+        const distance = rng.range(0.18, 0.42);
+        points.push({
+          color: palette[i],
+          homeX: 0.5 + Math.cos(angle) * distance,
+          homeY: 0.5 + Math.sin(angle) * distance,
+          // Irrational-ish frequency ratios: the path's period is the LCM of the two, which
+          // for these values is long enough that no viewer will see it close.
+          freqX1: rng.range(0.08, 0.17),
+          freqX2: rng.range(0.19, 0.31),
+          freqY1: rng.range(0.09, 0.19),
+          freqY2: rng.range(0.21, 0.34),
+          phaseX: rng.range(0, chunkILKUL7GD_cjs.TAU),
+          phaseY: rng.range(0, chunkILKUL7GD_cjs.TAU),
+          scale: rng.range(0.75, 1.3),
+          x: 0,
+          y: 0
+        });
+      }
+    }
+    function buildGrain() {
+      const strength = chunkILKUL7GD_cjs.clamp(opts.grain, 0, 1);
+      if (strength <= 0) {
+        grainTile = null;
+        return;
+      }
+      const SIZE = 128;
+      const tile = document.createElement("canvas");
+      tile.width = SIZE;
+      tile.height = SIZE;
+      const tileCtx = tile.getContext("2d");
+      if (!tileCtx) {
+        grainTile = null;
+        return;
+      }
+      const image = tileCtx.createImageData(SIZE, SIZE);
+      const data = image.data;
+      const rng = context.rng.fork();
+      for (let i = 0; i < data.length; i += 4) {
+        const value = rng.next() * 255;
+        data[i] = value;
+        data[i + 1] = value;
+        data[i + 2] = value;
+        data[i + 3] = 255;
+      }
+      tileCtx.putImageData(image, 0, 0);
+      grainTile = tile;
+    }
+    build();
+    buildGrain();
+    const instance = {
+      frame({ time }) {
+        const { ctx, size, pointer, surface } = context;
+        const { width, height } = size;
+        const diagonal = Math.hypot(width, height);
+        surface.clear();
+        const intensity = chunkILKUL7GD_cjs.clamp(opts.intensity, 0, 4);
+        const wander = opts.wander;
+        const baseRadius = diagonal * chunkILKUL7GD_cjs.clamp(opts.radius, 0.05, 2);
+        if (opts.backdrop) {
+          ctx.globalCompositeOperation = "source-over";
+          ctx.fillStyle = `rgb(${Math.round(backdropColor.r * 255)},${Math.round(backdropColor.g * 255)},${Math.round(backdropColor.b * 255)})`;
+          ctx.fillRect(0, 0, width, height);
+        }
+        const interactive = opts.interactive !== false && pointer !== null;
+        const pointerX = interactive ? pointer.smoothNx : 0.5;
+        const pointerY = interactive ? pointer.smoothNy : 0.5;
+        const pointerActive = interactive && pointer.everInside;
+        const pointerStrength = pointerActive ? chunkILKUL7GD_cjs.clamp(opts.pointerInfluence, 0, 1) : 0;
+        const pointerRadius = chunkILKUL7GD_cjs.clamp(opts.pointerRadius, 0.01, 2);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        for (const point of points) {
+          const driftX = (Math.sin(time * point.freqX1 + point.phaseX) * 0.6 + Math.sin(time * point.freqX2 + point.phaseX * 1.7) * 0.4) * wander;
+          const driftY = (Math.cos(time * point.freqY1 + point.phaseY) * 0.6 + Math.cos(time * point.freqY2 + point.phaseY * 1.3) * 0.4) * wander;
+          let nx = point.homeX + driftX;
+          let ny = point.homeY + driftY;
+          if (pointerStrength > 0) {
+            const dx = pointerX - nx;
+            const dy = pointerY - ny;
+            const distance = Math.hypot(dx, dy);
+            const falloff = chunkILKUL7GD_cjs.clamp(1 - distance / pointerRadius, 0, 1);
+            const pull = falloff * falloff * pointerStrength;
+            nx += dx * pull;
+            ny += dy * pull;
+          }
+          point.x = nx * width;
+          point.y = ny * height;
+          const radius = baseRadius * point.scale;
+          const rgb = `${Math.round(point.color.r * 255)},${Math.round(point.color.g * 255)},${Math.round(point.color.b * 255)}`;
+          const peak = chunkILKUL7GD_cjs.clamp(point.color.a * intensity * 0.85, 0, 1);
+          const gradient = ctx.createRadialGradient(point.x, point.y, 0, point.x, point.y, radius);
+          gradient.addColorStop(0, `rgba(${rgb},${peak})`);
+          gradient.addColorStop(0.3, `rgba(${rgb},${peak * 0.62})`);
+          gradient.addColorStop(0.62, `rgba(${rgb},${peak * 0.22})`);
+          gradient.addColorStop(1, `rgba(${rgb},0)`);
+          ctx.fillStyle = gradient;
+          ctx.fillRect(point.x - radius, point.y - radius, radius * 2, radius * 2);
+        }
+        if (grainTile) {
+          const strength = chunkILKUL7GD_cjs.clamp(opts.grain, 0, 1);
+          ctx.globalCompositeOperation = "overlay";
+          ctx.globalAlpha = strength;
+          const pattern = ctx.createPattern(grainTile, "repeat");
+          if (pattern) {
+            ctx.fillStyle = pattern;
+            ctx.fillRect(0, 0, width, height);
+          }
+          ctx.globalAlpha = 1;
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        const previousGrain = opts.grain;
+        opts = {
+          ...opts,
+          ...next
+        };
+        if ("colors" in next) build();
+        if (opts.grain !== previousGrain) buildGrain();
+      },
+      destroy() {
+        points = [];
+        if (grainTile) {
+          grainTile.width = 1;
+          grainTile.height = 1;
+          grainTile = null;
+        }
+      }
+    };
+    return instance;
+  }
+});
+var GRADIENT_DEFAULTS = {
+  colors: "ansh",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "source-over",
+  seed: 1,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  rotation: 4,
+  angle: 120,
+  travel: 0.25,
+  stops: 24
+};
+var animatedGradient = defineEffect({
+  name: "animated-gradient",
+  defaults: GRADIENT_DEFAULTS,
+  setup(context, options) {
+    let opts = options;
+    let samples = [];
+    function build() {
+      const count = Math.max(2, Math.floor(opts.stops));
+      const doubled = [...context.colors, ...context.colors, context.colors[0]];
+      samples = chunk23GSSIMK_cjs.expandPalette(doubled, count * 2);
+    }
+    build();
+    return {
+      frame({ time }) {
+        const { ctx, size, surface } = context;
+        const { width, height } = size;
+        surface.clear();
+        const stopCount = Math.max(2, Math.floor(opts.stops));
+        const angleDeg = opts.angle + opts.rotation / 60 * time * 360;
+        const angle = angleDeg * Math.PI / 180;
+        const halfDiagonal = Math.hypot(width, height) / 2;
+        const cx = width / 2;
+        const cy = height / 2;
+        const dx = Math.cos(angle) * halfDiagonal;
+        const dy = Math.sin(angle) * halfDiagonal;
+        const gradient = ctx.createLinearGradient(cx - dx, cy - dy, cx + dx, cy + dy);
+        const phase = time * opts.travel * 0.1 % 1;
+        for (let i = 0; i < stopCount; i++) {
+          const t = i / (stopCount - 1);
+          const sampleIndex = Math.floor((t + phase) % 1 * (samples.length - 1));
+          const color = samples[sampleIndex];
+          const alpha = chunkILKUL7GD_cjs.clamp(color.a * opts.intensity, 0, 1);
+          gradient.addColorStop(
+            t,
+            `rgba(${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)},${alpha})`
+          );
+        }
+        ctx.globalCompositeOperation = opts.blend ?? "source-over";
+        ctx.fillStyle = gradient;
+        ctx.fillRect(0, 0, width, height);
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = {
+          ...opts,
+          ...next
+        };
+        if ("colors" in next || "stops" in next) build();
+      }
+    };
+  }
+});
+
+// src/effects/particles/field.ts
+var DEFAULTS3 = {
+  colors: "neon",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 3,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "pause",
+  paused: false,
+  pauseOffscreen: true,
+  count: 700,
+  size: 1.6,
+  sizeVariance: 0.6,
+  scale: 16e-4,
+  flowSpeed: 48,
+  fieldDrift: 0.12,
+  glow: true,
+  trails: 0,
+  pointerRadius: 140,
+  pointerForce: 1
+};
+var MAX_PARTICLES = 4e3;
+var particleField = defineEffect({
+  name: "particle-field",
+  defaults: DEFAULTS3,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(MAX_PARTICLES, Math.max(1, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    const gradients = new GradientCache(64);
+    const curl = context.noise.curlAnimated({ octaves: 2, gain: 0.5 });
+    let seeded = false;
+    function seed() {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        buffer.x[index] = rng.next() * width;
+        buffer.y[index] = rng.next() * height;
+        buffer.vx[index] = 0;
+        buffer.vy[index] = 0;
+        buffer.life[index] = Infinity;
+        buffer.maxLife[index] = Infinity;
+        buffer.size[index] = opts.size * (1 + (rng.next() * 2 - 1) * chunkILKUL7GD_cjs.clamp(opts.sizeVariance, 0, 1));
+        buffer.colorIndex[index] = rng.int(0, colorCount - 1);
+        buffer.seed[index] = rng.next() * chunkILKUL7GD_cjs.TAU;
+      }
+      seeded = true;
+    }
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, pointer, surface, colors } = context;
+        const { width, height } = size;
+        if (!seeded || buffer.count === 0 && width > 1) seed();
+        const targetCount = Math.max(
+          8,
+          Math.floor(capacity * (opts.performance === "high" ? 1 : quality))
+        );
+        if (buffer.count > targetCount) buffer.truncate(targetCount);
+        const trails = chunkILKUL7GD_cjs.clamp(opts.trails, 0, 0.98);
+        if (trails <= 0) {
+          surface.clear();
+        } else {
+          ctx.globalCompositeOperation = "destination-out";
+          ctx.fillStyle = `rgba(0,0,0,${1 - trails})`;
+          ctx.fillRect(0, 0, width, height);
+          ctx.globalCompositeOperation = "source-over";
+        }
+        const scale = Math.max(1e-6, opts.scale);
+        const flowSpeed = opts.flowSpeed * opts.intensity;
+        const fieldTime = time * opts.fieldDrift;
+        const count = buffer.count;
+        for (let i = 0; i < count; i++) {
+          const flow = curl(buffer.x[i] * scale, buffer.y[i] * scale, fieldTime);
+          buffer.vx[i] = flow.x * flowSpeed;
+          buffer.vy[i] = flow.y * flowSpeed;
+        }
+        if (opts.interactive !== false && pointer && pointer.everInside) {
+          const px = pointer.smoothX;
+          const py = pointer.smoothY;
+          const radius = Math.max(1, opts.pointerRadius);
+          const radiusSq = radius * radius;
+          const force = opts.pointerForce * flowSpeed * 2.4;
+          for (let i = 0; i < count; i++) {
+            const dx = buffer.x[i] - px;
+            const dy = buffer.y[i] - py;
+            const distSq = dx * dx + dy * dy;
+            if (distSq > radiusSq || distSq < 1e-4) continue;
+            const distance = Math.sqrt(distSq);
+            const falloff = 1 - distance / radius;
+            const push = force * falloff * falloff / distance;
+            buffer.vx[i] += dx * push;
+            buffer.vy[i] += dy * push;
+          }
+        }
+        integrate(buffer, delta, 0);
+        wrapBounds(buffer, width, height, opts.size * 4);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        const colorCount = Math.max(1, colors.length);
+        const glow = opts.glow;
+        for (let i = 0; i < count; i++) {
+          const color = colors[buffer.colorIndex[i] % colorCount];
+          const shimmer = 0.72 + 0.28 * Math.sin(time * 1.6 + buffer.seed[i]);
+          const radius = buffer.size[i];
+          if (glow) {
+            drawGlow(ctx, buffer.x[i], buffer.y[i], radius * 4, color, shimmer, gradients);
+          } else {
+            ctx.globalAlpha = chunkILKUL7GD_cjs.clamp(color.a * shimmer, 0, 1);
+            ctx.fillStyle = `rgb(${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)})`;
+            ctx.beginPath();
+            ctx.arc(buffer.x[i], buffer.y[i], radius, 0, chunkILKUL7GD_cjs.TAU);
+            ctx.fill();
+          }
+        }
+        ctx.globalAlpha = 1;
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        const previousSize = opts.size;
+        opts = {
+          ...opts,
+          ...next
+        };
+        if (opts.size !== previousSize) {
+          const rng = context.rng;
+          for (let i = 0; i < buffer.count; i++) {
+            buffer.size[i] = opts.size * (1 + (rng.next() * 2 - 1) * chunkILKUL7GD_cjs.clamp(opts.sizeVariance, 0, 1));
+          }
+        }
+        if ("colors" in next) {
+          const colorCount = Math.max(1, context.colors.length);
+          for (let i = 0; i < buffer.count; i++) {
+            buffer.colorIndex[i] = buffer.colorIndex[i] % colorCount;
+          }
+        }
+        gradients.clear();
+      },
+      destroy() {
+        buffer.clear();
+        gradients.clear();
+      }
+    };
+  }
+});
+
+// src/effects/particles/constellation.ts
+var DEFAULTS4 = {
+  colors: ["#8ab4ff", "#c9d7ff"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "source-over",
+  seed: 11,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  count: 120,
+  linkDistance: 140,
+  nodeSize: 2,
+  lineWidth: 1,
+  drift: 18,
+  pointerRadius: 180,
+  pointerLinks: true,
+  alphaSteps: 6
+};
+var MAX_NODES = 1200;
+var constellation = defineEffect({
+  name: "constellation",
+  defaults: DEFAULTS4,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(MAX_NODES, Math.max(2, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    const grid = new SpatialGrid(capacity);
+    let buckets = [];
+    let seeded = false;
+    function rebuildBuckets() {
+      const steps = Math.max(1, Math.floor(opts.alphaSteps));
+      buckets = Array.from({ length: steps }, () => []);
+    }
+    function seed() {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        buffer.x[index] = rng.next() * width;
+        buffer.y[index] = rng.next() * height;
+        const angle = rng.angle();
+        const speed = rng.range(0.4, 1.2);
+        buffer.vx[index] = Math.cos(angle) * speed;
+        buffer.vy[index] = Math.sin(angle) * speed;
+        buffer.life[index] = Infinity;
+        buffer.maxLife[index] = Infinity;
+        buffer.size[index] = opts.nodeSize * rng.range(0.7, 1.4);
+        buffer.colorIndex[index] = rng.int(0, colorCount - 1);
+        buffer.seed[index] = rng.next() * chunkILKUL7GD_cjs.TAU;
+      }
+      seeded = true;
+    }
+    rebuildBuckets();
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, pointer, surface, colors } = context;
+        const { width, height } = size;
+        if (!seeded || buffer.count === 0 && width > 1) seed();
+        const targetCount = Math.max(
+          6,
+          Math.floor(capacity * (opts.performance === "high" ? 1 : quality))
+        );
+        if (buffer.count > targetCount) buffer.truncate(targetCount);
+        surface.clear();
+        const drift = opts.drift * opts.intensity;
+        const count = buffer.count;
+        for (let i = 0; i < count; i++) {
+          buffer.x[i] += buffer.vx[i] * drift * delta;
+          buffer.y[i] += buffer.vy[i] * drift * delta;
+        }
+        wrapBounds(buffer, width, height, opts.nodeSize * 2);
+        const linkDistance = Math.max(1, opts.linkDistance);
+        grid.build(buffer, width, height, linkDistance);
+        const steps = buckets.length;
+        for (const bucket of buckets) bucket.length = 0;
+        const linkDistanceSq = linkDistance * linkDistance;
+        for (let i = 0; i < count; i++) {
+          const xi = buffer.x[i];
+          const yi = buffer.y[i];
+          grid.forEachNeighbour(buffer, i, (j) => {
+            const dx = buffer.x[j] - xi;
+            const dy = buffer.y[j] - yi;
+            const distSq = dx * dx + dy * dy;
+            if (distSq > linkDistanceSq) return;
+            const proximity = 1 - Math.sqrt(distSq) / linkDistance;
+            const bucketIndex = Math.min(steps - 1, Math.floor(proximity * proximity * steps));
+            const bucket = buckets[bucketIndex];
+            bucket.push(xi, yi, buffer.x[j], buffer.y[j]);
+          });
+        }
+        const interactive = opts.interactive !== false && pointer !== null && pointer.everInside;
+        if (interactive && opts.pointerLinks) {
+          const px = pointer.smoothX;
+          const py = pointer.smoothY;
+          const radius = Math.max(1, opts.pointerRadius);
+          const radiusSq = radius * radius;
+          for (let i = 0; i < count; i++) {
+            const dx = buffer.x[i] - px;
+            const dy = buffer.y[i] - py;
+            const distSq = dx * dx + dy * dy;
+            if (distSq > radiusSq) continue;
+            const proximity = 1 - Math.sqrt(distSq) / radius;
+            const bucketIndex = Math.min(steps - 1, Math.floor(proximity * steps));
+            buckets[bucketIndex].push(px, py, buffer.x[i], buffer.y[i]);
+          }
+        }
+        const lineColor = colors[0];
+        const lineRgb = `${Math.round(lineColor.r * 255)},${Math.round(lineColor.g * 255)},${Math.round(lineColor.b * 255)}`;
+        ctx.globalCompositeOperation = opts.blend ?? "source-over";
+        ctx.lineWidth = Math.max(0.1, opts.lineWidth);
+        ctx.lineCap = "round";
+        for (let b = 0; b < steps; b++) {
+          const bucket = buckets[b];
+          if (bucket.length === 0) continue;
+          const alpha = (b + 1) / steps * 0.55 * opts.intensity * lineColor.a;
+          ctx.strokeStyle = `rgba(${lineRgb},${chunkILKUL7GD_cjs.clamp(alpha, 0, 1).toFixed(3)})`;
+          ctx.beginPath();
+          for (let k = 0; k < bucket.length; k += 4) {
+            ctx.moveTo(bucket[k], bucket[k + 1]);
+            ctx.lineTo(bucket[k + 2], bucket[k + 3]);
+          }
+          ctx.stroke();
+        }
+        const colorCount = Math.max(1, colors.length);
+        for (let c = 0; c < colorCount; c++) {
+          const color = colors[c];
+          ctx.fillStyle = `rgba(${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)},${chunkILKUL7GD_cjs.clamp(color.a * opts.intensity, 0, 1)})`;
+          ctx.beginPath();
+          for (let i = 0; i < count; i++) {
+            if (buffer.colorIndex[i] % colorCount !== c) continue;
+            const twinkle = 0.75 + 0.25 * Math.sin(time * 2 + buffer.seed[i]);
+            const radius = buffer.size[i] * twinkle;
+            ctx.moveTo(buffer.x[i] + radius, buffer.y[i]);
+            ctx.arc(buffer.x[i], buffer.y[i], radius, 0, chunkILKUL7GD_cjs.TAU);
+          }
+          ctx.fill();
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        const previousSteps = opts.alphaSteps;
+        opts = {
+          ...opts,
+          ...next
+        };
+        if (opts.alphaSteps !== previousSteps) rebuildBuckets();
+      },
+      destroy() {
+        buffer.clear();
+        buckets = [];
+      }
+    };
+  }
+});
+
+// src/effects/atmosphere/meteors.ts
+var DEFAULTS5 = {
+  colors: ["#ffffff", "#a5c8ff", "#8a2be2"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 5,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "pause",
+  paused: false,
+  pauseOffscreen: true,
+  count: 12,
+  angle: 135,
+  angleVariance: 8,
+  velocity: 420,
+  velocityVariance: 0.45,
+  trailLength: 160,
+  thickness: 2,
+  head: true
+};
+var MAX_METEORS = 200;
+var meteors = defineEffect({
+  name: "meteors",
+  defaults: DEFAULTS5,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(MAX_METEORS, Math.max(1, Math.floor(opts.count * 2)));
+    const buffer = new ParticleBuffer(capacity);
+    let nextSpawn = 0;
+    function sampleGap(rate) {
+      const u = Math.max(1e-6, context.rng.next());
+      return -Math.log(u) / Math.max(1e-3, rate);
+    }
+    function spawn() {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const index = buffer.spawn();
+      if (index < 0) return;
+      const angle = chunkILKUL7GD_cjs.radians(opts.angle + rng.range(-opts.angleVariance, opts.angleVariance));
+      const dirX = Math.cos(angle);
+      const dirY = Math.sin(angle);
+      const velocity = opts.velocity * (1 + rng.range(-1, 1) * chunkILKUL7GD_cjs.clamp(opts.velocityVariance, 0, 1));
+      const margin = 48;
+      const spread = rng.next();
+      let x;
+      let y;
+      if (Math.abs(dirY) > Math.abs(dirX)) {
+        x = spread * (width + margin * 2) - margin;
+        y = dirY > 0 ? -margin : height + margin;
+      } else {
+        x = dirX > 0 ? -margin : width + margin;
+        y = spread * (height + margin * 2) - margin;
+      }
+      buffer.x[index] = x;
+      buffer.y[index] = y;
+      buffer.vx[index] = dirX * velocity;
+      buffer.vy[index] = dirY * velocity;
+      buffer.size[index] = opts.thickness * rng.range(0.6, 1.5);
+      buffer.colorIndex[index] = rng.int(0, Math.max(0, context.colors.length - 1));
+      buffer.extra[index] = opts.trailLength * rng.range(0.6, 1.35);
+      const travelDistance = Math.hypot(width, height) + margin * 2 + buffer.extra[index];
+      buffer.maxLife[index] = travelDistance / Math.max(1, velocity);
+      buffer.life[index] = buffer.maxLife[index];
+    }
+    return {
+      frame({ delta, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        surface.clear();
+        const targetConcurrent = Math.max(
+          1,
+          Math.floor(opts.count * (opts.performance === "high" ? 1 : chunkILKUL7GD_cjs.clamp(quality, 0.3, 1)))
+        );
+        nextSpawn -= delta;
+        const averageLife = Math.hypot(width, height) / Math.max(1, opts.velocity);
+        const rate = targetConcurrent / Math.max(0.1, averageLife);
+        let spawnsThisFrame = 0;
+        while (nextSpawn <= 0 && spawnsThisFrame < 8) {
+          if (buffer.count < targetConcurrent * 2) spawn();
+          nextSpawn += sampleGap(rate);
+          spawnsThisFrame++;
+        }
+        integrate(buffer, delta, 0);
+        ageAndCull(buffer, delta);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        ctx.lineCap = "round";
+        const count = buffer.count;
+        const colorCount = Math.max(1, colors.length);
+        for (let i = 0; i < count; i++) {
+          const age = buffer.age(i);
+          const fade = age < 0.15 ? age / 0.15 : age > 0.65 ? 1 - (age - 0.65) / 0.35 : 1;
+          const alpha = chunkILKUL7GD_cjs.clamp(fade * opts.intensity, 0, 1);
+          if (alpha <= 0.01) continue;
+          const color = colors[buffer.colorIndex[i] % colorCount];
+          const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+          const headX = buffer.x[i];
+          const headY = buffer.y[i];
+          const speed = Math.hypot(buffer.vx[i], buffer.vy[i]);
+          if (speed < 1e-3) continue;
+          const trail = buffer.extra[i];
+          const tailX = headX - buffer.vx[i] / speed * trail;
+          const tailY = headY - buffer.vy[i] / speed * trail;
+          const gradient = ctx.createLinearGradient(headX, headY, tailX, tailY);
+          gradient.addColorStop(0, `rgba(${rgb},${alpha})`);
+          gradient.addColorStop(0.25, `rgba(${rgb},${alpha * 0.45})`);
+          gradient.addColorStop(1, `rgba(${rgb},0)`);
+          ctx.strokeStyle = gradient;
+          ctx.lineWidth = buffer.size[i];
+          ctx.beginPath();
+          ctx.moveTo(headX, headY);
+          ctx.lineTo(tailX, tailY);
+          ctx.stroke();
+          if (opts.head) {
+            const coreRadius = buffer.size[i] * 1.8;
+            const core = ctx.createRadialGradient(headX, headY, 0, headX, headY, coreRadius);
+            core.addColorStop(0, `rgba(255,255,255,${alpha})`);
+            core.addColorStop(0.5, `rgba(${rgb},${alpha * 0.7})`);
+            core.addColorStop(1, `rgba(${rgb},0)`);
+            ctx.fillStyle = core;
+            ctx.fillRect(headX - coreRadius, headY - coreRadius, coreRadius * 2, coreRadius * 2);
+          }
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+      },
+      destroy() {
+        buffer.clear();
+      }
+    };
+  }
+});
+
+// src/effects/atmosphere/precipitation.ts
+var RAIN_DEFAULTS = {
+  colors: ["#9fc4ff", "#dbe9ff"],
+  speed: 1,
+  intensity: 1,
+  opacity: 0.7,
+  blur: 0,
+  blend: "source-over",
+  seed: 17,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "pause",
+  paused: false,
+  pauseOffscreen: true,
+  count: 320,
+  angle: 96,
+  wind: 0,
+  velocity: 900,
+  depthRange: [1, 0.35],
+  length: 18,
+  thickness: 1.2,
+  splash: false
+};
+var rain = defineEffect({
+  name: "rain",
+  defaults: RAIN_DEFAULTS,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(2e3, Math.max(1, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    let seeded = false;
+    const splashes = [];
+    function seedOne(index, initial) {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const [near, far] = opts.depthRange;
+      const depth = rng.range(Math.min(near, far), Math.max(near, far));
+      buffer.seed[index] = depth;
+      buffer.size[index] = opts.thickness * depth;
+      buffer.extra[index] = opts.length * depth;
+      buffer.colorIndex[index] = rng.int(0, Math.max(0, context.colors.length - 1));
+      buffer.life[index] = Infinity;
+      buffer.maxLife[index] = Infinity;
+      buffer.x[index] = rng.range(-width * 0.2, width * 1.2);
+      buffer.y[index] = initial ? rng.range(-height, height) : rng.range(-height * 0.3, -10);
+    }
+    function seed() {
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        seedOne(index, true);
+      }
+      seeded = true;
+    }
+    return {
+      frame({ delta, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (!seeded || buffer.count === 0 && width > 1) seed();
+        const target = Math.max(
+          8,
+          Math.floor(capacity * (opts.performance === "high" ? 1 : quality))
+        );
+        if (buffer.count > target) buffer.truncate(target);
+        surface.clear();
+        const angle = chunkILKUL7GD_cjs.radians(opts.angle + opts.wind);
+        const dirX = Math.cos(angle);
+        const dirY = Math.sin(angle);
+        const baseVelocity = opts.velocity * opts.intensity;
+        const count = buffer.count;
+        ctx.globalCompositeOperation = opts.blend ?? "source-over";
+        ctx.lineCap = "butt";
+        const colorCount = Math.max(1, colors.length);
+        for (let i = 0; i < count; i++) {
+          const depth = buffer.seed[i];
+          const velocity = baseVelocity * depth;
+          buffer.x[i] += dirX * velocity * delta;
+          buffer.y[i] += dirY * velocity * delta;
+          const trailLength = buffer.extra[i];
+          if (buffer.y[i] - trailLength > height) {
+            if (opts.splash && splashes.length < 24) {
+              splashes.push({ x: buffer.x[i], y: height - 1, age: 0 });
+            }
+            seedOne(i, false);
+            continue;
+          }
+          if (buffer.x[i] < -width * 0.25 || buffer.x[i] > width * 1.25) {
+            seedOne(i, false);
+            continue;
+          }
+          const color = colors[buffer.colorIndex[i] % colorCount];
+          ctx.strokeStyle = `rgba(${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)},${chunkILKUL7GD_cjs.clamp(color.a * depth, 0, 1).toFixed(3)})`;
+          ctx.lineWidth = buffer.size[i];
+          ctx.beginPath();
+          ctx.moveTo(buffer.x[i], buffer.y[i]);
+          ctx.lineTo(buffer.x[i] - dirX * trailLength, buffer.y[i] - dirY * trailLength);
+          ctx.stroke();
+        }
+        if (opts.splash && splashes.length > 0) {
+          const SPLASH_DURATION = 0.45;
+          const color = colors[0];
+          const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+          for (let s = splashes.length - 1; s >= 0; s--) {
+            const splash = splashes[s];
+            splash.age += delta;
+            if (splash.age >= SPLASH_DURATION) {
+              splashes.splice(s, 1);
+              continue;
+            }
+            const t = splash.age / SPLASH_DURATION;
+            const radius = 2 + t * 14;
+            ctx.strokeStyle = `rgba(${rgb},${(1 - t) * 0.4})`;
+            ctx.lineWidth = 1;
+            ctx.beginPath();
+            ctx.ellipse(splash.x, splash.y, radius, radius * 0.35, 0, 0, chunkILKUL7GD_cjs.TAU);
+            ctx.stroke();
+          }
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+      },
+      destroy() {
+        buffer.clear();
+        splashes.length = 0;
+      }
+    };
+  }
+});
+var SNOW_DEFAULTS = {
+  colors: ["#ffffff", "#e8f1ff"],
+  speed: 1,
+  intensity: 1,
+  opacity: 0.9,
+  blur: 0,
+  blend: "source-over",
+  seed: 23,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "pause",
+  paused: false,
+  pauseOffscreen: true,
+  count: 220,
+  angle: 92,
+  wind: 0,
+  velocity: 70,
+  depthRange: [1, 0.3],
+  size: 2.6,
+  sway: 28,
+  swaySpeed: 0.35,
+  soft: true
+};
+var snow = defineEffect({
+  name: "snow",
+  defaults: SNOW_DEFAULTS,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(1500, Math.max(1, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    let seeded = false;
+    let order = [];
+    function seedOne(index, initial) {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const [near, far] = opts.depthRange;
+      const depth = rng.range(Math.min(near, far), Math.max(near, far));
+      buffer.seed[index] = depth;
+      buffer.size[index] = opts.size * depth;
+      buffer.extra[index] = rng.range(0, chunkILKUL7GD_cjs.TAU);
+      buffer.colorIndex[index] = rng.int(0, Math.max(0, context.colors.length - 1));
+      buffer.life[index] = Infinity;
+      buffer.maxLife[index] = Infinity;
+      buffer.vx[index] = rng.range(0.6, 1.5);
+      buffer.x[index] = rng.range(-width * 0.15, width * 1.15);
+      buffer.y[index] = initial ? rng.range(-height, height) : rng.range(-height * 0.25, -8);
+    }
+    function seed() {
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        seedOne(index, true);
+      }
+      order = Array.from({ length: buffer.count }, (_, i) => i).sort(
+        (a, b) => buffer.seed[a] - buffer.seed[b]
+      );
+      seeded = true;
+    }
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, surface, colors } = context;
+        const { width, height } = size;
+        if (!seeded || buffer.count === 0 && width > 1) seed();
+        const target = Math.max(
+          8,
+          Math.floor(capacity * (opts.performance === "high" ? 1 : quality))
+        );
+        if (buffer.count > target) {
+          buffer.truncate(target);
+          order = order.filter((i) => i < buffer.count);
+        }
+        surface.clear();
+        const angle = chunkILKUL7GD_cjs.radians(opts.angle + opts.wind);
+        const dirX = Math.cos(angle);
+        const dirY = Math.sin(angle);
+        const baseVelocity = opts.velocity * opts.intensity;
+        const sway = opts.sway;
+        const swaySpeed = opts.swaySpeed;
+        ctx.globalCompositeOperation = opts.blend ?? "source-over";
+        const colorCount = Math.max(1, colors.length);
+        for (const i of order) {
+          if (i >= buffer.count) continue;
+          const depth = buffer.seed[i];
+          const velocity = baseVelocity * depth;
+          buffer.y[i] += dirY * velocity * delta;
+          const swayPhase = time * swaySpeed * chunkILKUL7GD_cjs.TAU * buffer.vx[i] + buffer.extra[i];
+          buffer.x[i] += (dirX * velocity + Math.cos(swayPhase) * sway * depth) * delta;
+          const radius = buffer.size[i];
+          if (buffer.y[i] - radius > height) {
+            seedOne(i, false);
+            continue;
+          }
+          if (buffer.x[i] < -width * 0.2 || buffer.x[i] > width * 1.2) {
+            seedOne(i, false);
+            continue;
+          }
+          const color = colors[buffer.colorIndex[i] % colorCount];
+          const alpha = chunkILKUL7GD_cjs.clamp(color.a * depth, 0, 1);
+          const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+          if (opts.soft) {
+            const gradient = ctx.createRadialGradient(
+              buffer.x[i],
+              buffer.y[i],
+              0,
+              buffer.x[i],
+              buffer.y[i],
+              radius * 2
+            );
+            gradient.addColorStop(0, `rgba(${rgb},${alpha})`);
+            gradient.addColorStop(0.5, `rgba(${rgb},${alpha * 0.5})`);
+            gradient.addColorStop(1, `rgba(${rgb},0)`);
+            ctx.fillStyle = gradient;
+            ctx.fillRect(buffer.x[i] - radius * 2, buffer.y[i] - radius * 2, radius * 4, radius * 4);
+          } else {
+            ctx.fillStyle = `rgba(${rgb},${alpha})`;
+            ctx.beginPath();
+            ctx.arc(buffer.x[i], buffer.y[i], radius, 0, chunkILKUL7GD_cjs.TAU);
+            ctx.fill();
+          }
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+      },
+      destroy() {
+        buffer.clear();
+        order = [];
+      }
+    };
+  }
+});
+
+// src/effects/atmosphere/fireflies.ts
+var DEFAULTS6 = {
+  colors: ["#ffe98a", "#c8ff8a", "#8affd4"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 29,
+  interactive: true,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "slow",
+  paused: false,
+  pauseOffscreen: true,
+  count: 40,
+  size: 5,
+  wanderSpeed: 22,
+  turbulence: 0.35,
+  pulseRate: 0.5,
+  baseGlow: 0.12,
+  pointerRadius: 120
+};
+var fireflies = defineEffect({
+  name: "fireflies",
+  defaults: DEFAULTS6,
+  structuralOptions: ["count"],
+  setup(context, options) {
+    let opts = options;
+    const capacity = Math.min(400, Math.max(1, Math.floor(opts.count)));
+    const buffer = new ParticleBuffer(capacity);
+    const gradients = new GradientCache(48);
+    const heading = context.noise.fbm2D({ octaves: 2, gain: 0.5 });
+    let seeded = false;
+    function seed() {
+      const { width, height } = context.size;
+      const rng = context.rng;
+      const colorCount = Math.max(1, context.colors.length);
+      buffer.clear();
+      for (let i = 0; i < capacity; i++) {
+        const index = buffer.spawn();
+        if (index < 0) break;
+        buffer.x[index] = rng.next() * width;
+        buffer.y[index] = rng.next() * height;
+        buffer.size[index] = opts.size * rng.range(0.6, 1.5);
+        buffer.colorIndex[index] = rng.int(0, colorCount - 1);
+        buffer.life[index] = Infinity;
+        buffer.maxLife[index] = Infinity;
+        buffer.seed[index] = rng.range(0, chunkILKUL7GD_cjs.TAU);
+        buffer.extra[index] = rng.range(0.6, 1.6);
+        buffer.vx[index] = rng.range(0, 1e3);
+        buffer.vy[index] = rng.range(0, 1e3);
+      }
+      seeded = true;
+    }
+    return {
+      frame({ time, delta, quality }) {
+        const { ctx, size, pointer, surface, colors } = context;
+        const { width, height } = size;
+        if (!seeded || buffer.count === 0 && width > 1) seed();
+        const target = Math.max(
+          4,
+          Math.floor(capacity * (opts.performance === "high" ? 1 : quality))
+        );
+        if (buffer.count > target) buffer.truncate(target);
+        surface.clear();
+        const wanderSpeed = opts.wanderSpeed * opts.intensity;
+        const turbulence = opts.turbulence;
+        const baseGlow = chunkILKUL7GD_cjs.clamp(opts.baseGlow, 0, 1);
+        const pulseRate = opts.pulseRate;
+        const count = buffer.count;
+        const interactive = opts.interactive !== false && pointer !== null && pointer.everInside;
+        const px = interactive ? pointer.smoothX : 0;
+        const py = interactive ? pointer.smoothY : 0;
+        const scatterRadius = Math.max(1, opts.pointerRadius);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        const colorCount = Math.max(1, colors.length);
+        for (let i = 0; i < count; i++) {
+          const n = heading(buffer.vx[i] * 0.01, buffer.vy[i] * 0.01 + time * turbulence);
+          const angle = n * chunkILKUL7GD_cjs.TAU * 2;
+          let dx = Math.cos(angle) * wanderSpeed;
+          let dy = Math.sin(angle) * wanderSpeed;
+          if (interactive) {
+            const ox = buffer.x[i] - px;
+            const oy = buffer.y[i] - py;
+            const distance = Math.hypot(ox, oy);
+            if (distance < scatterRadius && distance > 1e-3) {
+              const falloff = 1 - distance / scatterRadius;
+              const push = falloff * falloff * falloff * wanderSpeed * 6;
+              dx += ox / distance * push;
+              dy += oy / distance * push;
+            }
+          }
+          buffer.x[i] += dx * delta;
+          buffer.y[i] += dy * delta;
+          const margin = buffer.size[i] * 3;
+          if (buffer.x[i] < margin) buffer.x[i] += (margin - buffer.x[i]) * 0.08;
+          else if (buffer.x[i] > width - margin)
+            buffer.x[i] -= (buffer.x[i] - (width - margin)) * 0.08;
+          if (buffer.y[i] < margin) buffer.y[i] += (margin - buffer.y[i]) * 0.08;
+          else if (buffer.y[i] > height - margin)
+            buffer.y[i] -= (buffer.y[i] - (height - margin)) * 0.08;
+          const raw = (Math.sin(time * pulseRate * chunkILKUL7GD_cjs.TAU * buffer.extra[i] + buffer.seed[i]) + 1) / 2;
+          const pulse = baseGlow + (1 - baseGlow) * raw ** 2.6;
+          const color = colors[buffer.colorIndex[i] % colorCount];
+          drawGlow(
+            ctx,
+            buffer.x[i],
+            buffer.y[i],
+            buffer.size[i] * 3.2,
+            color,
+            chunkILKUL7GD_cjs.clamp(pulse * opts.intensity, 0, 1),
+            gradients
+          );
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      resize() {
+        seeded = false;
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        gradients.clear();
+      },
+      destroy() {
+        buffer.clear();
+        gradients.clear();
+      }
+    };
+  }
+});
+
+// src/effects/surfaces/waves.ts
+var DEFAULTS7 = {
+  colors: "abyss",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  blend: "source-over",
+  seed: 31,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  layers: 4,
+  samples: 28,
+  amplitude: 40,
+  wavelength: 0.6,
+  position: 0.68,
+  roughness: 0.35,
+  filled: true,
+  lineWidth: 0
+};
+var waves = defineEffect({
+  name: "waves",
+  defaults: DEFAULTS7,
+  structuralOptions: ["layers"],
+  setup(context, options) {
+    let opts = options;
+    let layers = [];
+    const profile = context.noise.fbm2D({ octaves: 3, gain: 0.5 });
+    let crest = [];
+    function build() {
+      const count = Math.max(1, Math.floor(opts.layers));
+      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const rng = context.rng;
+      layers = [];
+      for (let i = 0; i < count; i++) {
+        const t = count === 1 ? 1 : i / (count - 1);
+        layers.push({
+          color: palette[i],
+          f1: rng.range(0.8, 1.2),
+          f2: rng.range(1.7, 2.4),
+          f3: rng.range(3.1, 4.3),
+          phase: rng.range(0, chunkILKUL7GD_cjs.TAU),
+          speed: rng.range(0.5, 1.1),
+          // Back layers are taller: they need to show above the front ones to read as distance.
+          amplitude: chunkILKUL7GD_cjs.lerp(1.35, 0.7, t),
+          offset: chunkILKUL7GD_cjs.lerp(-0.1, 0.06, t),
+          alpha: chunkILKUL7GD_cjs.lerp(0.5, 0.95, t),
+          noiseOffset: rng.range(0, 100)
+        });
+      }
+    }
+    function ensureCrest(sampleCount) {
+      if (crest.length === sampleCount + 1) return;
+      crest = Array.from({ length: sampleCount + 1 }, () => ({ x: 0, y: 0 }));
+    }
+    build();
+    return {
+      frame({ time }) {
+        const { ctx, size, surface } = context;
+        const { width, height } = size;
+        surface.clear();
+        const sampleCount = Math.max(4, Math.floor(opts.samples));
+        ensureCrest(sampleCount);
+        const amplitude = opts.amplitude * opts.intensity;
+        const baseY = height * chunkILKUL7GD_cjs.clamp(opts.position, 0, 1);
+        const wavelength = Math.max(0.05, opts.wavelength);
+        const roughness = chunkILKUL7GD_cjs.clamp(opts.roughness, 0, 1);
+        ctx.globalCompositeOperation = opts.blend ?? "source-over";
+        for (const layer of layers) {
+          const t = time * layer.speed;
+          const layerAmplitude = amplitude * layer.amplitude;
+          const layerY = baseY + height * layer.offset;
+          for (let s = 0; s <= sampleCount; s++) {
+            const u = s / sampleCount;
+            const p = u / wavelength * chunkILKUL7GD_cjs.TAU + layer.phase;
+            const sines = Math.sin(p * layer.f1 + t * 0.9) * 0.5 + Math.sin(p * layer.f2 - t * 0.6) * 0.32 + Math.sin(p * layer.f3 + t * 1.4) * 0.18;
+            const noise = roughness > 0 ? profile(u * 3 + layer.noiseOffset, t * 0.25) : 0;
+            const y = layerY + (sines * (1 - roughness) + noise * roughness) * layerAmplitude;
+            crest[s].x = u * width;
+            crest[s].y = y;
+          }
+          const rgb = `${Math.round(layer.color.r * 255)},${Math.round(layer.color.g * 255)},${Math.round(layer.color.b * 255)}`;
+          if (opts.filled) {
+            ctx.beginPath();
+            traceOpenSpline(ctx, crest, 0.5);
+            ctx.lineTo(width, height + layerAmplitude * 2);
+            ctx.lineTo(0, height + layerAmplitude * 2);
+            ctx.closePath();
+            const gradient = ctx.createLinearGradient(0, layerY - layerAmplitude, 0, height);
+            gradient.addColorStop(0, `rgba(${rgb},${chunkILKUL7GD_cjs.clamp(layer.alpha, 0, 1)})`);
+            gradient.addColorStop(1, `rgba(${rgb},${chunkILKUL7GD_cjs.clamp(layer.alpha * 0.82, 0, 1)})`);
+            ctx.fillStyle = gradient;
+            ctx.fill();
+          }
+          if (opts.lineWidth > 0) {
+            ctx.beginPath();
+            traceOpenSpline(ctx, crest, 0.5);
+            ctx.strokeStyle = `rgba(255,255,255,${chunkILKUL7GD_cjs.clamp(layer.alpha * 0.25, 0, 1)})`;
+            ctx.lineWidth = opts.lineWidth;
+            ctx.stroke();
+          }
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        if ("colors" in next) build();
+      },
+      destroy() {
+        layers = [];
+        crest = [];
+      }
+    };
+  }
+});
+
+// src/effects/surfaces/blob.ts
+var DEFAULTS8 = {
+  colors: "ansh",
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 30,
+  blend: "lighter",
+  seed: 37,
+  interactive: true,
+  resolution: 0.6,
+  performance: "auto",
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  count: 3,
+  segments: 48,
+  radius: 0.32,
+  distortion: 0.35,
+  detail: 1.6,
+  morphSpeed: 0.4,
+  drift: 0.1,
+  outline: false,
+  lineWidth: 2,
+  pointerInfluence: 0.25
+};
+var blob = defineEffect({
+  name: "blob",
+  defaults: DEFAULTS8,
+  structuralOptions: ["count", "segments"],
+  setup(context, options) {
+    let opts = options;
+    let blobs = [];
+    const field = context.noise.fbm3D({ octaves: 3, gain: 0.5 });
+    let ring = [];
+    function build() {
+      const count = Math.max(1, Math.floor(opts.count));
+      const palette = chunk23GSSIMK_cjs.expandPalette(context.colors, count);
+      const rng = context.rng;
+      blobs = [];
+      for (let i = 0; i < count; i++) {
+        const angle = i / count * chunkILKUL7GD_cjs.TAU + rng.range(-0.5, 0.5);
+        const distance = rng.range(0.1, 0.3);
+        blobs.push({
+          color: palette[i],
+          homeX: 0.5 + Math.cos(angle) * distance,
+          homeY: 0.5 + Math.sin(angle) * distance,
+          radiusScale: rng.range(0.7, 1.25),
+          noiseOffset: rng.range(0, 60),
+          driftFreqX: rng.range(0.07, 0.16),
+          driftFreqY: rng.range(0.08, 0.18),
+          phase: rng.range(0, chunkILKUL7GD_cjs.TAU),
+          alpha: chunkILKUL7GD_cjs.lerp(0.85, 0.5, count === 1 ? 0 : i / (count - 1))
+        });
+      }
+    }
+    function ensureRing(pointCount) {
+      if (ring.length === pointCount) return;
+      ring = Array.from({ length: pointCount }, () => ({ x: 0, y: 0 }));
+    }
+    build();
+    return {
+      frame({ time }) {
+        const { ctx, size, pointer, surface } = context;
+        const { width, height } = size;
+        surface.clear();
+        const pointCount = Math.max(8, Math.floor(opts.segments));
+        ensureRing(pointCount);
+        const minDimension = Math.min(width, height);
+        const baseRadius = minDimension * chunkILKUL7GD_cjs.clamp(opts.radius, 0.02, 1);
+        const distortion = chunkILKUL7GD_cjs.clamp(opts.distortion, 0, 1) * opts.intensity;
+        const detail = Math.max(0.1, opts.detail);
+        const morph = time * opts.morphSpeed;
+        const drift = opts.drift;
+        const interactive = opts.interactive !== false && pointer !== null && pointer.everInside;
+        const pointerX = interactive ? pointer.smoothNx : 0.5;
+        const pointerY = interactive ? pointer.smoothNy : 0.5;
+        const pull = interactive ? chunkILKUL7GD_cjs.clamp(opts.pointerInfluence, 0, 1) : 0;
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        for (const b of blobs) {
+          let nx = b.homeX + Math.sin(time * b.driftFreqX + b.phase) * drift;
+          let ny = b.homeY + Math.cos(time * b.driftFreqY + b.phase * 1.4) * drift;
+          if (pull > 0) {
+            nx += (pointerX - nx) * pull * 0.5;
+            ny += (pointerY - ny) * pull * 0.5;
+          }
+          const cx = nx * width;
+          const cy = ny * height;
+          const radius = baseRadius * b.radiusScale;
+          for (let i = 0; i < pointCount; i++) {
+            const angle = i / pointCount * chunkILKUL7GD_cjs.TAU;
+            const sampleX = Math.cos(angle) * detail + b.noiseOffset;
+            const sampleY = Math.sin(angle) * detail + b.noiseOffset;
+            const n = field(sampleX, sampleY, morph);
+            const r = radius * (1 + n * distortion);
+            ring[i].x = cx + Math.cos(angle) * r;
+            ring[i].y = cy + Math.sin(angle) * r;
+          }
+          ctx.beginPath();
+          traceClosedSpline(ctx, ring, 0.5);
+          const rgb = `${Math.round(b.color.r * 255)},${Math.round(b.color.g * 255)},${Math.round(b.color.b * 255)}`;
+          if (opts.outline) {
+            ctx.strokeStyle = `rgba(${rgb},${chunkILKUL7GD_cjs.clamp(b.alpha * b.color.a, 0, 1)})`;
+            ctx.lineWidth = opts.lineWidth;
+            ctx.stroke();
+          } else {
+            const gradient = ctx.createRadialGradient(cx, cy, 0, cx, cy, radius * 1.4);
+            const peak = chunkILKUL7GD_cjs.clamp(b.alpha * b.color.a * opts.intensity, 0, 1);
+            gradient.addColorStop(0, `rgba(${rgb},${peak})`);
+            gradient.addColorStop(0.55, `rgba(${rgb},${peak * 0.72})`);
+            gradient.addColorStop(1, `rgba(${rgb},${peak * 0.25})`);
+            ctx.fillStyle = gradient;
+            ctx.fill();
+          }
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        if ("colors" in next) build();
+      },
+      destroy() {
+        blobs = [];
+        ring = [];
+      }
+    };
+  }
+});
+
+// src/effects/overlays/noise-layer.ts
+var DEFAULTS9 = {
+  colors: ["#ffffff"],
+  speed: 1,
+  intensity: 1,
+  opacity: 1,
+  blur: 0,
+  // `overlay` preserves the underlying luminance while adding texture, which is what grain
+  // should do. `source-over` would just wash the image out with grey.
+  blend: "overlay",
+  seed: 41,
+  interactive: false,
+  resolution: 1,
+  performance: "auto",
+  // Grain has no directional motion, so it causes no vestibular discomfort. But flickering can
+  // trigger photosensitivity, so under reduced motion we hold a single static tile.
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  amount: 0.08,
+  tileSize: 160,
+  frames: 4,
+  frameRate: 12,
+  grainSize: 1,
+  monochrome: true
+};
+var noiseLayer = defineEffect({
+  name: "noise-layer",
+  defaults: DEFAULTS9,
+  structuralOptions: ["tileSize", "frames", "grainSize", "monochrome"],
+  setup(context, options) {
+    let opts = options;
+    let tiles = [];
+    let patterns = [];
+    function buildTiles() {
+      disposeTiles();
+      const size = Math.max(16, Math.floor(opts.tileSize));
+      const frameCount = Math.max(1, Math.min(12, Math.floor(opts.frames)));
+      const grain = Math.max(1, Math.floor(opts.grainSize));
+      const rng = context.rng.fork();
+      const monochrome = opts.monochrome;
+      const generated = Math.max(8, Math.floor(size / grain));
+      for (let f = 0; f < frameCount; f++) {
+        const tile = document.createElement("canvas");
+        tile.width = generated;
+        tile.height = generated;
+        const tileCtx = tile.getContext("2d");
+        if (!tileCtx) continue;
+        const image = tileCtx.createImageData(generated, generated);
+        const data = image.data;
+        for (let i = 0; i < data.length; i += 4) {
+          if (monochrome) {
+            const value = rng.next() * 255;
+            data[i] = value;
+            data[i + 1] = value;
+            data[i + 2] = value;
+          } else {
+            data[i] = rng.next() * 255;
+            data[i + 1] = rng.next() * 255;
+            data[i + 2] = rng.next() * 255;
+          }
+          data[i + 3] = 255;
+        }
+        tileCtx.putImageData(image, 0, 0);
+        tiles.push(tile);
+      }
+      patterns = new Array(tiles.length).fill(null);
+    }
+    function disposeTiles() {
+      for (const tile of tiles) {
+        tile.width = 1;
+        tile.height = 1;
+      }
+      tiles = [];
+      patterns = [];
+    }
+    buildTiles();
+    return {
+      frame({ time }) {
+        const { ctx, size, surface } = context;
+        const { width, height } = size;
+        surface.clear();
+        const amount = chunkILKUL7GD_cjs.clamp(opts.amount * opts.intensity, 0, 1);
+        if (amount <= 1e-3 || tiles.length === 0) return;
+        const index = opts.frameRate > 0 ? Math.floor(time * opts.frameRate) % tiles.length : 0;
+        let pattern = patterns[index];
+        if (!pattern) {
+          pattern = ctx.createPattern(tiles[index], "repeat");
+          patterns[index] = pattern;
+        }
+        if (!pattern) return;
+        ctx.save();
+        ctx.globalCompositeOperation = opts.blend ?? "overlay";
+        ctx.globalAlpha = amount;
+        const grain = Math.max(1, Math.floor(opts.grainSize));
+        if (grain > 1) {
+          ctx.scale(grain, grain);
+        }
+        if (opts.frameRate > 0) {
+          const jitterX = index * 37 % Math.max(1, Math.floor(opts.tileSize));
+          const jitterY = index * 53 % Math.max(1, Math.floor(opts.tileSize));
+          ctx.translate(-jitterX, -jitterY);
+        }
+        ctx.fillStyle = pattern;
+        const overdraw = Math.max(1, Math.floor(opts.tileSize));
+        ctx.fillRect(0, 0, width / grain + overdraw, height / grain + overdraw);
+        ctx.restore();
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+      },
+      destroy() {
+        disposeTiles();
+      }
+    };
+  }
+});
+
+// src/effects/overlays/spotlight.ts
+var DEFAULTS10 = {
+  colors: ["#ffffff"],
+  speed: 1,
+  intensity: 0.35,
+  opacity: 1,
+  blur: 0,
+  blend: "lighter",
+  seed: 43,
+  interactive: true,
+  // The output is one enormous soft gradient. Even quarter resolution is more than enough.
+  resolution: 0.35,
+  performance: "auto",
+  // The light only moves in response to the user's own pointer, which is not the kind of
+  // autonomous motion reduced-motion is protecting against. A static centred light is the
+  // sensible fallback.
+  reducedMotion: "static",
+  paused: false,
+  pauseOffscreen: true,
+  radius: 320,
+  falloff: 1.6,
+  fade: 0.35,
+  ambient: false,
+  ambientDrift: 0.25,
+  core: true
+};
+var spotlight = defineEffect({
+  name: "spotlight",
+  defaults: DEFAULTS10,
+  setup(context, options) {
+    let opts = options;
+    let presence = opts.ambient ? 1 : 0;
+    const drift = { phaseX: context.rng.range(0, chunkILKUL7GD_cjs.TAU), phaseY: context.rng.range(0, chunkILKUL7GD_cjs.TAU) };
+    return {
+      frame({ time, delta }) {
+        const { ctx, size, pointer, surface, colors } = context;
+        const { width, height } = size;
+        surface.clear();
+        const interactive = opts.interactive !== false && pointer !== null;
+        const hovering = interactive && pointer.inside;
+        const fadeSeconds = Math.max(0, opts.fade);
+        const target = hovering || opts.ambient ? 1 : 0;
+        if (fadeSeconds <= 0) {
+          presence = target;
+        } else {
+          const step = delta / fadeSeconds;
+          presence = presence < target ? Math.min(target, presence + step) : Math.max(target, presence - step);
+        }
+        if (presence <= 2e-3) return;
+        let x;
+        let y;
+        if (interactive && pointer.everInside) {
+          x = pointer.smoothX;
+          y = pointer.smoothY;
+        } else {
+          const driftAmount = opts.ambientDrift;
+          x = width * (0.5 + Math.sin(time * 0.11 + drift.phaseX) * driftAmount);
+          y = height * (0.5 + Math.cos(time * 0.13 + drift.phaseY) * driftAmount);
+        }
+        const radius = Math.max(1, opts.radius);
+        const color = colors[0];
+        const rgb = `${Math.round(color.r * 255)},${Math.round(color.g * 255)},${Math.round(color.b * 255)}`;
+        const peak = chunkILKUL7GD_cjs.clamp(color.a * opts.intensity * presence, 0, 1);
+        const falloff = Math.max(0.2, opts.falloff);
+        ctx.globalCompositeOperation = opts.blend ?? "lighter";
+        const gradient = ctx.createRadialGradient(x, y, 0, x, y, radius);
+        const STOPS = 6;
+        for (let i = 0; i <= STOPS; i++) {
+          const t = i / STOPS;
+          const alpha = peak * (1 - t) ** falloff;
+          gradient.addColorStop(t, `rgba(${rgb},${alpha.toFixed(4)})`);
+        }
+        ctx.fillStyle = gradient;
+        ctx.fillRect(x - radius, y - radius, radius * 2, radius * 2);
+        if (opts.core) {
+          const coreRadius = radius * 0.32;
+          const core = ctx.createRadialGradient(x, y, 0, x, y, coreRadius);
+          core.addColorStop(0, `rgba(${rgb},${(peak * 0.75).toFixed(4)})`);
+          core.addColorStop(0.5, `rgba(${rgb},${(peak * 0.28).toFixed(4)})`);
+          core.addColorStop(1, `rgba(${rgb},0)`);
+          ctx.fillStyle = core;
+          ctx.fillRect(x - coreRadius, y - coreRadius, coreRadius * 2, coreRadius * 2);
+        }
+        ctx.globalCompositeOperation = "source-over";
+      },
+      update(next) {
+        opts = { ...opts, ...next };
+        if (opts.ambient) presence = Math.max(presence, 1e-3);
+      }
+    };
+  }
+});
+
+// src/effects/index.ts
+var effects = {
+  aurora,
+  "mesh-gradient": meshGradient,
+  "animated-gradient": animatedGradient,
+  "particle-field": particleField,
+  constellation,
+  meteors,
+  rain,
+  snow,
+  fireflies,
+  waves,
+  blob,
+  "noise-layer": noiseLayer,
+  spotlight
+};
+
+exports.GradientCache = GradientCache;
+exports.ParticleBuffer = ParticleBuffer;
+exports.SpatialGrid = SpatialGrid;
+exports.ageAndCull = ageAndCull;
+exports.animatedGradient = animatedGradient;
+exports.aurora = aurora;
+exports.blob = blob;
+exports.constellation = constellation;
+exports.createSurface = createSurface;
+exports.defineEffect = defineEffect;
+exports.drawDot = drawDot;
+exports.drawGlow = drawGlow;
+exports.effects = effects;
+exports.fireflies = fireflies;
+exports.integrate = integrate;
+exports.meshGradient = meshGradient;
+exports.meteors = meteors;
+exports.mountEffect = mountEffect;
+exports.noiseLayer = noiseLayer;
+exports.particleField = particleField;
+exports.rain = rain;
+exports.resetFilterSupport = resetFilterSupport;
+exports.snow = snow;
+exports.spotlight = spotlight;
+exports.supportsCanvasFilter = supportsCanvasFilter;
+exports.supportsOffscreenCanvas = supportsOffscreenCanvas;
+exports.supportsWorkerRendering = supportsWorkerRendering;
+exports.traceClosedSpline = traceClosedSpline;
+exports.traceOpenSpline = traceOpenSpline;
+exports.traceRoundRect = traceRoundRect;
+exports.waves = waves;
+exports.wrapBounds = wrapBounds;
+//# sourceMappingURL=chunk-R7UJ7MWP.cjs.map
+//# sourceMappingURL=chunk-R7UJ7MWP.cjs.map