@basmilius/sparkle 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1322 @@
+import { hexToRGB, mulberry32 } from "@basmilius/utils";
+//#region src/canvas.ts
+var LimitedFrameRateCanvas = class {
+	#canvas;
+	#context;
+	#frameRate;
+	#target;
+	#current = 0;
+	#delta = 0;
+	#frame = 0;
+	#now = 0;
+	#then = 0;
+	#ticks = 0;
+	#isStopped = true;
+	#height = 540;
+	#width = 960;
+	get canvas() {
+		return this.#canvas;
+	}
+	get context() {
+		return this.#context;
+	}
+	get delta() {
+		return this.#delta;
+	}
+	get deltaFactor() {
+		return this.#then === 0 ? 1 : this.#target / this.#delta;
+	}
+	get frameRate() {
+		return this.#frameRate;
+	}
+	get isSmall() {
+		return innerWidth < 991;
+	}
+	get isTicking() {
+		return !this.#isStopped;
+	}
+	get ticks() {
+		return this.#ticks;
+	}
+	get height() {
+		return this.#height;
+	}
+	get width() {
+		return this.#width;
+	}
+	constructor(canvas, frameRate, options = { colorSpace: "display-p3" }) {
+		this.#canvas = canvas;
+		this.#context = canvas.getContext("2d", options);
+		this.#frameRate = frameRate;
+		this.#target = 1e3 / frameRate;
+		this.onVisibilityChange = this.onVisibilityChange.bind(this);
+		this.onResize = this.onResize.bind(this);
+		document.addEventListener("visibilitychange", this.onVisibilityChange, { passive: true });
+		window.addEventListener("resize", this.onResize, { passive: true });
+	}
+	loop() {
+		if (this.#isStopped) return;
+		this.#current = Date.now();
+		this.#frame = requestAnimationFrame(this.loop.bind(this));
+		if (this.#then > 0 && this.#current - this.#then + 1 < this.#target) return;
+		this.#now = this.#current;
+		this.#delta = this.#now - this.#then;
+		++this.#ticks;
+		this.tick();
+		this.draw();
+		this.#then = this.#now;
+	}
+	start() {
+		this.onResize();
+		this.#isStopped = false;
+		this.#frame = requestAnimationFrame(this.loop.bind(this));
+	}
+	stop() {
+		this.#isStopped = true;
+		cancelAnimationFrame(this.#frame);
+	}
+	draw() {
+		throw new Error("LimitedFrameRateCanvas::draw() should be overwritten.");
+	}
+	tick() {
+		throw new Error("LimitedFrameRateCanvas::tick() should be overwritten.");
+	}
+	destroy() {
+		this.stop();
+		document.removeEventListener("visibilitychange", this.onVisibilityChange);
+		window.removeEventListener("resize", this.onResize);
+	}
+	onResize() {
+		const { width, height } = this.#canvas.getBoundingClientRect();
+		this.#height = height;
+		this.#width = width;
+	}
+	onVisibilityChange() {
+		cancelAnimationFrame(this.#frame);
+		if (document.visibilityState === "visible") {
+			this.#then = 0;
+			this.start();
+		} else {
+			this.#then = 0;
+			this.stop();
+		}
+	}
+};
+//#endregion
+//#region src/confetti/consts.ts
+const DEFAULT_CONFIG = {
+	angle: 90,
+	colors: [
+		"#26ccff",
+		"#a25afd",
+		"#ff5e7e",
+		"#88ff5a",
+		"#fcff42",
+		"#ffa62d",
+		"#ff36ff"
+	],
+	decay: .9,
+	gravity: 1,
+	particles: 50,
+	shapes: [
+		"circle",
+		"diamond",
+		"ribbon",
+		"square",
+		"star",
+		"triangle"
+	],
+	spread: 45,
+	ticks: 200,
+	startVelocity: 45,
+	x: .5,
+	y: .5
+};
+const MULBERRY$2 = mulberry32(13);
+//#endregion
+//#region src/confetti/simulation.ts
+const TWO_PI = Math.PI * 2;
+const SHAPE_PATHS = {
+	circle: (() => {
+		const path = new Path2D();
+		path.ellipse(0, 0, .6, 1, 0, 0, TWO_PI);
+		return path;
+	})(),
+	diamond: (() => {
+		const path = new Path2D();
+		path.moveTo(0, -1);
+		path.lineTo(.6, 0);
+		path.lineTo(0, 1);
+		path.lineTo(-.6, 0);
+		path.closePath();
+		return path;
+	})(),
+	ribbon: (() => {
+		const path = new Path2D();
+		path.rect(-.2, -1, .4, 2);
+		return path;
+	})(),
+	square: (() => {
+		const path = new Path2D();
+		path.rect(-.7, -.7, 1.4, 1.4);
+		return path;
+	})(),
+	star: (() => {
+		const path = new Path2D();
+		for (let i = 0; i < 10; i++) {
+			const r = i % 2 === 0 ? 1 : .42;
+			const angle = i * Math.PI / 5 - Math.PI / 2;
+			if (i === 0) path.moveTo(r * Math.cos(angle), r * Math.sin(angle));
+			else path.lineTo(r * Math.cos(angle), r * Math.sin(angle));
+		}
+		path.closePath();
+		return path;
+	})(),
+	triangle: (() => {
+		const path = new Path2D();
+		for (let i = 0; i < 3; i++) {
+			const angle = i * 2 * Math.PI / 3 - Math.PI / 2;
+			if (i === 0) path.moveTo(Math.cos(angle), Math.sin(angle));
+			else path.lineTo(Math.cos(angle), Math.sin(angle));
+		}
+		path.closePath();
+		return path;
+	})()
+};
+var ConfettiSimulation = class extends LimitedFrameRateCanvas {
+	#scale;
+	#particles = [];
+	constructor(canvas, config = {}) {
+		super(canvas, 60, config.canvasOptions ?? { colorSpace: "display-p3" });
+		this.#scale = config.scale ?? 1;
+		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%";
+	}
+	fire(config) {
+		this.onResize();
+		this.draw();
+		const resolved = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		const { angle, colors, decay, gravity, shapes, spread, startVelocity, ticks, x, y } = resolved;
+		const numberOfParticles = Math.max(1, resolved.particles);
+		for (let i = 0; i < numberOfParticles; i++) {
+			const particle = this.#createParticle({
+				angle,
+				color: hexToRGB(colors[Math.floor(MULBERRY$2.next() * colors.length)]),
+				decay,
+				gravity: gravity * this.#scale,
+				shape: shapes[Math.floor(MULBERRY$2.next() * shapes.length)],
+				spread,
+				startVelocity: startVelocity * this.#scale,
+				ticks,
+				x: this.width * x,
+				y: this.height * y
+			});
+			this.#tickParticle(particle);
+			this.#particles.push(particle);
+		}
+		if (!this.isTicking) this.start();
+	}
+	draw() {
+		const { context, width, height } = this;
+		context.clearRect(0, 0, width, height);
+		const particles = this.#particles;
+		for (let i = 0; i < particles.length; i++) {
+			const p = particles[i];
+			const flipCos = Math.cos(p.flipAngle);
+			const size = p.size;
+			context.setTransform(p.rotCos * flipCos * size, p.rotSin * flipCos * size, -p.rotSin * size, p.rotCos * size, p.x, p.y);
+			context.globalAlpha = 1 - p.tick / p.totalTicks;
+			context.fillStyle = p.colorStr;
+			context.fill(SHAPE_PATHS[p.shape]);
+		}
+		context.resetTransform();
+	}
+	tick() {
+		const particles = this.#particles;
+		let alive = 0;
+		const dt = this.delta > 0 && this.delta < 200 ? this.delta / (1e3 / 60) : 1;
+		for (let i = 0; i < particles.length; i++) {
+			const p = particles[i];
+			if (p.tick < p.totalTicks) {
+				this.#tickParticle(p, dt);
+				particles[alive++] = p;
+			}
+		}
+		particles.length = alive;
+		if (alive === 0) this.stop();
+	}
+	onResize() {
+		super.onResize();
+		this.canvas.width = this.width;
+		this.canvas.height = this.height;
+	}
+	#createParticle(config) {
+		const launchAngle = -(config.angle * Math.PI / 180) + .5 * config.spread * Math.PI / 180 - MULBERRY$2.next() * config.spread * Math.PI / 180;
+		const speed = config.startVelocity * (.5 + MULBERRY$2.next());
+		const rotAngle = MULBERRY$2.next() * TWO_PI;
+		return {
+			colorStr: `rgb(${config.color[0]}, ${config.color[1]}, ${config.color[2]})`,
+			decay: config.decay - .05 + MULBERRY$2.next() * .1,
+			flipAngle: MULBERRY$2.next() * TWO_PI,
+			flipSpeed: .03 + MULBERRY$2.next() * .05,
+			gravity: config.gravity,
+			rotAngle,
+			rotCos: Math.cos(rotAngle),
+			rotSin: Math.sin(rotAngle),
+			rotSpeed: (MULBERRY$2.next() - .5) * .06,
+			shape: config.shape,
+			size: (5 + MULBERRY$2.next() * 5) * this.#scale,
+			swing: MULBERRY$2.next() * TWO_PI,
+			swingAmp: .5 + MULBERRY$2.next() * 1.5,
+			swingSpeed: .025 + MULBERRY$2.next() * .035,
+			tick: 0,
+			totalTicks: config.ticks,
+			vx: Math.cos(launchAngle) * speed,
+			vy: Math.sin(launchAngle) * speed,
+			x: config.x,
+			y: config.y
+		};
+	}
+	#tickParticle(particle, dt = 1) {
+		const decayFactor = Math.pow(particle.decay, dt);
+		particle.vx *= decayFactor;
+		particle.vy *= decayFactor;
+		particle.vy += particle.gravity * .35 * dt;
+		particle.swing += particle.swingSpeed * dt;
+		particle.x += (particle.vx + particle.swingAmp * Math.cos(particle.swing)) * dt;
+		particle.y += particle.vy * dt;
+		particle.rotAngle += particle.rotSpeed * dt;
+		particle.rotCos = Math.cos(particle.rotAngle);
+		particle.rotSin = Math.sin(particle.rotAngle);
+		particle.flipAngle += particle.flipSpeed * dt;
+		particle.tick += dt;
+	}
+};
+//#endregion
+//#region src/fireworks/consts.ts
+const MULBERRY$1 = mulberry32(13);
+//#endregion
+//#region src/fireworks/types.ts
+const FIREWORK_VARIANTS = [
+	"peony",
+	"chrysanthemum",
+	"willow",
+	"ring",
+	"palm",
+	"crackle",
+	"crossette",
+	"saturn",
+	"dahlia",
+	"brocade",
+	"horsetail",
+	"strobe",
+	"heart",
+	"spiral",
+	"flower",
+	"concentric"
+];
+const EXPLOSION_CONFIGS = {
+	peony: {
+		particleCount: [50, 70],
+		speed: [2, 10],
+		friction: .96,
+		gravity: .8,
+		decay: [.012, .025],
+		trailMemory: 3,
+		hueVariation: 30,
+		brightness: [50, 80],
+		lineWidthScale: .8,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: true,
+		glowSize: 12
+	},
+	chrysanthemum: {
+		particleCount: [80, 120],
+		speed: [3, 12],
+		friction: .975,
+		gravity: .5,
+		decay: [.006, .012],
+		trailMemory: 6,
+		hueVariation: 20,
+		brightness: [55, 85],
+		lineWidthScale: .5,
+		shape: "line",
+		sparkle: true,
+		strobe: false,
+		spread3d: true,
+		glowSize: 15
+	},
+	willow: {
+		particleCount: [50, 70],
+		speed: [3, 10],
+		friction: .988,
+		gravity: 1.5,
+		decay: [.004, .008],
+		trailMemory: 10,
+		hueVariation: 15,
+		brightness: [60, 90],
+		lineWidthScale: .4,
+		shape: "line",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 10
+	},
+	ring: {
+		particleCount: [40, 60],
+		speed: [6, 8],
+		friction: .96,
+		gravity: .4,
+		decay: [.012, .022],
+		trailMemory: 4,
+		hueVariation: 10,
+		brightness: [55, 80],
+		lineWidthScale: .7,
+		shape: "diamond",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 14
+	},
+	palm: {
+		particleCount: [20, 30],
+		speed: [5, 12],
+		friction: .97,
+		gravity: 1.2,
+		decay: [.006, .014],
+		trailMemory: 6,
+		hueVariation: 20,
+		brightness: [55, 85],
+		lineWidthScale: .6,
+		shape: "line",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 12
+	},
+	crackle: {
+		particleCount: [40, 55],
+		speed: [2, 8],
+		friction: .955,
+		gravity: .8,
+		decay: [.012, .025],
+		trailMemory: 2,
+		hueVariation: 25,
+		brightness: [60, 90],
+		lineWidthScale: .6,
+		shape: "star",
+		sparkle: false,
+		strobe: false,
+		spread3d: true,
+		glowSize: 8
+	},
+	crossette: {
+		particleCount: [16, 20],
+		speed: [5, 9],
+		friction: .965,
+		gravity: .6,
+		decay: [.006, .014],
+		trailMemory: 4,
+		hueVariation: 15,
+		brightness: [55, 85],
+		lineWidthScale: .7,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: true,
+		glowSize: 12
+	},
+	dahlia: {
+		particleCount: [48, 80],
+		speed: [3, 9],
+		friction: .965,
+		gravity: .7,
+		decay: [.01, .02],
+		trailMemory: 4,
+		hueVariation: 5,
+		brightness: [55, 85],
+		lineWidthScale: .7,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: true,
+		glowSize: 12
+	},
+	brocade: {
+		particleCount: [60, 80],
+		speed: [3, 9],
+		friction: .98,
+		gravity: 1.3,
+		decay: [.004, .01],
+		trailMemory: 10,
+		hueVariation: 10,
+		brightness: [60, 90],
+		lineWidthScale: .4,
+		shape: "line",
+		sparkle: true,
+		strobe: false,
+		spread3d: false,
+		glowSize: 10
+	},
+	horsetail: {
+		particleCount: [30, 40],
+		speed: [8, 14],
+		friction: .975,
+		gravity: 2,
+		decay: [.004, .01],
+		trailMemory: 12,
+		hueVariation: 15,
+		brightness: [60, 90],
+		lineWidthScale: .5,
+		shape: "line",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 10
+	},
+	strobe: {
+		particleCount: [40, 55],
+		speed: [2, 8],
+		friction: .96,
+		gravity: .7,
+		decay: [.01, .02],
+		trailMemory: 2,
+		hueVariation: 10,
+		brightness: [75, 95],
+		lineWidthScale: .6,
+		shape: "circle",
+		sparkle: false,
+		strobe: true,
+		spread3d: true,
+		glowSize: 10
+	},
+	heart: {
+		particleCount: [60, 80],
+		speed: [3, 5],
+		friction: .965,
+		gravity: .3,
+		decay: [.008, .016],
+		trailMemory: 4,
+		hueVariation: 15,
+		brightness: [55, 85],
+		lineWidthScale: .7,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 12
+	},
+	spiral: {
+		particleCount: [45, 60],
+		speed: [2, 10],
+		friction: .97,
+		gravity: .4,
+		decay: [.008, .016],
+		trailMemory: 5,
+		hueVariation: 10,
+		brightness: [55, 85],
+		lineWidthScale: .6,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 12
+	},
+	flower: {
+		particleCount: [70, 90],
+		speed: [3, 7],
+		friction: .965,
+		gravity: .3,
+		decay: [.008, .016],
+		trailMemory: 4,
+		hueVariation: 20,
+		brightness: [55, 85],
+		lineWidthScale: .7,
+		shape: "circle",
+		sparkle: false,
+		strobe: false,
+		spread3d: false,
+		glowSize: 12
+	}
+};
+//#endregion
+//#region src/fireworks/explosion.ts
+const PERSPECTIVE = 800;
+var Explosion = class {
+	#position;
+	#angle;
+	#brightness;
+	#config;
+	#decay;
+	#hue;
+	#lineWidth;
+	#shape;
+	#trail = [];
+	#type;
+	#alpha = 1;
+	#depthScale = 1;
+	#hasCrackled = false;
+	#hasSplit = false;
+	#speed;
+	#sparkleTimer = 0;
+	#vz;
+	#z = 0;
+	get angle() {
+		return this.#angle;
+	}
+	get hue() {
+		return this.#hue;
+	}
+	get isDead() {
+		return this.#alpha <= 0;
+	}
+	get position() {
+		return this.#position;
+	}
+	get type() {
+		return this.#type;
+	}
+	constructor(position, hue, lineWidth, type, scale = 1, angle, speed, vz) {
+		const config = EXPLOSION_CONFIGS[type];
+		this.#config = config;
+		this.#type = type;
+		this.#shape = config.shape;
+		this.#position = { ...position };
+		this.#alpha = 1;
+		this.#angle = angle ?? MULBERRY$1.nextBetween(0, Math.PI * 2);
+		this.#brightness = MULBERRY$1.nextBetween(config.brightness[0], config.brightness[1]);
+		this.#decay = MULBERRY$1.nextBetween(config.decay[0], config.decay[1]);
+		this.#hue = hue + MULBERRY$1.nextBetween(-config.hueVariation, config.hueVariation);
+		this.#lineWidth = lineWidth * config.lineWidthScale;
+		this.#speed = (speed ?? MULBERRY$1.nextBetween(config.speed[0], config.speed[1])) * scale;
+		if (vz !== void 0) this.#vz = vz * scale;
+		else if (config.spread3d) this.#vz = MULBERRY$1.nextBetween(-this.#speed * .5, this.#speed * .5);
+		else this.#vz = 0;
+		for (let i = 0; i < config.trailMemory; i++) this.#trail.push({ ...position });
+	}
+	checkCrackle() {
+		if (this.#type !== "crackle" || this.#hasCrackled) return false;
+		if (this.#alpha <= this.#decay * 3) {
+			this.#hasCrackled = true;
+			return true;
+		}
+		return false;
+	}
+	checkSplit() {
+		if (this.#type !== "crossette" || this.#hasSplit) return false;
+		if (this.#alpha < .5) {
+			this.#hasSplit = true;
+			return true;
+		}
+		return false;
+	}
+	draw(ctx) {
+		if (this.#config.strobe && this.#sparkleTimer % 6 < 3) return;
+		const ds = this.#depthScale;
+		const trailEnd = this.#trail[this.#trail.length - 1];
+		const effectiveWidth = this.#shape === "line" ? this.#lineWidth * ds : this.#lineWidth * .4 * ds;
+		const effectiveAlpha = this.#alpha * Math.min(ds, 1.2);
+		ctx.save();
+		ctx.lineCap = "round";
+		if (this.#trail.length > 2) for (let i = this.#trail.length - 1; i > 0; i--) {
+			const progress = i / this.#trail.length;
+			const alpha = (1 - progress) * effectiveAlpha * .5;
+			const width = effectiveWidth * (1 - progress * .4);
+			ctx.beginPath();
+			ctx.moveTo(this.#trail[i].x, this.#trail[i].y);
+			ctx.lineTo(this.#trail[i - 1].x, this.#trail[i - 1].y);
+			ctx.lineWidth = width;
+			ctx.strokeStyle = `hsla(${this.#hue}, 100%, ${this.#brightness * .7}%, ${alpha})`;
+			ctx.stroke();
+		}
+		ctx.beginPath();
+		ctx.moveTo(trailEnd.x, trailEnd.y);
+		ctx.lineTo(this.#position.x, this.#position.y);
+		ctx.lineWidth = effectiveWidth;
+		ctx.strokeStyle = `hsla(${this.#hue}, 100%, ${this.#brightness}%, ${effectiveAlpha})`;
+		ctx.stroke();
+		if (this.#shape !== "line") this.#drawShape(ctx, ds, effectiveAlpha);
+		if (this.#config.sparkle && this.#sparkleTimer % 4 < 2) {
+			ctx.beginPath();
+			ctx.arc(this.#position.x, this.#position.y, this.#lineWidth * .8 * ds, 0, Math.PI * 2);
+			ctx.fillStyle = `hsla(${this.#hue}, 30%, 95%, ${effectiveAlpha * .9})`;
+			ctx.fill();
+		}
+		ctx.restore();
+	}
+	tick() {
+		this.#trail.pop();
+		this.#trail.unshift({ ...this.#position });
+		this.#speed *= this.#config.friction;
+		this.#vz *= this.#config.friction;
+		this.#position.x += Math.cos(this.#angle) * this.#speed;
+		this.#position.y += Math.sin(this.#angle) * this.#speed + this.#config.gravity;
+		this.#z += this.#vz;
+		this.#depthScale = PERSPECTIVE / (PERSPECTIVE + this.#z);
+		this.#alpha -= this.#decay;
+		this.#sparkleTimer++;
+	}
+	#drawShape(ctx, ds, alpha) {
+		const size = this.#lineWidth * 1.2 * ds;
+		const color = `hsla(${this.#hue}, 100%, ${this.#brightness}%, ${alpha})`;
+		switch (this.#shape) {
+			case "circle":
+				ctx.beginPath();
+				ctx.arc(this.#position.x, this.#position.y, size * .5, 0, Math.PI * 2);
+				ctx.fillStyle = color;
+				ctx.fill();
+				break;
+			case "star":
+				this.#drawStarPath(ctx, this.#position.x, this.#position.y, size * .7, 4, this.#sparkleTimer * .15);
+				ctx.fillStyle = `hsla(${this.#hue}, 60%, ${Math.min(this.#brightness + 10, 100)}%, ${alpha})`;
+				ctx.fill();
+				break;
+			case "diamond":
+				this.#drawDiamondPath(ctx, this.#position.x, this.#position.y, size * .6, this.#angle);
+				ctx.fillStyle = color;
+				ctx.fill();
+				break;
+		}
+	}
+	#drawStarPath(ctx, cx, cy, radius, points, rotation) {
+		const innerRadius = radius * .4;
+		const totalPoints = points * 2;
+		ctx.beginPath();
+		for (let i = 0; i < totalPoints; i++) {
+			const r = i % 2 === 0 ? radius : innerRadius;
+			const angle = i * Math.PI / points + rotation;
+			const px = cx + Math.cos(angle) * r;
+			const py = cy + Math.sin(angle) * r;
+			if (i === 0) ctx.moveTo(px, py);
+			else ctx.lineTo(px, py);
+		}
+		ctx.closePath();
+	}
+	#drawDiamondPath(ctx, cx, cy, size, rotation) {
+		const cos = Math.cos(rotation);
+		const sin = Math.sin(rotation);
+		const hw = size * .5;
+		ctx.beginPath();
+		ctx.moveTo(cx + cos * size - sin * 0, cy + sin * size + cos * 0);
+		ctx.lineTo(cx + cos * 0 - sin * hw, cy + sin * 0 + cos * hw);
+		ctx.lineTo(cx + cos * -size - sin * 0, cy + sin * -size + cos * 0);
+		ctx.lineTo(cx + cos * 0 - sin * -hw, cy + sin * 0 + cos * -hw);
+		ctx.closePath();
+	}
+};
+//#endregion
+//#region src/distance.ts
+function distance(a, b) {
+	let x = a.x - b.x;
+	let y = a.y - b.y;
+	return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+}
+//#endregion
+//#region src/fireworks/spark.ts
+var Spark = class {
+	#position;
+	#velocity;
+	#hue;
+	#size;
+	#decay;
+	#friction = .94;
+	#gravity = .6;
+	#alpha = 1;
+	get isDead() {
+		return this.#alpha <= 0;
+	}
+	get position() {
+		return this.#position;
+	}
+	constructor(position, hue, velocityX = 0, velocityY = 0) {
+		this.#position = { ...position };
+		this.#hue = hue + MULBERRY$1.nextBetween(-20, 20);
+		this.#size = MULBERRY$1.nextBetween(.5, 1.5);
+		this.#decay = MULBERRY$1.nextBetween(.03, .08);
+		this.#velocity = {
+			x: velocityX + MULBERRY$1.nextBetween(-1.5, 1.5),
+			y: velocityY + MULBERRY$1.nextBetween(-2, .5)
+		};
+	}
+	draw(ctx) {
+		ctx.beginPath();
+		ctx.arc(this.#position.x, this.#position.y, this.#size, 0, Math.PI * 2);
+		ctx.fillStyle = `hsla(${this.#hue}, 80%, 70%, ${this.#alpha})`;
+		ctx.fill();
+	}
+	tick() {
+		this.#velocity.x *= this.#friction;
+		this.#velocity.y *= this.#friction;
+		this.#velocity.y += this.#gravity;
+		this.#position.x += this.#velocity.x;
+		this.#position.y += this.#velocity.y;
+		this.#alpha -= this.#decay;
+	}
+};
+//#endregion
+//#region src/fireworks/firework.ts
+var Firework = class extends EventTarget {
+	#position;
+	#startPosition;
+	#acceleration = 1.05;
+	#angle;
+	#baseSize;
+	#brightness = MULBERRY$1.nextBetween(55, 75);
+	#distance;
+	#hue;
+	#tailWidth;
+	#trail = [];
+	#distanceTraveled = 0;
+	#speed = 1;
+	#sparkTimer = 0;
+	#pendingSparks = [];
+	get position() {
+		return this.#position;
+	}
+	get hue() {
+		return this.#hue;
+	}
+	constructor(start, target, hue, tailWidth, baseSize) {
+		super();
+		this.#hue = hue;
+		this.#tailWidth = tailWidth;
+		this.#baseSize = baseSize;
+		this.#position = { ...start };
+		this.#startPosition = { ...start };
+		this.#angle = Math.atan2(target.y - start.y, target.x - start.x);
+		this.#distance = distance(start, target);
+		for (let i = 0; i < 6; i++) this.#trail.push({ ...start });
+	}
+	collectSparks() {
+		const sparks = this.#pendingSparks;
+		this.#pendingSparks = [];
+		return sparks;
+	}
+	draw(ctx) {
+		ctx.save();
+		ctx.lineCap = "round";
+		for (let i = this.#trail.length - 1; i > 0; i--) {
+			const progress = i / this.#trail.length;
+			const alpha = (1 - progress) * .8;
+			const width = this.#tailWidth * (1 - progress * .5);
+			const hue = this.#hue + MULBERRY$1.nextBetween(-15, 15);
+			ctx.beginPath();
+			ctx.moveTo(this.#trail[i].x, this.#trail[i].y);
+			ctx.lineTo(this.#trail[i - 1].x, this.#trail[i - 1].y);
+			ctx.lineWidth = width;
+			ctx.strokeStyle = `hsla(${hue}, 100%, ${this.#brightness}%, ${alpha})`;
+			ctx.stroke();
+		}
+		ctx.shadowBlur = this.#baseSize * 4;
+		ctx.shadowColor = `hsl(${this.#hue}, 100%, 60%)`;
+		ctx.beginPath();
+		ctx.moveTo(this.#trail[0].x, this.#trail[0].y);
+		ctx.lineTo(this.#position.x, this.#position.y);
+		ctx.lineWidth = this.#tailWidth;
+		ctx.strokeStyle = `hsl(${this.#hue}, 100%, ${this.#brightness}%)`;
+		ctx.stroke();
+		ctx.shadowBlur = this.#baseSize * 6;
+		ctx.shadowColor = `hsl(${this.#hue}, 80%, 80%)`;
+		ctx.beginPath();
+		ctx.arc(this.#position.x, this.#position.y, this.#tailWidth * .6, 0, Math.PI * 2);
+		ctx.fillStyle = `hsl(${this.#hue}, 20%, 92%)`;
+		ctx.fill();
+		ctx.restore();
+	}
+	tick() {
+		this.#trail.pop();
+		this.#trail.unshift({ ...this.#position });
+		this.#speed *= this.#acceleration;
+		const vx = Math.cos(this.#angle) * this.#speed;
+		const vy = Math.sin(this.#angle) * this.#speed;
+		this.#distanceTraveled = distance(this.#startPosition, {
+			x: this.#position.x + vx,
+			y: this.#position.y + vy
+		});
+		if (this.#distanceTraveled >= this.#distance) {
+			this.dispatchEvent(new CustomEvent("remove"));
+			return;
+		}
+		this.#position.x += vx;
+		this.#position.y += vy;
+		this.#sparkTimer++;
+		if (this.#sparkTimer % 3 === 0) this.#pendingSparks.push(new Spark(this.#position, this.#hue, -vx * .1, -vy * .1));
+	}
+};
+//#endregion
+//#region src/fireworks/simulation.ts
+var FireworkSimulation = class extends LimitedFrameRateCanvas {
+	#explosions = [];
+	#fireworks = [];
+	#sparks = [];
+	#hue = 120;
+	#positionRandom = MULBERRY$1.fork();
+	#autoSpawn;
+	#baseSize;
+	#scale;
+	#tailWidth;
+	constructor(canvas, config = {}) {
+		super(canvas, 60, config.canvasOptions ?? { colorSpace: "display-p3" });
+		const scale = config.scale ?? 1;
+		this.#autoSpawn = config.autoSpawn ?? true;
+		this.#baseSize = 5 * scale;
+		this.#scale = scale;
+		this.#tailWidth = 2 * scale;
+		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%";
+	}
+	draw() {
+		if (this.canvas.width !== this.width || this.canvas.height !== this.height) {
+			this.canvas.width = this.width;
+			this.canvas.height = this.height;
+		}
+		this.context.clearRect(0, 0, this.width, this.height);
+		this.context.globalCompositeOperation = "lighter";
+		for (const spark of this.#sparks) spark.draw(this.context);
+		for (const explosion of this.#explosions) explosion.draw(this.context);
+		for (const firework of this.#fireworks) firework.draw(this.context);
+	}
+	fireExplosion(variant, position) {
+		const pos = position ?? {
+			x: this.width / 2,
+			y: this.height * .4
+		};
+		this.#hue = MULBERRY$1.nextBetween(0, 360);
+		this.#createExplosion(pos, this.#hue, variant);
+	}
+	tick() {
+		if (this.#autoSpawn && this.#fireworks.length < 6 && this.ticks % (this.isSmall ? 60 : 30) === 0) {
+			let count = MULBERRY$1.nextBetween(1, 100) < 10 ? 2 : 1;
+			while (count--) {
+				this.#hue = MULBERRY$1.nextBetween(0, 360);
+				this.#createFirework();
+			}
+		}
+		for (const firework of this.#fireworks) {
+			firework.tick();
+			this.#sparks.push(...firework.collectSparks());
+		}
+		for (const explosion of this.#explosions) explosion.tick();
+		for (const spark of this.#sparks) spark.tick();
+		const newExplosions = [];
+		const newSparks = [];
+		for (const explosion of this.#explosions) {
+			if (explosion.checkSplit()) for (let i = 0; i < 4; i++) {
+				const angle = explosion.angle + Math.PI / 2 * i + Math.PI / 4;
+				newExplosions.push(new Explosion(explosion.position, explosion.hue, this.#baseSize * .6, "peony", this.#scale, angle, MULBERRY$1.nextBetween(3, 6)));
+			}
+			if (explosion.checkCrackle()) for (let j = 0; j < 8; j++) newSparks.push(new Spark(explosion.position, explosion.hue + MULBERRY$1.nextBetween(-30, 30)));
+		}
+		this.#explosions.push(...newExplosions);
+		this.#sparks.push(...newSparks);
+		this.#explosions = this.#explosions.filter((e) => !e.isDead);
+		this.#sparks = this.#sparks.filter((s) => !s.isDead);
+	}
+	#createExplosion(position, hue, variant) {
+		const selected = variant ?? this.#pickVariant();
+		if (selected === "saturn") {
+			this.#createSaturnExplosion(position, hue);
+			return;
+		}
+		if (selected === "dahlia") {
+			this.#createDahliaExplosion(position, hue);
+			return;
+		}
+		if (selected === "heart") {
+			this.#createHeartExplosion(position, hue);
+			return;
+		}
+		if (selected === "spiral") {
+			this.#createSpiralExplosion(position, hue);
+			return;
+		}
+		if (selected === "flower") {
+			this.#createFlowerExplosion(position, hue);
+			return;
+		}
+		if (selected === "concentric") {
+			this.#createConcentricExplosion(position, hue);
+			return;
+		}
+		const type = selected;
+		const config = EXPLOSION_CONFIGS[type];
+		const particleCount = Math.floor(MULBERRY$1.nextBetween(config.particleCount[0], config.particleCount[1]));
+		const effectiveHue = type === "brocade" ? MULBERRY$1.nextBetween(35, 50) : hue;
+		for (let i = 0; i < particleCount; i++) {
+			let angle;
+			let speed;
+			if (type === "ring") {
+				angle = i / particleCount * Math.PI * 2;
+				speed = MULBERRY$1.nextBetween(config.speed[0], config.speed[1]) * .5 + config.speed[0] * .5;
+			} else if (type === "palm" || type === "horsetail") {
+				const spread = type === "horsetail" ? Math.PI / 8 : Math.PI / 5;
+				angle = -Math.PI / 2 + MULBERRY$1.nextBetween(-spread, spread);
+			}
+			this.#explosions.push(new Explosion(position, effectiveHue, this.#baseSize, type, this.#scale, angle, speed));
+		}
+	}
+	#createSaturnExplosion(position, hue) {
+		const velocity = MULBERRY$1.nextBetween(4, 6);
+		const shellCount = Math.floor(MULBERRY$1.nextBetween(25, 35));
+		for (let i = 0; i < shellCount; i++) {
+			const rad = i / shellCount * Math.PI * 2;
+			this.#explosions.push(new Explosion(position, hue, this.#baseSize, "peony", this.#scale, rad + MULBERRY$1.nextBetween(-.05, .05), velocity + MULBERRY$1.nextBetween(-.25, .25)));
+		}
+		const fillCount = Math.floor(MULBERRY$1.nextBetween(40, 60));
+		for (let i = 0; i < fillCount; i++) {
+			const rad = MULBERRY$1.nextBetween(0, Math.PI * 2);
+			const speed = velocity * MULBERRY$1.nextBetween(0, 1);
+			this.#explosions.push(new Explosion(position, hue, this.#baseSize, "peony", this.#scale, rad, speed));
+		}
+		const ringRotation = MULBERRY$1.nextBetween(0, Math.PI * 2);
+		const ringCount = Math.floor(MULBERRY$1.nextBetween(40, 55));
+		const ringVx = velocity * MULBERRY$1.nextBetween(2, 3);
+		const ringVy = velocity * .6;
+		for (let i = 0; i < ringCount; i++) {
+			const rad = i / ringCount * Math.PI * 2;
+			const cx = Math.cos(rad) * ringVx + MULBERRY$1.nextBetween(-.25, .25);
+			const cy = Math.sin(rad) * ringVy + MULBERRY$1.nextBetween(-.25, .25);
+			const cosR = Math.cos(ringRotation);
+			const sinR = Math.sin(ringRotation);
+			const vx = cx * cosR - cy * sinR;
+			const vy = cx * sinR + cy * cosR;
+			const screenAngle = Math.atan2(vy, vx);
+			const screenSpeed = Math.sqrt(vx * vx + vy * vy);
+			const vz = Math.sin(rad) * velocity * .8;
+			this.#explosions.push(new Explosion(position, hue + 60, this.#baseSize, "ring", this.#scale, screenAngle, screenSpeed, vz));
+		}
+	}
+	#createDahliaExplosion(position, hue) {
+		const petalCount = Math.floor(MULBERRY$1.nextBetween(6, 9));
+		const particlesPerPetal = Math.floor(MULBERRY$1.nextBetween(8, 12));
+		for (let petal = 0; petal < petalCount; petal++) {
+			const baseAngle = petal / petalCount * Math.PI * 2;
+			const petalHue = hue + (petal % 2 === 0 ? 25 : -25);
+			for (let i = 0; i < particlesPerPetal; i++) {
+				const angle = baseAngle + MULBERRY$1.nextBetween(-.3, .3);
+				this.#explosions.push(new Explosion(position, petalHue, this.#baseSize, "dahlia", this.#scale, angle));
+			}
+		}
+	}
+	#createHeartExplosion(position, hue) {
+		const velocity = MULBERRY$1.nextBetween(3, 5);
+		const count = Math.floor(MULBERRY$1.nextBetween(60, 80));
+		const rotation = MULBERRY$1.nextBetween(-.3, .3);
+		for (let i = 0; i < count; i++) {
+			const t = i / count * Math.PI * 2;
+			const hx = 16 * Math.pow(Math.sin(t), 3);
+			const hy = -(13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t));
+			const scale = velocity / 16;
+			const vx = hx * scale;
+			const vy = hy * scale;
+			const cosR = Math.cos(rotation);
+			const sinR = Math.sin(rotation);
+			const rvx = vx * cosR - vy * sinR;
+			const rvy = vx * sinR + vy * cosR;
+			const angle = Math.atan2(rvy, rvx);
+			const speed = Math.sqrt(rvx * rvx + rvy * rvy);
+			this.#explosions.push(new Explosion(position, hue, this.#baseSize, "heart", this.#scale, angle, Math.max(.1, speed + MULBERRY$1.nextBetween(-.15, .15))));
+		}
+	}
+	#createSpiralExplosion(position, hue) {
+		const arms = Math.floor(MULBERRY$1.nextBetween(3, 5));
+		const particlesPerArm = Math.floor(MULBERRY$1.nextBetween(15, 20));
+		const twist = MULBERRY$1.nextBetween(2, 3.5);
+		const baseRotation = MULBERRY$1.nextBetween(0, Math.PI * 2);
+		for (let arm = 0; arm < arms; arm++) {
+			const baseAngle = baseRotation + arm / arms * Math.PI * 2;
+			const armHue = hue + arm * (360 / arms / 3);
+			for (let i = 0; i < particlesPerArm; i++) {
+				const progress = i / particlesPerArm;
+				const angle = baseAngle + progress * twist;
+				const speed = 2 + progress * 8;
+				this.#explosions.push(new Explosion(position, armHue, this.#baseSize, "spiral", this.#scale, angle, speed + MULBERRY$1.nextBetween(-.3, .3)));
+			}
+		}
+	}
+	#createFlowerExplosion(position, hue) {
+		const velocity = MULBERRY$1.nextBetween(4, 7);
+		const count = Math.floor(MULBERRY$1.nextBetween(70, 90));
+		const petals = Math.floor(MULBERRY$1.nextBetween(2, 4));
+		const rotation = MULBERRY$1.nextBetween(0, Math.PI * 2);
+		for (let i = 0; i < count; i++) {
+			const t = i / count * Math.PI * 2;
+			const speed = velocity * Math.abs(Math.cos(petals * t));
+			if (speed < .3) continue;
+			this.#explosions.push(new Explosion(position, hue + MULBERRY$1.nextBetween(-15, 15), this.#baseSize, "flower", this.#scale, t + rotation, speed + MULBERRY$1.nextBetween(-.2, .2)));
+		}
+	}
+	#createConcentricExplosion(position, hue) {
+		const outerCount = Math.floor(MULBERRY$1.nextBetween(35, 50));
+		const outerSpeed = MULBERRY$1.nextBetween(7, 10);
+		for (let i = 0; i < outerCount; i++) {
+			const angle = i / outerCount * Math.PI * 2;
+			this.#explosions.push(new Explosion(position, hue, this.#baseSize, "ring", this.#scale, angle + MULBERRY$1.nextBetween(-.05, .05), outerSpeed + MULBERRY$1.nextBetween(-.25, .25)));
+		}
+		const innerCount = Math.floor(MULBERRY$1.nextBetween(25, 35));
+		const innerSpeed = MULBERRY$1.nextBetween(3, 5);
+		for (let i = 0; i < innerCount; i++) {
+			const angle = i / innerCount * Math.PI * 2;
+			this.#explosions.push(new Explosion(position, hue + 120, this.#baseSize, "ring", this.#scale, angle + MULBERRY$1.nextBetween(-.05, .05), innerSpeed + MULBERRY$1.nextBetween(-.25, .25)));
+		}
+	}
+	#createFirework(position) {
+		const hue = this.#hue;
+		const targetX = position?.x || this.#positionRandom.nextBetween(this.width * .1, this.width * .9);
+		const targetY = position?.y || this.height * .1 + this.#positionRandom.nextBetween(0, this.height * .5);
+		const firework = new Firework({
+			x: this.width * .3 + this.#positionRandom.nextBetween(0, this.width * .4),
+			y: this.height
+		}, {
+			x: targetX,
+			y: targetY
+		}, hue, this.#tailWidth, this.#baseSize);
+		firework.addEventListener("remove", () => {
+			this.#fireworks.splice(this.#fireworks.indexOf(firework), 1);
+			this.#createExplosion(firework.position, hue);
+		}, { once: true });
+		this.#fireworks.push(firework);
+	}
+	#pickVariant() {
+		const roll = MULBERRY$1.nextBetween(0, 100);
+		if (roll < 12) return "peony";
+		if (roll < 22) return "chrysanthemum";
+		if (roll < 29) return "willow";
+		if (roll < 34) return "ring";
+		if (roll < 39) return "palm";
+		if (roll < 44) return "crackle";
+		if (roll < 48) return "crossette";
+		if (roll < 55) return "saturn";
+		if (roll < 62) return "dahlia";
+		if (roll < 67) return "brocade";
+		if (roll < 71) return "horsetail";
+		if (roll < 75) return "strobe";
+		if (roll < 82) return "heart";
+		if (roll < 89) return "spiral";
+		if (roll < 94) return "flower";
+		return "concentric";
+	}
+};
+//#endregion
+//#region src/snow/consts.ts
+const MULBERRY = mulberry32(13);
+//#endregion
+//#region src/snow/simulation.ts
+const SPRITE_SIZE = 64;
+const SPRITE_CENTER = SPRITE_SIZE / 2;
+const SPRITE_RADIUS = SPRITE_SIZE / 2;
+var SnowSimulation = class extends LimitedFrameRateCanvas {
+	#scale;
+	#size;
+	#speed;
+	#baseOpacity;
+	#maxParticles;
+	#time = 0;
+	#ratio = 1;
+	#snowflakes = [];
+	#sprites = [];
+	constructor(canvas, config = {}) {
+		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() {
+		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 < .5) continue;
+			ctx.globalAlpha = this.#baseOpacity * (.15 + snowflake.depth * .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() {
+		const speedFactor = this.height / (420 * this.#ratio) / this.#speed * this.deltaFactor;
+		this.#time += .015 * speedFactor;
+		const wind = Math.sin(this.#time * .7) * .5 + Math.sin(this.#time * 1.9 + 3) * .25 + Math.sin(this.#time * 4.3 + 1) * .1;
+		for (let index = 0; index < this.#snowflakes.length; index++) {
+			const snowflake = this.#snowflakes[index];
+			const swing = Math.sin(this.#time * snowflake.swingFrequency + snowflake.swingOffset) * snowflake.swingAmplitude;
+			snowflake.x += (swing + wind * snowflake.depth * 2) / (4e3 * speedFactor);
+			snowflake.y += (snowflake.fallSpeed * 2 + snowflake.depth + snowflake.radius * .15) / (700 * speedFactor);
+			snowflake.rotation += snowflake.rotationSpeed / speedFactor;
+			if (snowflake.x > 1.15 || snowflake.x < -.15 || snowflake.y > 1.05) {
+				const recycled = this.#createSnowflake(false);
+				if (index % 3 > 0) {
+					recycled.x = MULBERRY.next();
+					recycled.y = -.05 - MULBERRY.next() * .15;
+				} else if (wind > .2) {
+					recycled.x = -.15;
+					recycled.y = MULBERRY.next() * .8;
+				} else if (wind < -.2) {
+					recycled.x = 1.15;
+					recycled.y = MULBERRY.next() * .8;
+				} else {
+					recycled.x = MULBERRY.next();
+					recycled.y = -.05 - MULBERRY.next() * .15;
+				}
+				this.#snowflakes[index] = recycled;
+			}
+		}
+	}
+	#parseColor(fillStyle) {
+		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, g, b) {
+		const sprites = [];
+		for (const profile of [
+			[
+				[0, .8],
+				[.3, .4],
+				[.7, .1],
+				[1, 0]
+			],
+			[
+				[0, 1],
+				[.15, .7],
+				[.5, .2],
+				[1, 0]
+			],
+			[
+				[0, .9],
+				[.25, .5],
+				[.5, .1],
+				[1, 0]
+			]
+		]) {
+			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);
+		}
+		sprites.push(this.#createCrystalSprite(r, g, b));
+		return sprites;
+	}
+	#createCrystalSprite(r, g, b) {
+		const canvas = document.createElement("canvas");
+		canvas.width = SPRITE_SIZE;
+		canvas.height = SPRITE_SIZE;
+		const ctx = canvas.getContext("2d");
+		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(.25, `rgba(${r}, ${g}, ${b}, 0.25)`);
+		glow.addColorStop(.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();
+		ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, 0.7)`;
+		ctx.lineWidth = 1.5;
+		ctx.lineCap = "round";
+		const armLength = SPRITE_RADIUS * .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;
+			ctx.beginPath();
+			ctx.moveTo(SPRITE_CENTER, SPRITE_CENTER);
+			ctx.lineTo(tipX, tipY);
+			ctx.stroke();
+			for (const position of [.4, .65]) {
+				const branchX = SPRITE_CENTER + Math.cos(angle) * armLength * position;
+				const branchY = SPRITE_CENTER + Math.sin(angle) * armLength * position;
+				const branchLength = armLength * (.4 - position * .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();
+				}
+			}
+		}
+		const centerGlow = ctx.createRadialGradient(SPRITE_CENTER, SPRITE_CENTER, 0, SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * .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 * .12, 0, Math.PI * 2);
+		ctx.fill();
+		return canvas;
+	}
+	#createSnowflake(initialSpread) {
+		const depth = .3 + MULBERRY.next() * .7;
+		const radius = MULBERRY.next() * this.#size + 2 * this.#scale;
+		let spriteIndex;
+		if (depth > .85 && radius > this.#size * .6 && MULBERRY.next() > .65) spriteIndex = 3;
+		else if (depth < .45) spriteIndex = 2;
+		else spriteIndex = MULBERRY.next() > .5 ? 0 : 1;
+		return {
+			x: MULBERRY.next(),
+			y: initialSpread ? MULBERRY.next() * 2 - 1 : -.05 - MULBERRY.next() * .15,
+			depth,
+			radius,
+			rotation: MULBERRY.next() * Math.PI * 2,
+			rotationSpeed: (MULBERRY.next() - .5) * .03,
+			swingAmplitude: .3 + MULBERRY.next() * .7,
+			swingFrequency: .5 + MULBERRY.next() * 1.5,
+			swingOffset: MULBERRY.next() * Math.PI * 2,
+			fallSpeed: .5 + MULBERRY.next() * .5,
+			spriteIndex
+		};
+	}
+};
+//#endregion
+export { ConfettiSimulation, FIREWORK_VARIANTS, FireworkSimulation, LimitedFrameRateCanvas, SnowSimulation };
+
+//# sourceMappingURL=index.mjs.map