@basmilius/sparkle 2.0.0 → 2.1.0

package/dist/index.d.mts

@@ -1,10 +1,32 @@
+//#region src/layer.d.ts
+type EdgeFadeSide = number | [number, number];
+type EdgeFade = {
+  readonly top?: EdgeFadeSide;
+  readonly bottom?: EdgeFadeSide;
+  readonly left?: EdgeFadeSide;
+  readonly right?: EdgeFadeSide;
+};
+declare abstract class SimulationLayer {
+  fade: EdgeFade | null;
+  abstract tick(dt: number, width: number, height: number): void;
+  abstract draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+  onResize(_width: number, _height: number): void;
+  onMount(_canvas: HTMLCanvasElement): void;
+  onUnmount(_canvas: HTMLCanvasElement): void;
+  withFade(fade: EdgeFade): this;
+}
+//#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;
@@ -22,12 +44,184 @@ declare class LimitedFrameRateCanvas {
   onVisibilityChange(): void;
 }
 //#endregion
+//#region src/simulation-canvas.d.ts
+declare class SimulationCanvas extends LimitedFrameRateCanvas {
+  #private;
+  constructor(canvas: HTMLCanvasElement, simulation: SimulationLayer, frameRate?: number, options?: CanvasRenderingContext2DSettings);
+  start(): void;
+  destroy(): void;
+  draw(): void;
+  tick(): void;
+  onResize(): void;
+}
+//#endregion
+//#region src/aurora/simulation.d.ts
+interface AuroraSimulationConfig {
+  readonly bands?: number;
+  readonly colors?: string[];
+  readonly speed?: number;
+  readonly intensity?: number;
+  readonly waveAmplitude?: number;
+  readonly verticalPosition?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class AuroraSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: AuroraSimulationConfig);
+}
+//#endregion
+//#region src/aurora/layer.d.ts
+declare class AuroraLayer extends SimulationLayer {
+  #private;
+  constructor(config?: AuroraSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/color.d.ts
+declare function parseColor(fillStyle: string): {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+//#endregion
+//#region src/balloons/simulation.d.ts
+interface BalloonSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly sizeRange?: [number, number];
+  readonly speed?: number;
+  readonly driftAmount?: number;
+  readonly stringLength?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class BalloonSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: BalloonSimulationConfig);
+}
+//#endregion
+//#region src/balloons/layer.d.ts
+declare class BalloonLayer extends SimulationLayer {
+  #private;
+  constructor(config?: BalloonSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/bubbles/simulation.d.ts
+interface BubbleSimulationConfig {
+  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;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class BubbleSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: BubbleSimulationConfig);
+}
+//#endregion
+//#region src/bubbles/layer.d.ts
+declare class BubbleLayer extends SimulationLayer {
+  #private;
+  constructor(config?: BubbleSimulationConfig);
+  onMount(canvas: HTMLCanvasElement): void;
+  onUnmount(canvas: HTMLCanvasElement): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/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,48 +230,800 @@ 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 {
   readonly scale?: number;
   readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
-declare class ConfettiSimulation extends LimitedFrameRateCanvas {
+declare class ConfettiSimulation extends SimulationCanvas {
   #private;
   constructor(canvas: HTMLCanvasElement, config?: ConfettiSimulationConfig);
   fire(config: Partial<Config>): void;
-  draw(): void;
-  tick(): void;
-  onResize(): void;
 }
 //#endregion
-//#region src/point.d.ts
-type Point = {
+//#region src/confetti/layer.d.ts
+declare class ConfettiLayer extends SimulationLayer {
+  #private;
+  constructor(config?: ConfettiSimulationConfig);
+  onResize(width: number, height: number): void;
+  fire(config: Partial<Config>): void;
+  get hasParticles(): boolean;
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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;
+  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/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/donuts/simulation.d.ts
+interface DonutSimulationConfig {
+  readonly background?: string;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+  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;
+}
+declare class DonutSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: DonutSimulationConfig);
+}
+//#endregion
+//#region src/donuts/layer.d.ts
+declare class DonutLayer extends SimulationLayer {
+  #private;
+  constructor(config?: DonutSimulationConfig);
+  onResize(width: number, height: number): void;
+  onMount(canvas: HTMLCanvasElement): void;
+  onUnmount(canvas: HTMLCanvasElement): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/fireflies/simulation.d.ts
+interface FireflySimulationConfig {
+  readonly count?: number;
+  readonly color?: string;
+  readonly size?: number;
+  readonly speed?: number;
+  readonly glowSpeed?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class FireflySimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: FireflySimulationConfig);
+}
+//#endregion
+//#region src/fireflies/layer.d.ts
+declare class FireflyLayer extends SimulationLayer {
+  #private;
+  constructor(config?: FireflySimulationConfig);
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/firepit/simulation.d.ts
+interface FirepitSimulationConfig {
+  readonly embers?: number;
+  readonly flameWidth?: number;
+  readonly flameHeight?: number;
+  readonly intensity?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class FirepitSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: FirepitSimulationConfig);
+}
+//#endregion
+//#region src/firepit/layer.d.ts
+declare class FirepitLayer extends SimulationLayer {
+  #private;
+  constructor(config?: FirepitSimulationConfig);
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/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 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 FireworkSimulationConfig {
   readonly scale?: number;
   readonly autoSpawn?: boolean;
   readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
 declare const FIREWORK_VARIANTS: FireworkVariant[];
+declare const EXPLOSION_CONFIGS: Record<ExplosionType, ExplosionConfig>;
+//#endregion
+//#region src/fireworks/explosion.d.ts
+declare class Explosion {
+  #private;
+  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/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/layer.d.ts
+declare class FireworkLayer extends SimulationLayer {
+  #private;
+  constructor(config?: FireworkSimulationConfig);
+  onResize(width: number, height: number): void;
+  fireExplosion(variant: FireworkVariant, position?: Point): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
 //#endregion
 //#region src/fireworks/simulation.d.ts
-declare class FireworkSimulation extends LimitedFrameRateCanvas {
+declare class FireworkSimulation extends SimulationCanvas {
   #private;
   constructor(canvas: HTMLCanvasElement, config?: FireworkSimulationConfig);
-  draw(): void;
   fireExplosion(variant: FireworkVariant, position?: Point): void;
+}
+//#endregion
+//#region src/glitter/simulation.d.ts
+interface GlitterSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly groundLevel?: number;
+  readonly maxSettled?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class GlitterSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: GlitterSimulationConfig);
+}
+//#endregion
+//#region src/glitter/layer.d.ts
+declare class GlitterLayer extends SimulationLayer {
+  #private;
+  constructor(config?: GlitterSimulationConfig);
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/glitter/types.d.ts
+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/lanterns/simulation.d.ts
+interface LanternSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class LanternSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: LanternSimulationConfig);
+}
+//#endregion
+//#region src/lanterns/layer.d.ts
+declare class LanternLayer extends SimulationLayer {
+  #private;
+  constructor(config?: LanternSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/lanterns/types.d.ts
+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/layered.d.ts
+declare class LayeredSimulation extends LimitedFrameRateCanvas {
+  #private;
+  constructor(canvas: HTMLCanvasElement, frameRate?: number, options?: CanvasRenderingContext2DSettings);
+  add(layer: SimulationLayer): this;
+  start(): void;
+  destroy(): void;
+  draw(): void;
   tick(): void;
+  onResize(): void;
+}
+//#endregion
+//#region src/leaves/simulation.d.ts
+interface LeafSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly wind?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class LeafSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: LeafSimulationConfig);
+}
+//#endregion
+//#region src/leaves/layer.d.ts
+declare class LeafLayer extends SimulationLayer {
+  #private;
+  constructor(config?: LeafSimulationConfig);
+  onResize(_width: number, height: number): void;
+  tick(dt: number, _width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/leaves/types.d.ts
+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/lightning/simulation.d.ts
+interface LightningSimulationConfig {
+  readonly frequency?: number;
+  readonly color?: string;
+  readonly branches?: boolean;
+  readonly flash?: boolean;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class LightningSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: LightningSimulationConfig);
+}
+//#endregion
+//#region src/lightning/layer.d.ts
+declare class LightningLayer extends SimulationLayer {
+  #private;
+  constructor(config?: LightningSimulationConfig);
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
 }
 //#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/lightning/types.d.ts
+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/matrix/simulation.d.ts
+interface MatrixSimulationConfig {
+  readonly columns?: number;
+  readonly speed?: number;
+  readonly color?: string;
+  readonly fontSize?: number;
+  readonly trailLength?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class MatrixSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: MatrixSimulationConfig);
+}
+//#endregion
+//#region src/matrix/layer.d.ts
+declare class MatrixLayer extends SimulationLayer {
+  #private;
+  constructor(config?: MatrixSimulationConfig);
+  onResize(width: number, height: number): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/matrix/types.d.ts
+type MatrixColumn = {
+  x: number;
+  y: number;
+  speed: number;
+  chars: string[];
+  length: number;
+  headBrightness: number;
+};
+//#endregion
+//#region src/orbits/simulation.d.ts
+interface OrbitSimulationConfig {
+  readonly centers?: number;
+  readonly orbitersPerCenter?: number;
+  readonly speed?: number;
+  readonly colors?: string[];
+  readonly trailLength?: number;
+  readonly showCenters?: boolean;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class OrbitSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: OrbitSimulationConfig);
+}
+//#endregion
+//#region src/orbits/layer.d.ts
+declare class OrbitLayer extends SimulationLayer {
+  #private;
+  constructor(config?: OrbitSimulationConfig);
+  onResize(_width: number, _height: number): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/orbits/types.d.ts
+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;
+  }[];
+};
+//#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/simulation.d.ts
+interface ParticleSimulationConfig {
+  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;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class ParticleSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: ParticleSimulationConfig);
+}
+//#endregion
+//#region src/particles/layer.d.ts
+declare class ParticleLayer extends SimulationLayer {
+  #private;
+  constructor(config?: ParticleSimulationConfig);
+  onResize(width: number, height: number): void;
+  onMount(canvas: HTMLCanvasElement): void;
+  onUnmount(canvas: HTMLCanvasElement): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/petals/simulation.d.ts
+interface PetalSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly size?: number;
+  readonly speed?: number;
+  readonly wind?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class PetalSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: PetalSimulationConfig);
+}
+//#endregion
+//#region src/petals/layer.d.ts
+declare class PetalLayer extends SimulationLayer {
+  #private;
+  constructor(config?: PetalSimulationConfig);
+  tick(dt: number, _width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/plasma/types.d.ts
+type PlasmaColor = {
+  r: number;
+  g: number;
+  b: number;
+};
+//#endregion
+//#region src/plasma/simulation.d.ts
+interface PlasmaSimulationConfig {
+  readonly speed?: number;
+  readonly scale?: number;
+  readonly resolution?: number;
+  readonly palette?: PlasmaColor[];
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class PlasmaSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: PlasmaSimulationConfig);
+}
+//#endregion
+//#region src/plasma/layer.d.ts
+declare class PlasmaLayer extends SimulationLayer {
+  #private;
+  constructor(config?: PlasmaSimulationConfig);
+  tick(dt: number, _width: number, _height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/simulation.d.ts
+interface RainSimulationConfig {
+  readonly variant?: RainVariant;
+  readonly drops?: number;
+  readonly wind?: number;
+  readonly speed?: number;
+  readonly splashes?: boolean;
+  readonly color?: string;
+  readonly groundLevel?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class RainSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: RainSimulationConfig);
+}
+//#endregion
+//#region src/rain/layer.d.ts
+declare class RainLayer extends SimulationLayer {
+  #private;
+  constructor(config?: RainSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/sandstorm/simulation.d.ts
+interface SandstormSimulationConfig {
+  readonly count?: number;
+  readonly wind?: number;
+  readonly turbulence?: number;
+  readonly color?: string;
+  readonly hazeOpacity?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class SandstormSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: SandstormSimulationConfig);
+}
+//#endregion
+//#region src/sandstorm/layer.d.ts
+declare class SandstormLayer extends SimulationLayer {
+  #private;
+  constructor(config?: SandstormSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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/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;
+  readonly verticalFade?: [number, 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;
+  }[];
+};
+//#endregion
 //#region src/snow/simulation.d.ts
 interface SnowSimulationConfig {
   readonly fillStyle?: string;
@@ -87,12 +1033,244 @@ interface SnowSimulationConfig {
   readonly speed?: number;
   readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
-declare class SnowSimulation extends LimitedFrameRateCanvas {
-  #private;
+declare class SnowSimulation extends SimulationCanvas {
   constructor(canvas: HTMLCanvasElement, config?: SnowSimulationConfig);
-  draw(): void;
-  tick(): void;
 }
 //#endregion
-export { ConfettiSimulation, ConfettiSimulationConfig, ExplosionType, FIREWORK_VARIANTS, FireworkSimulation, FireworkSimulationConfig, FireworkVariant, LimitedFrameRateCanvas, ParticleShape, SnowSimulation, SnowSimulationConfig };
+//#region src/snow/layer.d.ts
+declare class SnowLayer extends SimulationLayer {
+  #private;
+  constructor(config?: SnowSimulationConfig);
+  onResize(_width: number, height: number): void;
+  tick(dt: number, _width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/sparklers/simulation.d.ts
+interface SparklerSimulationConfig {
+  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;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class SparklerSimulation extends SimulationCanvas {
+  #private;
+  constructor(canvas: HTMLCanvasElement, config?: SparklerSimulationConfig);
+  setPosition(x: number, y: number): void;
+}
+//#endregion
+//#region src/sparklers/layer.d.ts
+declare class SparklerLayer extends SimulationLayer {
+  #private;
+  constructor(config?: SparklerSimulationConfig);
+  setPosition(x: number, y: number): void;
+  onMount(canvas: HTMLCanvasElement): void;
+  onUnmount(canvas: HTMLCanvasElement): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#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;
+  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/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/simulation.d.ts
+interface StarSimulationConfig {
+  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;
+  readonly verticalFade?: [number, number];
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class StarSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: StarSimulationConfig);
+}
+//#endregion
+//#region src/stars/layer.d.ts
+declare class StarLayer extends SimulationLayer {
+  #private;
+  constructor(config?: StarSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/streamers/simulation.d.ts
+interface StreamerSimulationConfig {
+  readonly count?: number;
+  readonly colors?: string[];
+  readonly speed?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class StreamerSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: StreamerSimulationConfig);
+}
+//#endregion
+//#region src/streamers/layer.d.ts
+declare class StreamerLayer extends SimulationLayer {
+  #private;
+  constructor(config?: StreamerSimulationConfig);
+  onResize(width: number, height: number): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#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/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/simulation.d.ts
+interface WaveSimulationConfig {
+  readonly layers?: number;
+  readonly speed?: number;
+  readonly colors?: string[];
+  readonly foamColor?: string;
+  readonly foamAmount?: number;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class WaveSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: WaveSimulationConfig);
+}
+//#endregion
+//#region src/waves/layer.d.ts
+declare class WaveLayer extends SimulationLayer {
+  #private;
+  constructor(config?: WaveSimulationConfig);
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+//#region src/waves/types.d.ts
+type Wave = {
+  amplitude: number;
+  frequency: number;
+  speed: number;
+  phase: number;
+  baseY: number;
+  color: string;
+  foamThreshold: number;
+};
+//#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/simulation.d.ts
+interface WormholeSimulationConfig {
+  readonly count?: number;
+  readonly speed?: number;
+  readonly color?: string;
+  readonly direction?: WormholeDirection;
+  readonly scale?: number;
+  readonly canvasOptions?: CanvasRenderingContext2DSettings;
+}
+declare class WormholeSimulation extends SimulationCanvas {
+  constructor(canvas: HTMLCanvasElement, config?: WormholeSimulationConfig);
+}
+//#endregion
+//#region src/wormhole/layer.d.ts
+declare class WormholeLayer extends SimulationLayer {
+  #private;
+  constructor(config?: WormholeSimulationConfig);
+  onResize(width: number, height: number): void;
+  tick(dt: number, width: number, height: number): void;
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}
+//#endregion
+export { AuroraBand, AuroraLayer, AuroraSimulation, AuroraSimulationConfig, Balloon, BalloonLayer, BalloonParticle, BalloonParticleConfig, BalloonSimulation, BalloonSimulationConfig, Bubble, BubbleLayer, BubbleSimulation, BubbleSimulationConfig, ConfettiLayer, ConfettiParticle, type ConfettiParticleConfig, type Shape as ConfettiShape, ConfettiSimulation, type ConfettiSimulationConfig, DonutLayer, DonutSimulation, DonutSimulationConfig, EXPLOSION_CONFIGS, EdgeFade, EdgeFadeSide, Ember, Explosion, ExplosionConfig, ExplosionType, FIREWORK_VARIANTS, FallingGlitter, Firefly, FireflyLayer, FireflyParticle, FireflyParticleConfig, FireflySimulation, FireflySimulationConfig, FirepitLayer, FirepitSimulation, FirepitSimulationConfig, Firework, FireworkLayer, FireworkSimulation, FireworkSimulationConfig, FireworkVariant, FlameLayer, GlitterLayer, GlitterSimulation, GlitterSimulationConfig, Lantern, LanternLayer, LanternSimulation, LanternSimulationConfig, LayeredSimulation, Leaf, LeafLayer, LeafSimulation, LeafSimulationConfig, LightningBolt, LightningBranch, LightningLayer, LightningSimulation, LightningSimulationConfig, LightningSystem, LightningSystemConfig, LimitedFrameRateCanvas, MatrixColumn, MatrixLayer, MatrixSimulation, MatrixSimulationConfig, NetworkParticle, OrbitLayer, OrbitSimulation, OrbitSimulationConfig, OrbitalCenter, Orbiter, PALETTES, type Palette, ParticleLayer, ParticleMouseMode, ParticleShape, ParticleSimulation, ParticleSimulationConfig, Petal, PetalLayer, PetalSimulation, PetalSimulationConfig, PlasmaColor, PlasmaLayer, PlasmaSimulation, PlasmaSimulationConfig, PopParticle, RainLayer, RainSimulation, RainSimulationConfig, RainVariant, Raindrop, RaindropParticle, RaindropParticleConfig, SHAPE_PATHS, SandGrain, SandstormLayer, SandstormSimulation, SandstormSimulationConfig, SettledGlitter, type ShootingStar, ShootingStarSystem, ShootingStarSystemConfig, SimulationCanvas, SimulationLayer, SnowLayer, SnowSimulation, SnowSimulationConfig, Spark, SparklerLayer, SparklerParticle, SparklerParticleConfig, SparklerSimulation, SparklerSimulationConfig, SparklerSpark, Splash, SplashParticle, SplashParticleConfig, Star, StarLayer, StarMode, StarSimulation, StarSimulationConfig, Streamer, StreamerLayer, StreamerSimulation, StreamerSimulationConfig, Trail, TrailConfig, Wave, WaveLayer, WaveSimulation, WaveSimulationConfig, WormholeDirection, WormholeLayer, WormholeParticle, WormholeSimulation, WormholeSimulationConfig, createFireflySprite, parseColor };
 //# sourceMappingURL=index.d.mts.map