@basmilius/sparkle 2.0.0 → 2.2.0

package/dist/index.d.mts

@@ -1,10 +1,214 @@
+//#region src/layer.d.ts
+type EdgeFadeSide = number | [number, number];
+type EdgeFade = {
+  readonly top?: EdgeFadeSide;
+  readonly bottom?: EdgeFadeSide;
+  readonly left?: EdgeFadeSide;
+  readonly right?: EdgeFadeSide;
+};
+/**
+* Internal interface implemented by all Effect subclasses. Used by SimulationCanvas
+* and Scene to drive rendering without depending on the generic Effect<TConfig> type.
+*/
+interface SimulationLayer {
+  fade: EdgeFade | null;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+  onResize(width: number, height: number): void;
+  onMount(canvas: HTMLCanvasElement): void;
+  onUnmount(canvas: HTMLCanvasElement): void;
+}
+//#endregion
+//#region src/effect.d.ts
+/**
+* Base class for all visual effects. Implements the internal SimulationLayer interface
+* so that effects can be used both standalone (via mount()) and composed in a Scene.
+*
+* @example Standalone usage
+* const snow = new Snow({ particles: 200 });
+* snow.mount(canvas).start();
+*
+* @example Scene composition
+* const scene = new Scene()
+*     .mount(canvas)
+*     .layer(new Aurora())
+*     .layer(new Snow())
+*     .start();
+*/
+declare abstract class Effect<TConfig = Record<string, unknown>> implements SimulationLayer {
+  #private;
+  fade: EdgeFade | null;
+  abstract tick(dt: number, width: number, height: number): void;
+  abstract draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+  configure(_config: Partial<TConfig>): void;
+  onResize(_width: number, _height: number): void;
+  onMount(_canvas: HTMLCanvasElement): void;
+  onUnmount(_canvas: HTMLCanvasElement): void;
+  /**
+  * Apply an edge fade mask when rendering this effect standalone or in a Scene.
+  */
+  withFade(fade: EdgeFade): this;
+  /**
+  * Mount this effect to a canvas element or CSS selector, creating the render loop.
+  * Must be called before start().
+  */
+  mount(canvas: HTMLCanvasElement | string, options?: CanvasRenderingContext2DSettings): this;
+  /**
+  * Remove this effect from its canvas and clean up the render loop.
+  */
+  unmount(): this;
+  /**
+  * Start the render loop. Call mount() first.
+  */
+  start(): this;
+  /**
+  * Pause rendering without destroying state. Use resume() to continue.
+  */
+  pause(): this;
+  /**
+  * Resume rendering after a pause().
+  */
+  resume(): this;
+  /**
+  * Stop rendering and call onUnmount(). Safe to call multiple times.
+  */
+  destroy(): void;
+}
+//#endregion
+//#region src/aurora/layer.d.ts
+interface AuroraConfig {
+  readonly bands?: number;
+  readonly colors?: string[];
+  readonly speed?: number;
+  readonly intensity?: number;
+  readonly waveAmplitude?: number;
+  readonly verticalPosition?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/aurora/types.d.ts
+type AuroraBand = {
+  x: number;
+  baseY: number;
+  height: number;
+  sigma: number;
+  phase1: number;
+  phase2: number;
+  amplitude1: number;
+  frequency1: number;
+  speed: number;
+  hue: number;
+  opacity: number;
+};
+//#endregion
+//#region src/aurora/index.d.ts
+declare function createAurora(config?: AuroraConfig): Effect<AuroraConfig>;
+//#endregion
+//#region src/balloons/layer.d.ts
+interface BalloonsConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly sizeRange?: [number, number];
+  readonly speed?: number;
+  readonly driftAmount?: number;
+  readonly stringLength?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/point.d.ts
+type Point = {
+  x: number;
+  y: number;
+};
+//#endregion
+//#region src/balloons/particle.d.ts
+interface BalloonParticleConfig {
+  readonly driftAmp?: number;
+  readonly driftFreq?: number;
+  readonly driftPhase?: number;
+  readonly radiusX?: number;
+  readonly radiusY?: number;
+  readonly riseSpeed?: number;
+  readonly rotationSpeed?: number;
+  readonly scale?: number;
+  readonly stringLength?: number;
+}
+declare class BalloonParticle {
+  #private;
+  get isDone(): boolean;
+  get position(): Point;
+  constructor(position: Point, color: [number, number, number], config?: BalloonParticleConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+//#endregion
+//#region src/balloons/types.d.ts
+type Balloon = {
+  x: number;
+  y: number;
+  radiusX: number;
+  radiusY: number;
+  color: [number, number, number];
+  driftPhase: number;
+  driftFreq: number;
+  driftAmp: number;
+  riseSpeed: number;
+  rotation: number;
+  rotationSpeed: number;
+  stringLength: number;
+};
+//#endregion
+//#region src/balloons/index.d.ts
+declare function createBalloons(config?: BalloonsConfig): Effect<BalloonsConfig>;
+//#endregion
+//#region src/bubbles/layer.d.ts
+interface BubblesConfig {
+  readonly count?: number;
+  readonly sizeRange?: [number, number];
+  readonly speed?: number;
+  readonly popOnClick?: boolean;
+  readonly popRadius?: number;
+  readonly colors?: string[];
+  readonly wobbleAmount?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/bubbles/types.d.ts
+type Bubble = {
+  x: number;
+  y: number;
+  radius: number;
+  speed: number;
+  hue: number;
+  wobblePhase: number;
+  wobbleFreq: number;
+  wobbleAmp: number;
+  opacity: number;
+};
+type PopParticle = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  alpha: number;
+  size: number;
+  decay: number;
+};
+//#endregion
+//#region src/bubbles/index.d.ts
+declare function createBubbles(config?: BubblesConfig): Effect<BubblesConfig>;
+//#endregion
 //#region src/canvas.d.ts
 declare class LimitedFrameRateCanvas {
   #private;
+  static get globalSpeed(): number;
+  static set globalSpeed(value: number);
   get canvas(): HTMLCanvasElement;
   get context(): CanvasRenderingContext2D;
   get delta(): number;
   get deltaFactor(): number;
+  get speed(): number;
+  set speed(value: number);
   get frameRate(): number;
   get isSmall(): boolean;
   get isTicking(): boolean;
@@ -15,6 +219,8 @@ declare class LimitedFrameRateCanvas {
   loop(): void;
   start(): void;
   stop(): void;
+  pause(): void;
+  resume(): void;
   draw(): void;
   tick(): void;
   destroy(): void;
@@ -22,12 +228,21 @@ declare class LimitedFrameRateCanvas {
   onVisibilityChange(): void;
 }
 //#endregion
+//#region src/color.d.ts
+declare function parseColor(fillStyle: string): {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+//#endregion
 //#region src/confetti/types.d.ts
 type Config = {
   readonly angle: number;
   readonly colors: string[];
   readonly decay: number;
   readonly gravity: number;
+  readonly palette: Palette;
   readonly particles: number;
   readonly shapes: Shape[];
   readonly spread: number;
@@ -36,63 +251,873 @@ type Config = {
   readonly x: number;
   readonly y: number;
 };
-type Shape = "circle" | "diamond" | "ribbon" | "square" | "star" | "triangle";
+type Palette = "classic" | "pastel" | "vibrant" | "warm";
+type Shape = "bowtie" | "circle" | "crescent" | "diamond" | "heart" | "hexagon" | "ribbon" | "ring" | "square" | "star" | "triangle";
 //#endregion
-//#region src/confetti/simulation.d.ts
-interface ConfettiSimulationConfig {
+//#region src/confetti/layer.d.ts
+interface ConfettiConfig {
   readonly scale?: number;
-  readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
-declare class ConfettiSimulation extends LimitedFrameRateCanvas {
+//#endregion
+//#region src/confetti/particle.d.ts
+interface ConfettiParticleConfig {
+  readonly decay?: number;
+  readonly gravity?: number;
+  readonly scale?: number;
+  readonly spread?: number;
+  readonly startVelocity?: number;
+  readonly ticks?: number;
+}
+declare class ConfettiParticle {
   #private;
-  constructor(canvas: HTMLCanvasElement, config?: ConfettiSimulationConfig);
-  fire(config: Partial<Config>): void;
-  draw(): void;
-  tick(): void;
-  onResize(): void;
+  get isDead(): boolean;
+  get position(): Point;
+  constructor(position: Point, direction: number, shape: Shape, color: string, config?: ConfettiParticleConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
 }
 //#endregion
-//#region src/point.d.ts
-type Point = {
+//#region src/confetti/consts.d.ts
+declare const PALETTES: Record<Palette, string[]>;
+//#endregion
+//#region src/confetti/shapes.d.ts
+declare const SHAPE_PATHS: Record<Shape, Path2D>;
+//#endregion
+//#region src/confetti/index.d.ts
+interface ConfettiInstance extends Effect<ConfettiConfig> {
+  burst(config: Partial<Config>): void;
+}
+declare function createConfetti(config?: ConfettiConfig): ConfettiInstance;
+//#endregion
+//#region src/donuts/layer.d.ts
+interface DonutsConfig {
+  readonly background?: string;
+  readonly collisionPadding?: number;
+  readonly colors?: string[];
+  readonly count?: number;
+  readonly mouseAvoidance?: boolean;
+  readonly mouseAvoidanceRadius?: number;
+  readonly mouseAvoidanceStrength?: number;
+  readonly radiusRange?: [number, number];
+  readonly repulsionStrength?: number;
+  readonly rotationSpeedRange?: [number, number];
+  readonly scale?: number;
+  readonly speedRange?: [number, number];
+  readonly thickness?: number;
+}
+//#endregion
+//#region src/donuts/index.d.ts
+declare function createDonuts(config?: DonutsConfig): Effect<DonutsConfig>;
+//#endregion
+//#region src/fireflies/layer.d.ts
+interface FirefliesConfig {
+  readonly count?: number;
+  readonly color?: string;
+  readonly size?: number;
+  readonly speed?: number;
+  readonly glowSpeed?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/fireflies/particle.d.ts
+interface FireflyParticleConfig {
+  readonly glowSpeed?: number;
+  readonly scale?: number;
+  readonly size?: number;
+  readonly speed?: number;
+}
+declare function createFireflySprite(color: string, size?: number): HTMLCanvasElement;
+declare class FireflyParticle {
+  #private;
+  get position(): {
+    x: number;
+    y: number;
+  };
+  constructor(x: number, y: number, bounds: {
+    width: number;
+    height: number;
+  }, sprite: HTMLCanvasElement, config?: FireflyParticleConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+//#endregion
+//#region src/fireflies/types.d.ts
+type Firefly = {
+  x: number;
+  y: number;
+  size: number;
+  phase: number;
+  glowSpeed: number;
+  freqX1: number;
+  freqX2: number;
+  freqY1: number;
+  freqY2: number;
+  phaseX1: number;
+  phaseX2: number;
+  phaseY1: number;
+  phaseY2: number;
+  amplitudeX: number;
+  amplitudeY: number;
+};
+//#endregion
+//#region src/fireflies/index.d.ts
+declare function createFireflies(config?: FirefliesConfig): Effect<FirefliesConfig>;
+//#endregion
+//#region src/firepit/layer.d.ts
+interface FirepitConfig {
+  readonly embers?: number;
+  readonly flameWidth?: number;
+  readonly flameHeight?: number;
+  readonly intensity?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/firepit/types.d.ts
+type Ember = {
   x: number;
   y: number;
+  vx: number;
+  vy: number;
+  size: number;
+  life: number;
+  maxLife: number;
+  brightness: number;
+  flicker: number;
+};
+type FlameLayer = {
+  x: number;
+  phase: number;
+  speed: number;
+  amplitude: number;
+  width: number;
+  height: number;
 };
 //#endregion
+//#region src/firepit/index.d.ts
+declare function createFirepit(config?: FirepitConfig): Effect<FirepitConfig>;
+//#endregion
 //#region src/fireworks/types.d.ts
 type ExplosionType = "peony" | "chrysanthemum" | "willow" | "ring" | "palm" | "crackle" | "crossette" | "dahlia" | "brocade" | "horsetail" | "strobe" | "heart" | "spiral" | "flower";
 type FireworkVariant = ExplosionType | "saturn" | "concentric";
 type ParticleShape = "line" | "circle" | "star" | "diamond";
-interface FireworkSimulationConfig {
+interface ExplosionConfig {
+  readonly particleCount: [number, number];
+  readonly speed: [number, number];
+  readonly friction: number;
+  readonly gravity: number;
+  readonly decay: [number, number];
+  readonly trailMemory: number;
+  readonly hueVariation: number;
+  readonly brightness: [number, number];
+  readonly lineWidthScale: number;
+  readonly shape: ParticleShape;
+  readonly sparkle: boolean;
+  readonly strobe: boolean;
+  readonly spread3d: boolean;
+  readonly glowSize: number;
+}
+interface FireworksConfig {
   readonly scale?: number;
   readonly autoSpawn?: boolean;
-  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+  readonly variants?: FireworkVariant[];
 }
 declare const FIREWORK_VARIANTS: FireworkVariant[];
+declare const EXPLOSION_CONFIGS: Record<ExplosionType, ExplosionConfig>;
 //#endregion
-//#region src/fireworks/simulation.d.ts
-declare class FireworkSimulation extends LimitedFrameRateCanvas {
+//#region src/fireworks/explosion.d.ts
+declare class Explosion {
   #private;
-  constructor(canvas: HTMLCanvasElement, config?: FireworkSimulationConfig);
-  draw(): void;
-  fireExplosion(variant: FireworkVariant, position?: Point): void;
-  tick(): void;
+  get angle(): number;
+  get hue(): number;
+  get isDead(): boolean;
+  get position(): Point;
+  get type(): ExplosionType;
+  constructor(position: Point, hue: number, lineWidth: number, type: ExplosionType, scale?: number, angle?: number, speed?: number, vz?: number);
+  checkCrackle(): boolean;
+  checkSplit(): boolean;
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt: number): void;
+}
+//#endregion
+//#region src/fireworks/create-explosion.d.ts
+/**
+* Creates an array of {@link Explosion} particles for the given firework variant.
+* Use this to fire a fully formed explosion burst in your own render loop without
+* needing a {@link Fireworks} instance.
+*
+* @param variant - The firework variant to create.
+* @param position - The center position of the explosion in canvas pixels.
+* @param hue - Base hue in degrees (0–360).
+* @param options - Optional overrides for `lineWidth` (default `5`) and `scale` (default `1`).
+* @param rng - RNG function returning values in [0, 1). Defaults to `Math.random`.
+*/
+declare function createExplosion(variant: FireworkVariant, position: Point, hue: number, options?: {
+  lineWidth?: number;
+  scale?: number;
+}, rng?: () => number): Explosion[];
+//#endregion
+//#region src/fireworks/spark.d.ts
+declare class Spark {
+  #private;
+  get isDead(): boolean;
+  get position(): Point;
+  constructor(position: Point, hue: number, velocityX?: number, velocityY?: number);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt: number): void;
+}
+//#endregion
+//#region src/fireworks/firework.d.ts
+declare class Firework extends EventTarget {
+  #private;
+  get position(): Point;
+  get hue(): number;
+  constructor(start: Point, target: Point, hue: number, tailWidth: number, baseSize: number);
+  collectSparks(): Spark[];
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt: number): void;
+}
+//#endregion
+//#region src/fireworks/index.d.ts
+interface FireworksInstance extends Effect<FireworksConfig> {
+  launch(variant: FireworkVariant, position?: Point): void;
+}
+declare function createFireworks(config?: FireworksConfig): FireworksInstance;
+//#endregion
+//#region src/glitter/types.d.ts
+interface GlitterConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly groundLevel?: number;
+  readonly maxSettled?: number;
+  readonly scale?: number;
+}
+type FallingGlitter = {
+  x: number;
+  y: number;
+  vy: number;
+  size: number;
+  rotation: number;
+  rotationSpeed: number;
+  flipAngle: number;
+  flipSpeed: number;
+  sparkle: number;
+  colorIndex: number;
+  settled: boolean;
+};
+type SettledGlitter = {
+  x: number;
+  y: number;
+  size: number;
+  rotation: number;
+  sparklePhase: number;
+  sparkleSpeed: number;
+  colorIndex: number;
+};
+//#endregion
+//#region src/glitter/index.d.ts
+declare function createGlitter(config?: GlitterConfig): Effect<GlitterConfig>;
+//#endregion
+//#region src/lanterns/types.d.ts
+interface LanternsConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly scale?: number;
+}
+type Lantern = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  size: number;
+  glowPhase: number;
+  glowSpeed: number;
+  swayPhase: number;
+  swaySpeed: number;
+  swayAmplitude: number;
+  colorIndex: number;
+  opacity: number;
+};
+//#endregion
+//#region src/lanterns/index.d.ts
+declare function createLanterns(config?: LanternsConfig): Effect<LanternsConfig>;
+//#endregion
+//#region src/leaves/types.d.ts
+interface LeavesConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly wind?: number;
+  readonly scale?: number;
+}
+type Leaf = {
+  x: number;
+  y: number;
+  size: number;
+  depth: number;
+  rotation: number;
+  rotationSpeed: number;
+  flipAngle: number;
+  flipSpeed: number;
+  swingAmplitude: number;
+  swingFrequency: number;
+  swingOffset: number;
+  fallSpeed: number;
+  shape: number;
+  colorIndex: number;
+};
+//#endregion
+//#region src/leaves/index.d.ts
+declare function createLeaves(config?: LeavesConfig): Effect<LeavesConfig>;
+//#endregion
+//#region src/lightning/types.d.ts
+interface LightningConfig {
+  readonly frequency?: number;
+  readonly color?: string;
+  readonly branches?: boolean;
+  readonly flash?: boolean;
+  readonly scale?: number;
+}
+type LightningBranch = {
+  segments: {
+    x: number;
+    y: number;
+  }[];
+  alpha: number;
+};
+type LightningBolt = {
+  segments: {
+    x: number;
+    y: number;
+  }[];
+  branches: LightningBranch[];
+  alpha: number;
+  lifetime: number;
+  ticksAlive: number;
+};
+//#endregion
+//#region src/lightning/system.d.ts
+interface LightningSystemConfig {
+  readonly frequency?: number;
+  readonly color?: [number, number, number];
+  readonly branches?: boolean;
+  readonly flash?: boolean;
+  readonly scale?: number;
+  readonly groundLevel?: number;
+}
+declare class LightningSystem {
+  #private;
+  get flashAlpha(): number;
+  constructor(config: LightningSystemConfig, rng: () => number);
+  tick(dt: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
 }
 //#endregion
-//#region src/snow/simulation.d.ts
-interface SnowSimulationConfig {
+//#region src/lightning/index.d.ts
+declare function createLightning(config?: LightningConfig): Effect<LightningConfig>;
+//#endregion
+//#region src/matrix/types.d.ts
+interface MatrixConfig {
+  readonly columns?: number;
+  readonly speed?: number;
+  readonly color?: string;
+  readonly fontSize?: number;
+  readonly trailLength?: number;
+  readonly scale?: number;
+}
+type MatrixColumn = {
+  x: number;
+  y: number;
+  speed: number;
+  chars: string[];
+  length: number;
+  headBrightness: number;
+};
+//#endregion
+//#region src/matrix/index.d.ts
+declare function createMatrix(config?: MatrixConfig): Effect<MatrixConfig>;
+//#endregion
+//#region src/orbits/types.d.ts
+interface OrbitsConfig {
+  readonly centers?: number;
+  readonly orbitersPerCenter?: number;
+  readonly speed?: number;
+  readonly colors?: string[];
+  readonly trailLength?: number;
+  readonly showCenters?: boolean;
+  readonly scale?: number;
+}
+type OrbitalCenter = {
+  x: number;
+  y: number;
+};
+type Orbiter = {
+  centerIndex: number;
+  angle: number;
+  angularSpeed: number;
+  radiusX: number;
+  radiusY: number;
+  tilt: number;
+  size: number;
+  color: string;
+  trail: {
+    x: number;
+    y: number;
+  }[];
+  trailHead: number;
+};
+//#endregion
+//#region src/orbits/index.d.ts
+declare function createOrbits(config?: OrbitsConfig): Effect<OrbitsConfig>;
+//#endregion
+//#region src/particles/types.d.ts
+type ParticleMouseMode = "attract" | "repel" | "connect" | "none";
+type NetworkParticle = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  radius: number;
+  baseSpeed: number;
+};
+//#endregion
+//#region src/particles/layer.d.ts
+interface ParticlesConfig {
+  readonly count?: number;
+  readonly color?: string;
+  readonly lineColor?: string;
+  readonly size?: [number, number];
+  readonly speed?: [number, number];
+  readonly connectionDistance?: number;
+  readonly lineWidth?: number;
+  readonly mouseMode?: ParticleMouseMode;
+  readonly mouseRadius?: number;
+  readonly mouseStrength?: number;
+  readonly particleForces?: boolean;
+  readonly glow?: boolean;
+  readonly background?: string | null;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/particles/index.d.ts
+declare function createParticles(config?: ParticlesConfig): Effect<ParticlesConfig>;
+//#endregion
+//#region src/petals/layer.d.ts
+interface PetalsConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly wind?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/petals/types.d.ts
+type Petal = {
+  x: number;
+  y: number;
+  size: number;
+  depth: number;
+  rotation: number;
+  rotationSpeed: number;
+  flipAngle: number;
+  flipSpeed: number;
+  swingAmplitude: number;
+  swingFrequency: number;
+  swingOffset: number;
+  fallSpeed: number;
+  colorIndex: number;
+};
+//#endregion
+//#region src/petals/index.d.ts
+declare function createPetals(config?: PetalsConfig): Effect<PetalsConfig>;
+//#endregion
+//#region src/plasma/types.d.ts
+type PlasmaColor = {
+  r: number;
+  g: number;
+  b: number;
+};
+//#endregion
+//#region src/plasma/layer.d.ts
+interface PlasmaConfig {
+  readonly speed?: number;
+  readonly scale?: number;
+  readonly resolution?: number;
+  readonly palette?: PlasmaColor[];
+}
+//#endregion
+//#region src/plasma/index.d.ts
+declare function createPlasma(config?: PlasmaConfig): Effect<PlasmaConfig>;
+//#endregion
+//#region src/rain/types.d.ts
+type RainVariant = "drizzle" | "downpour" | "thunderstorm";
+type Raindrop = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  length: number;
+  speed: number;
+  depth: number;
+  opacity: number;
+};
+type Splash = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  alpha: number;
+  size: number;
+  gravity: number;
+};
+//#endregion
+//#region src/rain/layer.d.ts
+interface RainConfig {
+  readonly variant?: RainVariant;
+  readonly drops?: number;
+  readonly wind?: number;
+  readonly speed?: number;
+  readonly splashes?: boolean;
+  readonly color?: string;
+  readonly groundLevel?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/rain/particle.d.ts
+interface RaindropParticleConfig {
+  readonly depth?: number;
+  readonly groundY?: number;
+  readonly length?: number;
+  readonly scale?: number;
+}
+interface SplashParticleConfig {
+  readonly gravity?: number;
+  readonly scale?: number;
+  readonly size?: number;
+}
+declare class RaindropParticle {
+  #private;
+  get isDead(): boolean;
+  get position(): Point;
+  constructor(position: Point, velocity: Point, color: [number, number, number], config?: RaindropParticleConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+declare class SplashParticle {
+  #private;
+  get isDead(): boolean;
+  get position(): Point;
+  constructor(position: Point, velocity: Point, color: [number, number, number], config?: SplashParticleConfig);
+  static burst(position: Point, color: [number, number, number], config?: SplashParticleConfig): SplashParticle[];
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+//#endregion
+//#region src/rain/index.d.ts
+declare function createRain(config?: RainConfig): Effect<RainConfig>;
+//#endregion
+//#region src/sandstorm/layer.d.ts
+interface SandstormConfig {
+  readonly count?: number;
+  readonly wind?: number;
+  readonly turbulence?: number;
+  readonly color?: string;
+  readonly hazeOpacity?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/sandstorm/types.d.ts
+type SandGrain = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  size: number;
+  depth: number;
+  opacity: number;
+  turbulenceOffset: number;
+};
+//#endregion
+//#region src/sandstorm/index.d.ts
+declare function createSandstorm(config?: SandstormConfig): Effect<SandstormConfig>;
+//#endregion
+//#region src/scene.d.ts
+/**
+* Composable canvas that renders multiple Effect layers in order (first = bottom, last = top).
+*
+* @example
+* const scene = new Scene()
+*     .mount(canvas)
+*     .layer(new Aurora({ bands: 5 }))
+*     .layer(new Stars().withFade({ bottom: 0.4 }))
+*     .start();
+*/
+declare class Scene {
+  #private;
+  constructor(frameRate?: number, options?: CanvasRenderingContext2DSettings);
+  /**
+  * Mount the scene to a canvas element or CSS selector.
+  */
+  mount(canvas: HTMLCanvasElement | string, options?: CanvasRenderingContext2DSettings): this;
+  /**
+  * Add an effect layer. Layers are rendered in the order they are added.
+  * If the scene is already running, the layer is mounted immediately.
+  */
+  layer(effect: SimulationLayer): this;
+  /**
+  * Start the render loop.
+  */
+  start(): this;
+  /**
+  * Pause rendering without destroying state. Use resume() to continue.
+  */
+  pause(): this;
+  /**
+  * Resume rendering after pause().
+  */
+  resume(): this;
+  /**
+  * Stop and destroy all layers.
+  */
+  destroy(): void;
+  get speed(): number;
+  set speed(value: number);
+  get isTicking(): boolean;
+}
+/**
+* Factory alternative to `new Scene()`. Call .mount() and .layer() on the returned instance.
+*/
+declare function createScene(frameRate?: number, options?: CanvasRenderingContext2DSettings): Scene;
+//#endregion
+//#region src/shooting-stars/system.d.ts
+interface ShootingStarSystemConfig {
+  readonly interval: [number, number];
+  readonly color?: [number, number, number];
+  readonly trailLength?: number;
+  readonly trailAlphaFactor?: number;
+  readonly speed?: number;
+  readonly scale?: number;
+  readonly alphaMin?: number;
+  readonly alphaRange?: number;
+  readonly decayMin?: number;
+  readonly decayRange?: number;
+}
+declare class ShootingStarSystem {
+  #private;
+  constructor(config: ShootingStarSystemConfig, rng: () => number);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D): void;
+}
+//#endregion
+//#region src/shooting-stars/types.d.ts
+type ShootingStar = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  alpha: number;
+  size: number;
+  decay: number;
+  trail: {
+    x: number;
+    y: number;
+  }[];
+  trailHead: number;
+};
+//#endregion
+//#region src/snow/layer.d.ts
+interface SnowConfig {
   readonly fillStyle?: string;
   readonly particles?: number;
   readonly scale?: number;
   readonly size?: number;
   readonly speed?: number;
-  readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
-declare class SnowSimulation extends LimitedFrameRateCanvas {
+//#endregion
+//#region src/snow/index.d.ts
+declare function createSnow(config?: SnowConfig): Effect<SnowConfig>;
+//#endregion
+//#region src/sparklers/layer.d.ts
+interface SparklersConfig {
+  readonly emitRate?: number;
+  readonly maxSparks?: number;
+  readonly colors?: string[];
+  readonly speed?: [number, number];
+  readonly friction?: number;
+  readonly gravity?: number;
+  readonly decay?: [number, number];
+  readonly trailLength?: number;
+  readonly hoverMode?: boolean;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/sparklers/particle.d.ts
+interface SparklerParticleConfig {
+  readonly decay?: number;
+  readonly friction?: number;
+  readonly gravity?: number;
+  readonly scale?: number;
+  readonly size?: number;
+  readonly trailLength?: number;
+}
+declare class SparklerParticle {
   #private;
-  constructor(canvas: HTMLCanvasElement, config?: SnowSimulationConfig);
-  draw(): void;
-  tick(): void;
+  get isDead(): boolean;
+  get position(): Point;
+  constructor(position: Point, velocity: Point, color: [number, number, number], config?: SparklerParticleConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+//#endregion
+//#region src/sparklers/types.d.ts
+type SparklerSpark = {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  alpha: number;
+  color: [number, number, number];
+  size: number;
+  decay: number;
+  trail: Point[];
+};
+//#endregion
+//#region src/sparklers/index.d.ts
+interface SparklersInstance extends Effect<SparklersConfig> {
+  moveTo(x: number, y: number): void;
+}
+declare function createSparklers(config?: SparklersConfig): SparklersInstance;
+//#endregion
+//#region src/stars/types.d.ts
+type StarMode = "sky" | "shooting" | "both";
+type Star = {
+  x: number;
+  y: number;
+  size: number;
+  twinklePhase: number;
+  twinkleSpeed: number;
+  brightness: number;
+};
+//#endregion
+//#region src/stars/layer.d.ts
+interface StarsConfig {
+  readonly mode?: StarMode;
+  readonly starCount?: number;
+  readonly shootingInterval?: [number, number];
+  readonly shootingSpeed?: number;
+  readonly twinkleSpeed?: number;
+  readonly color?: string;
+  readonly shootingColor?: string;
+  readonly trailLength?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/stars/index.d.ts
+declare function createStars(config?: StarsConfig): Effect<StarsConfig>;
+//#endregion
+//#region src/streamers/layer.d.ts
+interface StreamersConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly speed?: number;
+  readonly scale?: number;
 }
 //#endregion
-export { ConfettiSimulation, ConfettiSimulationConfig, ExplosionType, FIREWORK_VARIANTS, FireworkSimulation, FireworkSimulationConfig, FireworkVariant, LimitedFrameRateCanvas, ParticleShape, SnowSimulation, SnowSimulationConfig };
+//#region src/streamers/types.d.ts
+type Streamer = {
+  x: number;
+  y: number;
+  length: number;
+  width: number;
+  segments: {
+    x: number;
+    y: number;
+  }[];
+  fallSpeed: number;
+  swayPhase: number;
+  swaySpeed: number;
+  swayAmplitude: number;
+  color: string;
+  curl: number;
+  depth: number;
+};
+//#endregion
+//#region src/streamers/index.d.ts
+declare function createStreamers(config?: StreamersConfig): Effect<StreamersConfig>;
+//#endregion
+//#region src/trail.d.ts
+interface TrailConfig {
+  readonly acceleration?: number;
+  readonly brightness?: number;
+  readonly glow?: number;
+  readonly hue?: number;
+  readonly length?: number;
+  readonly speed?: number;
+  readonly width?: number;
+}
+declare class Trail {
+  #private;
+  get hue(): number;
+  get isDone(): boolean;
+  get position(): Point;
+  collectSparks(): Spark[];
+  constructor(start: Point, end: Point, config?: TrailConfig);
+  draw(ctx: CanvasRenderingContext2D): void;
+  tick(dt?: number): void;
+}
+//#endregion
+//#region src/waves/layer.d.ts
+interface WavesConfig {
+  readonly layers?: number;
+  readonly speed?: number;
+  readonly colors?: string[];
+  readonly foamColor?: string;
+  readonly foamAmount?: number;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/waves/types.d.ts
+type Wave = {
+  amplitude: number;
+  frequency: number;
+  speed: number;
+  phase: number;
+  baseY: number;
+  color: string;
+  foamThreshold: number;
+  rgb: [number, number, number];
+};
+//#endregion
+//#region src/waves/index.d.ts
+declare function createWaves(config?: WavesConfig): Effect<WavesConfig>;
+//#endregion
+//#region src/wormhole/types.d.ts
+type WormholeDirection = "inward" | "outward";
+type WormholeParticle = {
+  angle: number;
+  distance: number;
+  speed: number;
+  size: number;
+  brightness: number;
+  trail: number;
+};
+//#endregion
+//#region src/wormhole/layer.d.ts
+interface WormholeConfig {
+  readonly count?: number;
+  readonly speed?: number;
+  readonly color?: string;
+  readonly direction?: WormholeDirection;
+  readonly scale?: number;
+}
+//#endregion
+//#region src/wormhole/index.d.ts
+declare function createWormhole(config?: WormholeConfig): Effect<WormholeConfig>;
+//#endregion
+export { type AuroraBand, type AuroraConfig, type Balloon, BalloonParticle, type BalloonParticleConfig, type BalloonsConfig, type Bubble, type BubblesConfig, type Config as ConfettiBurstConfig, type ConfettiConfig, ConfettiInstance, ConfettiParticle, type ConfettiParticleConfig, type Shape as ConfettiShape, type DonutsConfig, EXPLOSION_CONFIGS, type EdgeFade, type EdgeFadeSide, Effect, type Ember, Explosion, type ExplosionConfig, type ExplosionType, FIREWORK_VARIANTS, type FallingGlitter, type FirefliesConfig, type Firefly, FireflyParticle, type FireflyParticleConfig, type FirepitConfig, Firework, type FireworkVariant, type FireworksConfig, FireworksInstance, type FlameLayer, type GlitterConfig, type Lantern, type LanternsConfig, type Leaf, type LeavesConfig, type LightningBolt, type LightningBranch, type LightningConfig, LightningSystem, type LightningSystemConfig, LimitedFrameRateCanvas, type MatrixColumn, type MatrixConfig, type NetworkParticle, type OrbitalCenter, type Orbiter, type OrbitsConfig, PALETTES, type Palette, type ParticleMouseMode, type ParticleShape, type ParticlesConfig, type Petal, type PetalsConfig, type PlasmaColor, type PlasmaConfig, type PopParticle, type RainConfig, type RainVariant, type Raindrop, RaindropParticle, type RaindropParticleConfig, SHAPE_PATHS, type SandGrain, type SandstormConfig, Scene, type SettledGlitter, type ShootingStar, ShootingStarSystem, ShootingStarSystemConfig, type SnowConfig, Spark, SparklerParticle, type SparklerParticleConfig, type SparklerSpark, type SparklersConfig, SparklersInstance, type Splash, SplashParticle, type SplashParticleConfig, type Star, type StarMode, type StarsConfig, type Streamer, type StreamersConfig, Trail, TrailConfig, type Wave, type WavesConfig, type WormholeConfig, type WormholeDirection, type WormholeParticle, createAurora, createBalloons, createBubbles, createConfetti, createDonuts, createExplosion, createFireflies, createFireflySprite, createFirepit, createFireworks, createGlitter, createLanterns, createLeaves, createLightning, createMatrix, createOrbits, createParticles, createPetals, createPlasma, createRain, createSandstorm, createScene, createSnow, createSparklers, createStars, createStreamers, createWaves, createWormhole, parseColor };
 //# sourceMappingURL=index.d.mts.map