@basmilius/sparkle 1.0.0 → 2.1.0

package/src/snow/simulation.ts

@@ -1,6 +1,5 @@
-import { LimitedFrameRateCanvas } from '../canvas';
-import { MULBERRY } from './consts';
-import type { Snowflake } from './snowflake';
+import { SimulationCanvas } from '../simulation-canvas';
+import { SnowLayer } from './layer';
 
 export interface SnowSimulationConfig {
     readonly fillStyle?: string;
@@ -11,291 +10,8 @@ export interface SnowSimulationConfig {
     readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
 
-const SPRITE_SIZE = 64;
-const SPRITE_CENTER = SPRITE_SIZE / 2;
-const SPRITE_RADIUS = SPRITE_SIZE / 2;
-
-export class SnowSimulation extends LimitedFrameRateCanvas {
-    readonly #scale: number;
-    readonly #size: number;
-    readonly #speed: number;
-    readonly #baseOpacity: number;
-    #maxParticles: number;
-    #time: number = 0;
-    #ratio: number = 1;
-    #snowflakes: Snowflake[] = [];
-    #sprites: HTMLCanvasElement[] = [];
-
+export class SnowSimulation extends SimulationCanvas {
     constructor(canvas: HTMLCanvasElement, config: SnowSimulationConfig = {}) {
-        super(canvas, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-
-        this.#scale = config.scale ?? 1;
-        this.#maxParticles = config.particles ?? 200;
-        this.#size = (config.size ?? 9) * this.#scale;
-        this.#speed = config.speed ?? 2;
-
-        const {r, g, b, a} = this.#parseColor(config.fillStyle ?? 'rgb(255 255 255 / .75)');
-        this.#baseOpacity = a;
-
-        this.canvas.style.position = 'absolute';
-        this.canvas.style.top = '0';
-        this.canvas.style.left = '0';
-        this.canvas.style.height = '100%';
-        this.canvas.style.width = '100%';
-
-        if (this.isSmall) {
-            this.#maxParticles = Math.floor(this.#maxParticles / 2);
-        }
-
-        this.#sprites = this.#createSprites(r, g, b);
-
-        for (let i = 0; i < this.#maxParticles; ++i) {
-            this.#snowflakes.push(this.#createSnowflake(true));
-        }
-    }
-
-    draw(): void {
-        this.canvas.height = this.height;
-        this.canvas.width = this.width;
-
-        const ctx = this.context;
-        ctx.clearRect(0, 0, this.width, this.height);
-
-        for (const snowflake of this.#snowflakes) {
-            const px = snowflake.x * this.width;
-            const py = snowflake.y * this.height;
-            const displayRadius = snowflake.radius * snowflake.depth * this.#ratio;
-            const displaySize = displayRadius * 2;
-
-            if (displaySize < 0.5) {
-                continue;
-            }
-
-            ctx.globalAlpha = this.#baseOpacity * (0.15 + snowflake.depth * 0.85);
-
-            if (snowflake.spriteIndex === 3) {
-                ctx.save();
-                ctx.translate(px, py);
-                ctx.rotate(snowflake.rotation);
-                ctx.drawImage(
-                    this.#sprites[snowflake.spriteIndex],
-                    -displayRadius,
-                    -displayRadius,
-                    displaySize,
-                    displaySize
-                );
-                ctx.restore();
-            } else {
-                ctx.drawImage(
-                    this.#sprites[snowflake.spriteIndex],
-                    px - displayRadius,
-                    py - displayRadius,
-                    displaySize,
-                    displaySize
-                );
-            }
-        }
-
-        ctx.globalAlpha = 1;
-    }
-
-    tick(): void {
-        const speedFactor = (this.height / (420 * this.#ratio) / this.#speed) * this.deltaFactor;
-
-        this.#time += 0.015 * speedFactor;
-
-        // Multi-frequency wind for organic movement
-        const wind = Math.sin(this.#time * 0.7) * 0.5
-                   + Math.sin(this.#time * 1.9 + 3) * 0.25
-                   + Math.sin(this.#time * 4.3 + 1) * 0.1;
-
-        for (let index = 0; index < this.#snowflakes.length; index++) {
-            const snowflake = this.#snowflakes[index];
-
-            // Individual swing oscillation
-            const swing = Math.sin(this.#time * snowflake.swingFrequency + snowflake.swingOffset) * snowflake.swingAmplitude;
-
-            // Horizontal: personal swing + global wind (deeper = more wind influence)
-            snowflake.x += (swing + wind * snowflake.depth * 2) / (4000 * speedFactor);
-
-            // Vertical: individual speed + depth + size influence
-            snowflake.y += (snowflake.fallSpeed * 2 + snowflake.depth + snowflake.radius * 0.15) / (700 * speedFactor);
-
-            // Rotation (only visually relevant for crystal sprites)
-            snowflake.rotation += snowflake.rotationSpeed / speedFactor;
-
-            // Recycle out-of-bounds particles
-            if (snowflake.x > 1.15 || snowflake.x < -0.15 || snowflake.y > 1.05) {
-                const recycled = this.#createSnowflake(false);
-
-                if (index % 3 > 0) {
-                    recycled.x = MULBERRY.next();
-                    recycled.y = -0.05 - MULBERRY.next() * 0.15;
-                } else if (wind > 0.2) {
-                    recycled.x = -0.15;
-                    recycled.y = MULBERRY.next() * 0.8;
-                } else if (wind < -0.2) {
-                    recycled.x = 1.15;
-                    recycled.y = MULBERRY.next() * 0.8;
-                } else {
-                    recycled.x = MULBERRY.next();
-                    recycled.y = -0.05 - MULBERRY.next() * 0.15;
-                }
-
-                this.#snowflakes[index] = recycled;
-            }
-        }
-    }
-
-    #parseColor(fillStyle: string): {r: number; g: number; b: number; a: number} {
-        const canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        const ctx = canvas.getContext('2d')!;
-        ctx.fillStyle = fillStyle;
-        ctx.fillRect(0, 0, 1, 1);
-        const data = ctx.getImageData(0, 0, 1, 1).data;
-        return {r: data[0], g: data[1], b: data[2], a: data[3] / 255};
-    }
-
-    #createSprites(r: number, g: number, b: number): HTMLCanvasElement[] {
-        const sprites: HTMLCanvasElement[] = [];
-
-        const gradientProfiles: [number, number][][] = [
-            // 0: Soft glow
-            [[0, 0.8], [0.3, 0.4], [0.7, 0.1], [1, 0]],
-            // 1: Bright center
-            [[0, 1], [0.15, 0.7], [0.5, 0.2], [1, 0]],
-            // 2: Compact dot
-            [[0, 0.9], [0.25, 0.5], [0.5, 0.1], [1, 0]]
-        ];
-
-        for (const profile of gradientProfiles) {
-            const canvas = document.createElement('canvas');
-            canvas.width = SPRITE_SIZE;
-            canvas.height = SPRITE_SIZE;
-            const ctx = canvas.getContext('2d')!;
-
-            const gradient = ctx.createRadialGradient(
-                SPRITE_CENTER, SPRITE_CENTER, 0,
-                SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS
-            );
-
-            for (const [stop, alpha] of profile) {
-                gradient.addColorStop(stop, `rgba(${r}, ${g}, ${b}, ${alpha})`);
-            }
-
-            ctx.fillStyle = gradient;
-            ctx.beginPath();
-            ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS, 0, Math.PI * 2);
-            ctx.fill();
-
-            sprites.push(canvas);
-        }
-
-        // 3: Crystal snowflake
-        sprites.push(this.#createCrystalSprite(r, g, b));
-
-        return sprites;
-    }
-
-    #createCrystalSprite(r: number, g: number, b: number): HTMLCanvasElement {
-        const canvas = document.createElement('canvas');
-        canvas.width = SPRITE_SIZE;
-        canvas.height = SPRITE_SIZE;
-        const ctx = canvas.getContext('2d')!;
-
-        // Soft glow base
-        const glow = ctx.createRadialGradient(
-            SPRITE_CENTER, SPRITE_CENTER, 0,
-            SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS
-        );
-        glow.addColorStop(0, `rgba(${r}, ${g}, ${b}, 0.6)`);
-        glow.addColorStop(0.25, `rgba(${r}, ${g}, ${b}, 0.25)`);
-        glow.addColorStop(0.6, `rgba(${r}, ${g}, ${b}, 0.05)`);
-        glow.addColorStop(1, `rgba(${r}, ${g}, ${b}, 0)`);
-        ctx.fillStyle = glow;
-        ctx.beginPath();
-        ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS, 0, Math.PI * 2);
-        ctx.fill();
-
-        // Crystal arms
-        ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, 0.7)`;
-        ctx.lineWidth = 1.5;
-        ctx.lineCap = 'round';
-
-        const armLength = SPRITE_RADIUS * 0.75;
-
-        for (let arm = 0; arm < 6; arm++) {
-            const angle = (arm / 6) * Math.PI * 2 - Math.PI / 2;
-            const tipX = SPRITE_CENTER + Math.cos(angle) * armLength;
-            const tipY = SPRITE_CENTER + Math.sin(angle) * armLength;
-
-            // Main arm
-            ctx.beginPath();
-            ctx.moveTo(SPRITE_CENTER, SPRITE_CENTER);
-            ctx.lineTo(tipX, tipY);
-            ctx.stroke();
-
-            // Side branches at 40% and 65% along the arm
-            for (const position of [0.4, 0.65]) {
-                const branchX = SPRITE_CENTER + Math.cos(angle) * armLength * position;
-                const branchY = SPRITE_CENTER + Math.sin(angle) * armLength * position;
-                const branchLength = armLength * (0.4 - position * 0.3);
-
-                for (const side of [-1, 1]) {
-                    const branchAngle = angle + side * Math.PI / 3;
-                    ctx.beginPath();
-                    ctx.moveTo(branchX, branchY);
-                    ctx.lineTo(
-                        branchX + Math.cos(branchAngle) * branchLength,
-                        branchY + Math.sin(branchAngle) * branchLength
-                    );
-                    ctx.stroke();
-                }
-            }
-        }
-
-        // Center dot
-        const centerGlow = ctx.createRadialGradient(
-            SPRITE_CENTER, SPRITE_CENTER, 0,
-            SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * 0.12
-        );
-        centerGlow.addColorStop(0, `rgba(${r}, ${g}, ${b}, 0.9)`);
-        centerGlow.addColorStop(1, `rgba(${r}, ${g}, ${b}, 0)`);
-        ctx.fillStyle = centerGlow;
-        ctx.beginPath();
-        ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * 0.12, 0, Math.PI * 2);
-        ctx.fill();
-
-        return canvas;
-    }
-
-    #createSnowflake(initialSpread: boolean): Snowflake {
-        const depth = 0.3 + MULBERRY.next() * 0.7;
-        const radius = MULBERRY.next() * this.#size + 2 * this.#scale;
-
-        let spriteIndex: number;
-        if (depth > 0.85 && radius > this.#size * 0.6 && MULBERRY.next() > 0.65) {
-            spriteIndex = 3;
-        } else if (depth < 0.45) {
-            spriteIndex = 2;
-        } else {
-            spriteIndex = MULBERRY.next() > 0.5 ? 0 : 1;
-        }
-
-        return {
-            x: MULBERRY.next(),
-            y: initialSpread ? MULBERRY.next() * 2 - 1 : -0.05 - MULBERRY.next() * 0.15,
-            depth,
-            radius,
-            rotation: MULBERRY.next() * Math.PI * 2,
-            rotationSpeed: (MULBERRY.next() - 0.5) * 0.03,
-            swingAmplitude: 0.3 + MULBERRY.next() * 0.7,
-            swingFrequency: 0.5 + MULBERRY.next() * 1.5,
-            swingOffset: MULBERRY.next() * Math.PI * 2,
-            fallSpeed: 0.5 + MULBERRY.next() * 0.5,
-            spriteIndex
-        };
+        super(canvas, new SnowLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
     }
 }

package/src/sparklers/consts.ts

@@ -0,0 +1,3 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);

package/src/sparklers/index.ts

@@ -0,0 +1,6 @@
+export { SparklerLayer } from './layer';
+export { SparklerParticle } from './particle';
+export { SparklerSimulation } from './simulation';
+export type { SparklerParticleConfig } from './particle';
+export type { SparklerSimulationConfig } from './simulation';
+export type { SparklerSpark } from './types';

package/src/sparklers/layer.ts

@@ -0,0 +1,174 @@
+import { hexToRGB } from '@basmilius/utils';
+import { SimulationLayer } from '../layer';
+import { MULBERRY } from './consts';
+import type { SparklerSimulationConfig } from './simulation';
+import type { SparklerSpark } from './types';
+
+const DEFAULT_COLORS = ['#ffcc33', '#ff9900', '#ffffff', '#ffee88'];
+
+export class SparklerLayer extends SimulationLayer {
+    readonly #scale: number;
+    readonly #emitRate: number;
+    readonly #maxSparks: number;
+    readonly #colorRGBs: [number, number, number][];
+    readonly #speedRange: [number, number];
+    readonly #friction: number;
+    readonly #gravity: number;
+    readonly #decayRange: [number, number];
+    readonly #trailLength: number;
+    readonly #hoverMode: boolean;
+    readonly #onMouseMoveBound: (evt: MouseEvent) => void;
+    readonly #onMouseLeaveBound: () => void;
+    #emitX: number = 0.5;
+    #emitY: number = 0.5;
+    #mouseOnCanvas: boolean = false;
+    #sparks: SparklerSpark[] = [];
+
+    constructor(config: SparklerSimulationConfig = {}) {
+        super();
+
+        this.#scale = config.scale ?? 1;
+        this.#emitRate = config.emitRate ?? 8;
+        this.#maxSparks = config.maxSparks ?? 300;
+        this.#speedRange = config.speed ?? [2, 8];
+        this.#friction = config.friction ?? 0.96;
+        this.#gravity = config.gravity ?? 0.8;
+        this.#decayRange = config.decay ?? [0.02, 0.05];
+        this.#trailLength = config.trailLength ?? 3;
+        this.#hoverMode = config.hoverMode ?? false;
+
+        const colors = config.colors ?? DEFAULT_COLORS;
+        this.#colorRGBs = colors.map(c => hexToRGB(c));
+
+        this.#onMouseMoveBound = this.#onMouseMove.bind(this);
+        this.#onMouseLeaveBound = this.#onMouseLeave.bind(this);
+    }
+
+    setPosition(x: number, y: number): void {
+        this.#emitX = x;
+        this.#emitY = y;
+    }
+
+    onMount(canvas: HTMLCanvasElement): void {
+        if (this.#hoverMode) {
+            canvas.addEventListener('mousemove', this.#onMouseMoveBound, {passive: true});
+            canvas.addEventListener('mouseleave', this.#onMouseLeaveBound, {passive: true});
+        }
+    }
+
+    onUnmount(canvas: HTMLCanvasElement): void {
+        canvas.removeEventListener('mousemove', this.#onMouseMoveBound);
+        canvas.removeEventListener('mouseleave', this.#onMouseLeaveBound);
+    }
+
+    tick(dt: number, width: number, height: number): void {
+        if (!this.#hoverMode || this.#mouseOnCanvas) {
+            const emitCount = Math.min(this.#emitRate, this.#maxSparks - this.#sparks.length);
+
+            for (let i = 0; i < emitCount; i++) {
+                this.#sparks.push(this.#createSpark(width, height));
+            }
+        }
+
+        let alive = 0;
+
+        for (let i = 0; i < this.#sparks.length; i++) {
+            const spark = this.#sparks[i];
+
+            spark.trail.push({x: spark.x, y: spark.y});
+
+            if (spark.trail.length > this.#trailLength) {
+                spark.trail.shift();
+            }
+
+            spark.vx *= Math.pow(this.#friction, dt);
+            spark.vy *= Math.pow(this.#friction, dt);
+            spark.vy += this.#gravity * this.#scale * dt;
+
+            spark.x += spark.vx * dt;
+            spark.y += spark.vy * dt;
+
+            spark.alpha -= spark.decay * dt;
+
+            if (spark.alpha > 0) {
+                this.#sparks[alive++] = spark;
+            }
+        }
+
+        this.#sparks.length = alive;
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+        ctx.globalCompositeOperation = 'lighter';
+
+        if (!this.#hoverMode || this.#mouseOnCanvas) {
+            const cx = this.#emitX * width;
+            const cy = this.#emitY * height;
+            const glowRadius = 15 * this.#scale;
+            const glow = ctx.createRadialGradient(cx, cy, 0, cx, cy, glowRadius);
+            glow.addColorStop(0, 'rgba(255, 220, 100, 0.8)');
+            glow.addColorStop(0.3, 'rgba(255, 180, 50, 0.3)');
+            glow.addColorStop(1, 'rgba(255, 150, 0, 0)');
+            ctx.fillStyle = glow;
+            ctx.beginPath();
+            ctx.arc(cx, cy, glowRadius, 0, Math.PI * 2);
+            ctx.fill();
+        }
+
+        for (const spark of this.#sparks) {
+            const [r, g, b] = spark.color;
+
+            for (let t = 0; t < spark.trail.length; t++) {
+                const trailAlpha = spark.alpha * (t / spark.trail.length) * 0.5;
+
+                if (trailAlpha < 0.01) {
+                    continue;
+                }
+
+                const trailSize = spark.size * (t / spark.trail.length) * this.#scale;
+
+                ctx.beginPath();
+                ctx.arc(spark.trail[t].x, spark.trail[t].y, trailSize, 0, Math.PI * 2);
+                ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${trailAlpha})`;
+                ctx.fill();
+            }
+
+            ctx.beginPath();
+            ctx.arc(spark.x, spark.y, spark.size * this.#scale, 0, Math.PI * 2);
+            ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${spark.alpha})`;
+            ctx.fill();
+        }
+
+        ctx.globalCompositeOperation = 'source-over';
+    }
+
+    #onMouseMove(evt: MouseEvent): void {
+        const target = evt.currentTarget as HTMLCanvasElement;
+        const rect = target.getBoundingClientRect();
+        this.#emitX = (evt.clientX - rect.left) / rect.width;
+        this.#emitY = (evt.clientY - rect.top) / rect.height;
+        this.#mouseOnCanvas = true;
+    }
+
+    #onMouseLeave(): void {
+        this.#mouseOnCanvas = false;
+    }
+
+    #createSpark(width: number, height: number): SparklerSpark {
+        const angle = MULBERRY.next() * Math.PI * 2;
+        const speed = this.#speedRange[0] + MULBERRY.next() * (this.#speedRange[1] - this.#speedRange[0]);
+        const colorIndex = Math.floor(MULBERRY.next() * this.#colorRGBs.length);
+
+        return {
+            x: this.#emitX * width,
+            y: this.#emitY * height,
+            vx: Math.cos(angle) * speed * this.#scale,
+            vy: Math.sin(angle) * speed * this.#scale,
+            alpha: 0.8 + MULBERRY.next() * 0.2,
+            color: this.#colorRGBs[colorIndex],
+            size: 1 + MULBERRY.next() * 2,
+            decay: this.#decayRange[0] + MULBERRY.next() * (this.#decayRange[1] - this.#decayRange[0]),
+            trail: []
+        };
+    }
+}

package/src/sparklers/particle.ts

@@ -0,0 +1,89 @@
+import type { Point } from '../point';
+
+export interface SparklerParticleConfig {
+    readonly decay?: number;
+    readonly friction?: number;
+    readonly gravity?: number;
+    readonly scale?: number;
+    readonly size?: number;
+    readonly trailLength?: number;
+}
+
+export class SparklerParticle {
+    readonly #color: [number, number, number];
+    readonly #decay: number;
+    readonly #friction: number;
+    readonly #gravity: number;
+    readonly #scale: number;
+    readonly #size: number;
+    readonly #trailLength: number;
+    readonly #trail: Point[] = [];
+    #x: number;
+    #y: number;
+    #vx: number;
+    #vy: number;
+    #alpha: number = 1;
+
+    get isDead(): boolean {
+        return this.#alpha <= 0;
+    }
+
+    get position(): Point {
+        return {x: this.#x, y: this.#y};
+    }
+
+    constructor(position: Point, velocity: Point, color: [number, number, number], config: SparklerParticleConfig = {}) {
+        this.#x = position.x;
+        this.#y = position.y;
+        this.#vx = velocity.x;
+        this.#vy = velocity.y;
+        this.#color = color;
+        this.#decay = config.decay ?? (0.02 + Math.random() * 0.03);
+        this.#friction = config.friction ?? 0.96;
+        this.#gravity = config.gravity ?? 0.8;
+        this.#scale = config.scale ?? 1;
+        this.#size = config.size ?? (1 + Math.random() * 2);
+        this.#trailLength = config.trailLength ?? 3;
+    }
+
+    draw(ctx: CanvasRenderingContext2D): void {
+        const [r, g, b] = this.#color;
+
+        for (let t = 0; t < this.#trail.length; t++) {
+            const trailAlpha = this.#alpha * (t / this.#trail.length) * 0.5;
+
+            if (trailAlpha < 0.01) {
+                continue;
+            }
+
+            const trailSize = this.#size * (t / this.#trail.length) * this.#scale;
+
+            ctx.beginPath();
+            ctx.arc(this.#trail[t].x, this.#trail[t].y, trailSize, 0, Math.PI * 2);
+            ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${trailAlpha})`;
+            ctx.fill();
+        }
+
+        ctx.beginPath();
+        ctx.arc(this.#x, this.#y, this.#size * this.#scale, 0, Math.PI * 2);
+        ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${this.#alpha})`;
+        ctx.fill();
+    }
+
+    tick(dt: number = 1): void {
+        this.#trail.push({x: this.#x, y: this.#y});
+
+        if (this.#trail.length > this.#trailLength) {
+            this.#trail.shift();
+        }
+
+        this.#vx *= Math.pow(this.#friction, dt);
+        this.#vy *= Math.pow(this.#friction, dt);
+        this.#vy += this.#gravity * this.#scale * dt;
+
+        this.#x += this.#vx * dt;
+        this.#y += this.#vy * dt;
+
+        this.#alpha -= this.#decay * dt;
+    }
+}

package/src/sparklers/simulation.ts

@@ -0,0 +1,30 @@
+import { SimulationCanvas } from '../simulation-canvas';
+import { SparklerLayer } from './layer';
+
+export 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;
+}
+
+export class SparklerSimulation extends SimulationCanvas {
+    readonly #layer: SparklerLayer;
+
+    constructor(canvas: HTMLCanvasElement, config: SparklerSimulationConfig = {}) {
+        const layer = new SparklerLayer(config);
+        super(canvas, layer, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
+        this.#layer = layer;
+    }
+
+    setPosition(x: number, y: number): void {
+        this.#layer.setPosition(x, y);
+    }
+}

package/src/sparklers/types.ts

@@ -0,0 +1,13 @@
+import type { Point } from '../point';
+
+export type SparklerSpark = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    alpha: number;
+    color: [number, number, number];
+    size: number;
+    decay: number;
+    trail: Point[];
+};

package/src/stars/consts.ts

@@ -0,0 +1,3 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);

package/src/stars/index.ts

@@ -0,0 +1,4 @@
+export { StarLayer } from './layer';
+export { StarSimulation } from './simulation';
+export type { StarSimulationConfig } from './simulation';
+export type { Star, StarMode, ShootingStar } from './types';