@basmilius/sparkle 2.4.0 → 2.5.0

package/src/hyper-space/layer.ts

@@ -0,0 +1,167 @@
+import { Effect } from '../effect';
+import { MULBERRY } from './consts';
+import type { HyperSpaceStar } from './types';
+
+export interface HyperSpaceConfig {
+    readonly count?: number;
+    readonly speed?: number;
+    readonly color?: string;
+    readonly scale?: number;
+}
+
+export class HyperSpace extends Effect<HyperSpaceConfig> {
+    readonly #scale: number;
+    #speed: number;
+    #colorR: number;
+    #colorG: number;
+    #colorB: number;
+    #stars: HyperSpaceStar[] = [];
+    #maxCount: number;
+    #width: number = 960;
+    #height: number = 540;
+    #initialized: boolean = false;
+
+    constructor(config: HyperSpaceConfig = {}) {
+        super();
+
+        this.#scale = config.scale ?? 1;
+        this.#speed = config.speed ?? 1;
+        this.#maxCount = config.count ?? 250;
+
+        const parsed = this.#parseHex(config.color ?? '#ffffff');
+        this.#colorR = parsed[0];
+        this.#colorG = parsed[1];
+        this.#colorB = parsed[2];
+
+        if (typeof globalThis.innerWidth !== 'undefined' && globalThis.innerWidth < 991) {
+            this.#maxCount = Math.floor(this.#maxCount / 2);
+        }
+    }
+
+    configure(config: Partial<HyperSpaceConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+
+        if (config.color !== undefined) {
+            const parsed = this.#parseHex(config.color);
+            this.#colorR = parsed[0];
+            this.#colorG = parsed[1];
+            this.#colorB = parsed[2];
+        }
+    }
+
+    onResize(width: number, height: number): void {
+        this.#width = width;
+        this.#height = height;
+
+        if (!this.#initialized && width > 0 && height > 0) {
+            this.#initialized = true;
+            this.#stars = [];
+
+            for (let i = 0; i < this.#maxCount; ++i) {
+                this.#stars.push(this.#createStar(true));
+            }
+        }
+    }
+
+    tick(dt: number, width: number, height: number): void {
+        this.#width = width;
+        this.#height = height;
+
+        const maxRadius = Math.sqrt((width / 2) ** 2 + (height / 2) ** 2);
+
+        for (let i = 0; i < this.#stars.length; ++i) {
+            const star = this.#stars[i];
+
+            star.prevRadius = star.radius;
+
+            const acceleration = 1 + (star.radius / maxRadius) * 4;
+            star.radius += star.speed * this.#speed * acceleration * dt * 0.3 * this.#scale;
+
+            if (star.radius >= maxRadius + 10) {
+                this.#stars[i] = this.#createStar(false);
+            }
+        }
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+        const cx = width / 2;
+        const cy = height / 2;
+        const maxRadius = Math.sqrt(cx * cx + cy * cy);
+        const cr = this.#colorR;
+        const cg = this.#colorG;
+        const cb = this.#colorB;
+
+        ctx.globalCompositeOperation = 'source-over';
+        ctx.globalAlpha = 1;
+        ctx.fillStyle = 'rgb(0, 0, 8)';
+        ctx.fillRect(0, 0, width, height);
+
+        ctx.globalCompositeOperation = 'lighter';
+
+        for (const star of this.#stars) {
+            const normalizedRadius = star.radius / maxRadius;
+            const alpha = Math.min(1, 0.1 + normalizedRadius * 0.9) * star.brightness;
+            const lineWidth = Math.max(0.5, this.#scale * (0.3 + normalizedRadius * 1.5));
+
+            const px = cx + Math.cos(star.angle) * star.radius;
+            const py = cy + Math.sin(star.angle) * star.radius;
+
+            const trailLength = Math.max(star.radius - star.prevRadius, 1);
+            const prevRadius = Math.max(0, star.prevRadius);
+            const tx = cx + Math.cos(star.angle) * prevRadius;
+            const ty = cy + Math.sin(star.angle) * prevRadius;
+
+            const gradient = ctx.createLinearGradient(tx, ty, px, py);
+            gradient.addColorStop(0, `rgba(${cr}, ${cg}, ${cb}, 0)`);
+            gradient.addColorStop(1, `rgba(${cr}, ${cg}, ${cb}, ${alpha})`);
+
+            ctx.globalAlpha = 1;
+            ctx.beginPath();
+            ctx.moveTo(tx, ty);
+            ctx.lineTo(px, py);
+            ctx.strokeStyle = gradient;
+            ctx.lineWidth = lineWidth;
+            ctx.lineCap = 'round';
+            ctx.stroke();
+
+            if (normalizedRadius > 0.5) {
+                ctx.globalAlpha = alpha * 0.8;
+                ctx.fillStyle = `rgb(${cr}, ${cg}, ${cb})`;
+                ctx.beginPath();
+                ctx.arc(px, py, lineWidth * 0.7, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+
+        ctx.globalAlpha = 1;
+        ctx.resetTransform();
+        ctx.globalCompositeOperation = 'source-over';
+    }
+
+    #createStar(spread: boolean): HyperSpaceStar {
+        const maxRadius = Math.sqrt((this.#width / 2) ** 2 + (this.#height / 2) ** 2);
+        const angle = MULBERRY.next() * Math.PI * 2;
+        const radius = spread ? MULBERRY.next() * maxRadius * 0.8 : MULBERRY.next() * maxRadius * 0.05;
+
+        return {
+            angle,
+            radius,
+            prevRadius: radius,
+            speed: 0.5 + MULBERRY.next() * 1.5,
+            size: 0.5 + MULBERRY.next() * 1.5,
+            brightness: 0.5 + MULBERRY.next() * 0.5
+        };
+    }
+
+    #parseHex(hex: string): [number, number, number] {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+
+        if (!result) {
+            return [255, 255, 255];
+        }
+
+        return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)];
+    }
+}

package/src/hyper-space/types.ts

@@ -0,0 +1,8 @@
+export interface HyperSpaceStar {
+    angle: number;
+    radius: number;
+    speed: number;
+    prevRadius: number;
+    size: number;
+    brightness: number;
+}

package/src/index.ts

@@ -1,31 +1,60 @@
 export * from './aurora';
 export * from './balloons';
+export * from './black-hole';
+export * from './boids';
 export * from './bubbles';
+export * from './butterflies';
 export * from './canvas';
+export * from './caustics';
+export * from './clouds';
 export * from './color';
 export * from './confetti';
+export * from './constellation';
+export * from './coral-reef';
+export * from './crystallization';
+export * from './digital-rain';
 export * from './donuts';
 export * from './effect';
 export * from './fireflies';
 export * from './firepit';
 export * from './fireworks';
+export * from './glitch';
 export * from './glitter';
+export * from './gradient-flow';
+export * from './hologram';
+export * from './hyper-space';
+export * from './interference';
+export * from './kaleidoscope';
 export * from './lanterns';
+export * from './lava';
 export * from './leaves';
 export * from './lightning';
 export * from './matrix';
+export * from './murmuration';
+export * from './nebula';
+export * from './neon';
 export * from './orbits';
 export * from './particles';
 export * from './petals';
 export * from './plasma';
+export * from './pollen';
+export * from './popcorn';
+export * from './portal';
+export * from './pulse-grid';
 export * from './rain';
+export * from './roots';
 export * from './sandstorm';
 export * from './scene';
 export * from './shooting-stars';
+export * from './smoke';
 export * from './snow';
 export * from './sparklers';
 export * from './stars';
 export * from './streamers';
+export * from './topography';
+export * from './tornado';
 export * from './trail';
+export * from './voronoi';
+export * from './volcano';
 export * from './waves';
 export * from './wormhole';

package/src/interference/consts.ts

@@ -0,0 +1,9 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);
+
+export const DEFAULT_COLORS: string[] = [
+    '#ff0066',
+    '#0066ff',
+    '#00ff66'
+];

package/src/interference/index.ts

@@ -0,0 +1,9 @@
+import { Interference } from './layer';
+import type { InterferenceConfig } from './layer';
+import type { Effect } from '../effect';
+
+export function createInterference(config?: InterferenceConfig): Effect<InterferenceConfig> {
+    return new Interference(config);
+}
+
+export type { InterferenceConfig };

package/src/interference/layer.ts

@@ -0,0 +1,129 @@
+import { hexToRGB } from '@basmilius/utils';
+import { Effect } from '../effect';
+import { DEFAULT_COLORS } from './consts';
+
+export interface InterferenceConfig {
+    readonly speed?: number;
+    readonly scale?: number;
+    readonly resolution?: number;
+    readonly layers?: number;
+    readonly colors?: string[];
+}
+
+export class Interference extends Effect<InterferenceConfig> {
+    #speed: number;
+    #scale: number;
+    readonly #resolution: number;
+    readonly #layerCount: number;
+    readonly #colorRGBs: [number, number, number][];
+    #time: number = 0;
+    #offscreen: HTMLCanvasElement | null = null;
+    #offscreenCtx: CanvasRenderingContext2D | null = null;
+    #imageData: ImageData | null = null;
+    #centers: { x: number; y: number; freqX: number; freqY: number; phaseX: number; phaseY: number; speedMul: number }[];
+
+    constructor(config: InterferenceConfig = {}) {
+        super();
+
+        this.#speed = config.speed ?? 1;
+        this.#scale = config.scale ?? 1;
+        this.#resolution = config.resolution ?? 3;
+        this.#layerCount = config.layers ?? 3;
+
+        const colors = config.colors ?? DEFAULT_COLORS;
+        this.#colorRGBs = colors.map(c => hexToRGB(c));
+
+        this.#centers = [];
+
+        for (let idx = 0; idx < this.#layerCount; idx++) {
+            this.#centers.push({
+                x: 0,
+                y: 0,
+                freqX: 0.3 + idx * 0.17,
+                freqY: 0.2 + idx * 0.13,
+                phaseX: idx * Math.PI * 2 / this.#layerCount,
+                phaseY: idx * Math.PI * 1.3 / this.#layerCount,
+                speedMul: 0.7 + idx * 0.3
+            });
+        }
+    }
+
+    configure(config: Partial<InterferenceConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+        if (config.scale !== undefined) {
+            this.#scale = config.scale;
+        }
+    }
+
+    tick(dt: number, width: number, height: number): void {
+        this.#time += 0.015 * dt * this.#speed;
+
+        for (let idx = 0; idx < this.#centers.length; idx++) {
+            const center = this.#centers[idx];
+            center.x = (0.5 + 0.35 * Math.sin(this.#time * center.freqX + center.phaseX)) * width;
+            center.y = (0.5 + 0.35 * Math.cos(this.#time * center.freqY + center.phaseY)) * height;
+        }
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+        const resolution = this.#resolution;
+        const offWidth = Math.ceil(width / resolution);
+        const offHeight = Math.ceil(height / resolution);
+
+        if (!this.#offscreen || this.#offscreen.width !== offWidth || this.#offscreen.height !== offHeight) {
+            this.#offscreen = document.createElement('canvas');
+            this.#offscreen.width = offWidth;
+            this.#offscreen.height = offHeight;
+            this.#offscreenCtx = this.#offscreen.getContext('2d');
+            this.#imageData = this.#offscreenCtx!.createImageData(offWidth, offHeight);
+        }
+
+        const data = this.#imageData!.data;
+        const scale = this.#scale;
+        const freq = 30 * scale;
+        const centers = this.#centers;
+        const centerCount = centers.length;
+        const colorRGBs = this.#colorRGBs;
+        const colorCount = colorRGBs.length;
+
+        for (let py = 0; py < offHeight; py++) {
+            const worldY = py * resolution;
+
+            for (let px = 0; px < offWidth; px++) {
+                const worldX = px * resolution;
+
+                let totalR = 0;
+                let totalG = 0;
+                let totalB = 0;
+
+                for (let ci = 0; ci < centerCount; ci++) {
+                    const center = centers[ci];
+                    const dx = worldX - center.x;
+                    const dy = worldY - center.y;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+
+                    const wave = (Math.sin(dist / freq) + 1) * 0.5;
+                    const color = colorRGBs[ci % colorCount];
+
+                    totalR += color[0] * wave;
+                    totalG += color[1] * wave;
+                    totalB += color[2] * wave;
+                }
+
+                const maxVal = centerCount * 255;
+                const offset = (py * offWidth + px) * 4;
+                data[offset] = Math.min(255, (totalR / maxVal) * 255) | 0;
+                data[offset + 1] = Math.min(255, (totalG / maxVal) * 255) | 0;
+                data[offset + 2] = Math.min(255, (totalB / maxVal) * 255) | 0;
+                data[offset + 3] = 255;
+            }
+        }
+
+        this.#offscreenCtx!.putImageData(this.#imageData!, 0, 0);
+
+        ctx.imageSmoothingEnabled = true;
+        ctx.drawImage(this.#offscreen!, 0, 0, width, height);
+    }
+}

package/src/kaleidoscope/consts.ts

@@ -0,0 +1,12 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);
+
+export const DEFAULT_COLORS: string[] = [
+    '#ff3366',
+    '#33ccff',
+    '#ffcc00',
+    '#66ff66',
+    '#cc66ff',
+    '#ff9933'
+];

package/src/kaleidoscope/index.ts

@@ -0,0 +1,9 @@
+import { Kaleidoscope } from './layer';
+import type { KaleidoscopeConfig } from './types';
+import type { Effect } from '../effect';
+
+export function createKaleidoscope(config?: KaleidoscopeConfig): Effect<KaleidoscopeConfig> {
+    return new Kaleidoscope(config);
+}
+
+export type { KaleidoscopeConfig, KaleidoscopeShape } from './types';

package/src/kaleidoscope/layer.ts

@@ -0,0 +1,213 @@
+import { hexToRGB } from '@basmilius/utils';
+import { Effect } from '../effect';
+import { DEFAULT_COLORS, MULBERRY } from './consts';
+import type { KaleidoscopeConfig, KaleidoscopeShape } from './types';
+
+export class Kaleidoscope extends Effect<KaleidoscopeConfig> {
+    #segments: number;
+    #speed: number;
+    #shapeCount: number;
+    #colors: string[];
+    #scale: number;
+    #shapes: KaleidoscopeShape[] = [];
+    #sourceCanvas: HTMLCanvasElement | null = null;
+    #sourceCtx: CanvasRenderingContext2D | null = null;
+    #sourceRadius: number = 0;
+    #time: number = 0;
+    #initialized: boolean = false;
+
+    constructor(config: KaleidoscopeConfig = {}) {
+        super();
+
+        this.#segments = config.segments ?? 8;
+        this.#speed = config.speed ?? 1;
+        this.#shapeCount = config.shapes ?? 15;
+        this.#colors = config.colors ?? DEFAULT_COLORS;
+        this.#scale = config.scale ?? 1;
+    }
+
+    configure(config: Partial<KaleidoscopeConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+    }
+
+    onResize(width: number, height: number): void {
+        this.#sourceRadius = Math.min(width, height) / 2;
+
+        const size = Math.ceil(this.#sourceRadius * 2);
+        this.#sourceCanvas = document.createElement('canvas');
+        this.#sourceCanvas.width = size;
+        this.#sourceCanvas.height = size;
+        this.#sourceCtx = this.#sourceCanvas.getContext('2d')!;
+
+        if (!this.#initialized) {
+            this.#initialized = true;
+            this.#shapes = [];
+
+            for (let index = 0; index < this.#shapeCount; index++) {
+                this.#shapes.push(this.#createShape());
+            }
+        }
+    }
+
+    tick(dt: number, _width: number, _height: number): void {
+        const speedMul = this.#speed * dt;
+        this.#time += 0.02 * speedMul;
+
+        const radius = this.#sourceRadius * 0.8;
+
+        for (const shape of this.#shapes) {
+            shape.x += shape.vx * speedMul;
+            shape.y += shape.vy * speedMul;
+            shape.rotation += shape.rotationSpeed * speedMul;
+
+            const dist = Math.sqrt(shape.x * shape.x + shape.y * shape.y);
+
+            if (dist + shape.size > radius) {
+                const nx = shape.x / dist;
+                const ny = shape.y / dist;
+                const dot = shape.vx * nx + shape.vy * ny;
+                shape.vx -= 2 * dot * nx;
+                shape.vy -= 2 * dot * ny;
+
+                const overlap = dist + shape.size - radius;
+                shape.x -= nx * overlap;
+                shape.y -= ny * overlap;
+            }
+        }
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+        if (!this.#sourceCanvas || !this.#sourceCtx) {
+            return;
+        }
+
+        const sourceCtx = this.#sourceCtx;
+        const radius = this.#sourceRadius;
+        const segmentAngle = (Math.PI * 2) / this.#segments;
+        const centerX = width / 2;
+        const centerY = height / 2;
+
+        sourceCtx.clearRect(0, 0, this.#sourceCanvas.width, this.#sourceCanvas.height);
+        sourceCtx.save();
+
+        sourceCtx.beginPath();
+        sourceCtx.moveTo(radius, radius);
+        sourceCtx.arc(radius, radius, radius, -segmentAngle / 2, segmentAngle / 2);
+        sourceCtx.closePath();
+        sourceCtx.clip();
+
+        for (const shape of this.#shapes) {
+            const px = radius + shape.x * this.#scale;
+            const py = radius + shape.y * this.#scale;
+            const size = shape.size * this.#scale;
+            const [cr, cg, cb] = hexToRGB(shape.color);
+
+            sourceCtx.save();
+            sourceCtx.translate(px, py);
+            sourceCtx.rotate(shape.rotation);
+
+            if (shape.type === 0) {
+                const gradient = sourceCtx.createRadialGradient(0, 0, 0, 0, 0, size);
+                gradient.addColorStop(0, `rgba(${cr}, ${cg}, ${cb}, 0.9)`);
+                gradient.addColorStop(0.5, `rgba(${cr}, ${cg}, ${cb}, 0.5)`);
+                gradient.addColorStop(1, `rgba(${cr}, ${cg}, ${cb}, 0)`);
+                sourceCtx.fillStyle = gradient;
+                sourceCtx.beginPath();
+                sourceCtx.arc(0, 0, size, 0, Math.PI * 2);
+                sourceCtx.fill();
+            } else if (shape.type === 1) {
+                sourceCtx.fillStyle = `rgba(${cr}, ${cg}, ${cb}, 0.7)`;
+                sourceCtx.beginPath();
+                for (let point = 0; point < 6; point++) {
+                    const angle = (point / 6) * Math.PI * 2;
+                    const hx = Math.cos(angle) * size;
+                    const hy = Math.sin(angle) * size;
+
+                    if (point === 0) {
+                        sourceCtx.moveTo(hx, hy);
+                    } else {
+                        sourceCtx.lineTo(hx, hy);
+                    }
+                }
+                sourceCtx.closePath();
+                sourceCtx.fill();
+
+                sourceCtx.strokeStyle = `rgba(${Math.min(255, cr + 60)}, ${Math.min(255, cg + 60)}, ${Math.min(255, cb + 60)}, 0.5)`;
+                sourceCtx.lineWidth = 1.5;
+                sourceCtx.stroke();
+            } else if (shape.type === 2) {
+                const petalCount = 5;
+
+                sourceCtx.fillStyle = `rgba(${cr}, ${cg}, ${cb}, 0.6)`;
+
+                for (let petal = 0; petal < petalCount; petal++) {
+                    const angle = (petal / petalCount) * Math.PI * 2;
+                    sourceCtx.save();
+                    sourceCtx.rotate(angle);
+                    sourceCtx.beginPath();
+                    sourceCtx.ellipse(0, -size * 0.5, size * 0.3, size * 0.6, 0, 0, Math.PI * 2);
+                    sourceCtx.fill();
+                    sourceCtx.restore();
+                }
+
+                const coreGradient = sourceCtx.createRadialGradient(0, 0, 0, 0, 0, size * 0.25);
+                coreGradient.addColorStop(0, `rgba(255, 255, 255, 0.8)`);
+                coreGradient.addColorStop(1, `rgba(${cr}, ${cg}, ${cb}, 0.3)`);
+                sourceCtx.fillStyle = coreGradient;
+                sourceCtx.beginPath();
+                sourceCtx.arc(0, 0, size * 0.25, 0, Math.PI * 2);
+                sourceCtx.fill();
+            } else {
+                const gradient = sourceCtx.createRadialGradient(0, 0, size * 0.3, 0, 0, size);
+                gradient.addColorStop(0, `rgba(${cr}, ${cg}, ${cb}, 0)`);
+                gradient.addColorStop(0.4, `rgba(${cr}, ${cg}, ${cb}, 0.6)`);
+                gradient.addColorStop(0.6, `rgba(${cr}, ${cg}, ${cb}, 0.6)`);
+                gradient.addColorStop(1, `rgba(${cr}, ${cg}, ${cb}, 0)`);
+                sourceCtx.fillStyle = gradient;
+                sourceCtx.beginPath();
+                sourceCtx.arc(0, 0, size, 0, Math.PI * 2);
+                sourceCtx.fill();
+            }
+
+            sourceCtx.restore();
+        }
+
+        sourceCtx.restore();
+
+        for (let index = 0; index < this.#segments; index++) {
+            const angle = segmentAngle * index;
+            const mirrored = index % 2 === 1;
+
+            ctx.save();
+            ctx.translate(centerX, centerY);
+            ctx.rotate(angle);
+
+            if (mirrored) {
+                ctx.scale(1, -1);
+            }
+
+            ctx.drawImage(this.#sourceCanvas, -radius, -radius);
+            ctx.restore();
+        }
+    }
+
+    #createShape(): KaleidoscopeShape {
+        const maxDist = this.#sourceRadius * 0.6;
+        const angle = MULBERRY.next() * Math.PI * 2;
+        const dist = MULBERRY.next() * maxDist;
+
+        return {
+            x: Math.cos(angle) * dist,
+            y: Math.sin(angle) * dist,
+            vx: (MULBERRY.next() - 0.5) * 1.2,
+            vy: (MULBERRY.next() - 0.5) * 1.2,
+            size: 8 + MULBERRY.next() * 25,
+            color: this.#colors[Math.floor(MULBERRY.next() * this.#colors.length)],
+            type: Math.floor(MULBERRY.next() * 4),
+            rotation: MULBERRY.next() * Math.PI * 2,
+            rotationSpeed: (MULBERRY.next() - 0.5) * 0.06
+        };
+    }
+}

package/src/kaleidoscope/types.ts

@@ -0,0 +1,19 @@
+export interface KaleidoscopeConfig {
+    readonly segments?: number;
+    readonly speed?: number;
+    readonly shapes?: number;
+    readonly colors?: string[];
+    readonly scale?: number;
+}
+
+export type KaleidoscopeShape = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    size: number;
+    color: string;
+    type: number;
+    rotation: number;
+    rotationSpeed: number;
+};

package/src/lanterns/layer.ts

@@ -88,7 +88,8 @@ export class Lanterns extends Effect<LanternsConfig> {
             ctx.arc(px, py, glowRadius, 0, Math.PI * 2);
             ctx.fill();
 
-            ctx.setTransform(1, 0, 0, 1, px, py);
+            ctx.save();
+            ctx.transform(1, 0, 0, 1, px, py);
 
             const bodyW = size * 0.8;
             const bodyH = size;
@@ -152,7 +153,7 @@ export class Lanterns extends Effect<LanternsConfig> {
             ctx.lineWidth = size * 0.04;
             ctx.stroke();
 
-            ctx.resetTransform();
+            ctx.restore();
         }
     }
 

package/src/lava/consts.ts

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

package/src/lava/index.ts

@@ -0,0 +1,9 @@
+import { Lava } from './layer';
+import type { LavaConfig } from './layer';
+import type { Effect } from '../effect';
+
+export function createLava(config?: LavaConfig): Effect<LavaConfig> {
+    return new Lava(config);
+}
+
+export type { LavaConfig };