celebrate-js 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2025 akshaywritescode
+
+Permission is hereby granted,
+free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,338 @@
+# celebrate-js 🎉
+
+A lightweight, zero-dependency JavaScript library to add beautiful celebration effects to your website - confetti, fireworks, balloons, emoji rain, and more.
+
+Perfect for success screens, onboarding, achievements, or fun UI moments.
+
+---
+
+## Features
+
+- Multiple celebration effects
+- Customizable colors 🎨
+- Built-in and custom sound support
+- Lightweight and fast
+- Simple API
+- TypeScript support
+- Optional reduced-motion support
+
+---
+
+## Installation
+
+```bash
+npm install celebrate-js
+```
+
+or
+
+```bash
+yarn add celebrate-js
+```
+
+---
+
+## Usage
+
+```js
+import { celebrate } from "celebrate-js";
+
+// Default: confetti
+celebrate();
+
+// Use a specific effect
+celebrate.confetti();
+celebrate.balloons({ particleCount: 20 });
+celebrate.fireworks({ count: 6 });
+celebrate.stars({ sound: true });
+celebrate.popper({ sound: "/sounds/success.mp3" });
+```
+
+---
+
+## Effects
+
+### Confetti
+
+Small flat squares falling from the top of the screen.
+
+```js
+celebrate.confetti({
+  duration: 2000,
+  particleCount: 150,
+  colors: ["#4285F4", "#34A853", "#FBBC05", "#EA4335"],
+  sound: true
+});
+```
+
+You can change:
+
+- `duration` - how long the animation runs
+- `particleCount` - number of pieces
+- `colors` - colors used per piece
+- `sound` - built-in chime or custom audio path
+
+### Balloons
+
+Flat balloons rising from the bottom of the screen.
+
+```js
+celebrate.balloons({
+  duration: 3000,
+  particleCount: 20,
+  colors: ["#4285F4", "#34A853", "#FBBC05", "#EA4335"],
+  sound: true
+});
+```
+
+You can change:
+
+- `duration` - how long balloons keep rising
+- `particleCount` - number of balloons
+- `colors` - colors used per balloon
+- `sound` - built-in chime or custom audio path
+
+### Popper
+
+Confetti bursts from both bottom sides of the screen.
+
+```js
+celebrate.popper({
+  duration: 3200,
+  particleCount: 120,
+  colors: ["#4285F4", "#34A853", "#FBBC05", "#EA4335"],
+  sound: "/sounds/success.mp3"
+});
+```
+
+You can change:
+
+- `duration` - how long the burst runs
+- `particleCount` - number of particles
+- `colors` - colors used per particle
+- `sound` - built-in chime or custom audio path
+
+### Fireworks
+
+Circular bursts that appear across the upper half of the screen.
+
+```js
+celebrate.fireworks({
+  duration: 4000,
+  count: 5,
+  interval: 500,
+  colors: ["#4285F4", "#34A853", "#FBBC05", "#EA4335"]
+});
+```
+
+You can change:
+
+- `duration` - total animation time
+- `count` - number of bursts
+- `interval` - delay between bursts in milliseconds
+- `colors` - colors used per burst
+- `sound` - built-in chime or custom audio path
+
+### Bubbles
+
+Soft bubbles floating upward.
+
+```js
+celebrate.bubbles({
+  duration: 3000,
+  particleCount: 25
+});
+```
+
+You can change:
+
+- `duration` - how long bubbles keep floating
+- `particleCount` - number of bubbles
+- `sound` - built-in chime or custom audio path
+
+### Emojis
+
+Emoji rain falling from the top of the screen.
+
+```js
+celebrate.emojis({
+  duration: 3000,
+  particleCount: 30,
+  emojis: ["🎉", "✨", "🔥", "💯", "😍"]
+});
+```
+
+You can change:
+
+- `duration` - how long emojis fall
+- `particleCount` - number of emojis
+- `emojis` - custom emoji list
+- `sound` - built-in chime or custom audio path
+
+### Stars
+
+Shooting stars crossing the screen.
+
+```js
+celebrate.stars({
+  duration: 3000,
+  count: 5,
+  interval: 500
+});
+```
+
+You can change:
+
+- `duration` - total animation time
+- `count` - number of shooting stars
+- `interval` - delay between stars in milliseconds
+- `sound` - built-in chime or custom audio path
+
+### Snowfall
+
+Light snow falling from the top of the screen.
+
+```js
+celebrate.snowfall({
+  duration: 5000,
+  particleCount: 60
+});
+```
+
+You can change:
+
+- `duration` - how long snow keeps falling
+- `particleCount` - number of flakes
+- `sound` - built-in chime or custom audio path
+
+## API
+
+### celebrate(options?)
+
+```js
+celebrate({
+  effect: "confetti",
+  duration: 5000,
+  particleCount: 100,
+  colors: ["#ff0", "#0ff"],
+  sound: true,
+  soundVolume: 0.35
+});
+```
+
+---
+
+## Shortcuts
+
+```js
+celebrate.confetti(options);
+celebrate.balloons(options);
+celebrate.popper(options);
+celebrate.fireworks(options);
+celebrate.bubbles(options);
+celebrate.emojis(options);
+celebrate.stars(options);
+celebrate.snowfall(options);
+```
+
+---
+
+## Options
+
+```ts
+type CelebrateOptions = {
+  effect?: "confetti" | "balloons" | "popper" | "fireworks" | "bubbles" | "emojis" | "stars" | "snowfall";
+  duration?: number;
+  particleCount?: number;
+
+  /**
+   * Colors used by supported effects (confetti, balloons, fireworks, popper, stars)
+   */
+  colors?: string[];
+
+  respectReducedMotion?: boolean;
+  sound?: boolean | string;
+  soundVolume?: number;
+
+  // Fireworks only
+  count?: number;
+  interval?: number;
+
+  // Emoji rain only
+  emojis?: string[];
+};
+```
+
+Defaults use a modern flat Google-style palette:
+
+```js
+["#4285F4", "#34A853", "#FBBC05", "#EA4335"]
+```
+
+---
+
+## Sound
+
+Sound works with every effect and is off by default.
+
+Use the built-in completion chime:
+
+```js
+celebrate.balloons({
+  sound: true
+});
+```
+
+Use your own audio file by passing a path or URL:
+
+```js
+celebrate.balloons({
+  sound: "/sounds/success.mp3"
+});
+```
+
+In Vite, files inside `public/` are served from the root:
+
+```text
+public/success.mp3 -> /success.mp3
+```
+
+Adjust volume:
+
+```js
+celebrate.fireworks({
+  sound: "/sounds/success.mp3",
+  soundVolume: 0.2
+});
+```
+
+Sound is off by default. Browsers usually require sound to start from a user action, like a button click.
+
+---
+
+## Reduced Motion
+
+If `respectReducedMotion` is enabled and the user has `prefers-reduced-motion` set,
+animations will be skipped.
+
+```js
+celebrate({
+  respectReducedMotion: true
+});
+```
+
+---
+
+## Local Demo
+
+```bash
+npm run dev
+```
+
+Open `http://localhost:5173/` and click the demo button.
+
+---
+
+## License
+
+MIT © Akshay Yadav

package/dist/index.cjs

@@ -0,0 +1,486 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  celebrate: () => celebrate
+});
+module.exports = __toCommonJS(index_exports);
+var googleColors = ["#4285F4", "#34A853", "#FBBC05", "#EA4335"];
+function shouldSkip(options) {
+  return options.respectReducedMotion && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function createCanvas() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Canvas 2D context is not available.");
+  }
+  canvas.style.position = "fixed";
+  canvas.style.top = "0";
+  canvas.style.left = "0";
+  canvas.style.width = "100vw";
+  canvas.style.height = "100vh";
+  canvas.style.pointerEvents = "none";
+  canvas.style.zIndex = "9999";
+  document.body.appendChild(canvas);
+  const resize = () => {
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+  };
+  resize();
+  window.addEventListener("resize", resize);
+  return {
+    canvas,
+    ctx,
+    cleanup: () => {
+      window.removeEventListener("resize", resize);
+      canvas.remove();
+    }
+  };
+}
+function playCompletionSound(volume = 0.35) {
+  const AudioContextClass = window.AudioContext ?? window.webkitAudioContext;
+  if (!AudioContextClass) return;
+  const audio = new AudioContextClass();
+  const master = audio.createGain();
+  const now = audio.currentTime;
+  const safeVolume = Math.min(Math.max(volume, 0), 1);
+  const tone = (frequency, startOffset, duration, type, level) => {
+    const oscillator = audio.createOscillator();
+    const gain = audio.createGain();
+    const start = now + startOffset;
+    const end = start + duration;
+    oscillator.type = type;
+    oscillator.frequency.setValueAtTime(frequency, start);
+    oscillator.frequency.exponentialRampToValueAtTime(frequency * 1.015, end);
+    gain.gain.setValueAtTime(1e-4, start);
+    gain.gain.exponentialRampToValueAtTime(level, start + 0.012);
+    gain.gain.exponentialRampToValueAtTime(1e-4, end);
+    oscillator.connect(gain);
+    gain.connect(master);
+    oscillator.start(start);
+    oscillator.stop(end + 0.03);
+  };
+  const notes = [
+    { frequency: 523.25, start: 0, duration: 0.09 },
+    { frequency: 659.25, start: 0.08, duration: 0.1 },
+    { frequency: 783.99, start: 0.16, duration: 0.12 },
+    { frequency: 1046.5, start: 0.28, duration: 0.22 }
+  ];
+  const sparkles = [
+    { frequency: 1567.98, start: 0.2 },
+    { frequency: 2093, start: 0.32 },
+    { frequency: 2637.02, start: 0.42 }
+  ];
+  master.gain.setValueAtTime(1e-4, now);
+  master.gain.exponentialRampToValueAtTime(safeVolume, now + 0.02);
+  master.gain.exponentialRampToValueAtTime(1e-4, now + 0.78);
+  master.connect(audio.destination);
+  notes.forEach((note) => {
+    tone(note.frequency, note.start, note.duration, "triangle", 0.9);
+    tone(note.frequency * 2, note.start + 0.01, note.duration * 0.55, "sine", 0.18);
+  });
+  sparkles.forEach((sparkle) => {
+    tone(sparkle.frequency, sparkle.start, 0.055, "sine", 0.22);
+  });
+  window.setTimeout(() => {
+    void audio.close();
+  }, 1e3);
+}
+function playSound(sound, volume = 0.35) {
+  if (typeof sound === "string") {
+    const audio = new Audio(sound);
+    audio.volume = Math.min(Math.max(volume, 0), 1);
+    void audio.play();
+    return;
+  }
+  if (sound === true) {
+    playCompletionSound(volume);
+  }
+}
+function confetti(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 2e3;
+  const particleCount = options.particleCount ?? 150;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const particles = Array.from({ length: particleCount }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * canvas.height - canvas.height,
+    size: Math.random() * 6 + 4,
+    color: colors[Math.floor(Math.random() * colors.length)],
+    velocityX: Math.random() * 4 - 2,
+    velocityY: Math.random() * 6 + 4,
+    rotation: Math.random() * 360
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    for (const p of particles) {
+      p.x += p.velocityX;
+      p.y += p.velocityY;
+      p.rotation += 5;
+      ctx.save();
+      ctx.translate(p.x, p.y);
+      ctx.rotate(p.rotation * Math.PI / 180);
+      ctx.fillStyle = p.color;
+      ctx.fillRect(-p.size / 2, -p.size / 2, p.size, p.size);
+      ctx.restore();
+    }
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function balloons(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 20;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => {
+    const radius = Math.random() * 20 + 20;
+    return {
+      x: Math.random() * canvas.width,
+      y: canvas.height + radius + Math.random() * 120,
+      radius,
+      color: colors[Math.floor(Math.random() * colors.length)],
+      speed: Math.random() * 2 + 2.8,
+      sway: Math.random() * 2 + 1
+    };
+  });
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((b, i) => {
+      b.y -= b.speed;
+      b.x += Math.sin(now / 300 + i) * b.sway;
+      ctx.fillStyle = b.color;
+      ctx.beginPath();
+      ctx.ellipse(b.x, b.y, b.radius * 0.8, b.radius, 0, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.beginPath();
+      ctx.moveTo(b.x - b.radius * 0.18, b.y + b.radius * 0.78);
+      ctx.lineTo(b.x + b.radius * 0.18, b.y + b.radius * 0.78);
+      ctx.lineTo(b.x, b.y + b.radius * 1.08);
+      ctx.closePath();
+      ctx.fill();
+      ctx.beginPath();
+      ctx.moveTo(b.x, b.y + b.radius);
+      ctx.quadraticCurveTo(
+        b.x + Math.sin(now / 150 + i) * b.sway * 4,
+        b.y + b.radius + 17.5,
+        b.x,
+        b.y + b.radius + 35
+      );
+      ctx.strokeStyle = "#9AA0A6";
+      ctx.lineWidth = 1;
+      ctx.stroke();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function popper(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3200;
+  const particleCount = options.particleCount ?? 120;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const particles = [];
+  for (const side of ["left", "right"]) {
+    for (let i = 0; i < particleCount / 2; i++) {
+      const direction = side === "left" ? 1 : -1;
+      const angle = Math.random() * 0.75 + 0.2;
+      const power = Math.random() * 8 + 10;
+      particles.push({
+        x: side === "left" ? canvas.width * 0.08 : canvas.width * 0.92,
+        y: canvas.height * 0.82,
+        size: Math.random() * 6 + 4,
+        color: colors[Math.floor(Math.random() * colors.length)],
+        vx: Math.cos(angle) * power * direction,
+        vy: -Math.sin(angle) * power - Math.random() * 6,
+        rotation: Math.random() * 360,
+        rotationSpeed: Math.random() * 12 - 6
+      });
+    }
+  }
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    particles.forEach((p) => {
+      p.vy += 0.32;
+      p.vx *= 0.992;
+      p.vy *= 0.997;
+      p.x += p.vx;
+      p.y += p.vy;
+      p.rotation += p.rotationSpeed;
+      ctx.save();
+      ctx.translate(p.x, p.y);
+      ctx.rotate(p.rotation * Math.PI / 180);
+      ctx.fillStyle = p.color;
+      ctx.fillRect(-p.size / 2, -p.size / 2, p.size, p.size);
+      ctx.restore();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function fireworks(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 4e3;
+  const burstCount = options.count ?? 5;
+  const interval = options.interval ?? 500;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  let particles = [];
+  let bursts = 0;
+  let lastBurst = 0;
+  const start = performance.now();
+  function createBurst() {
+    const x = Math.random() * canvas.width;
+    const y = Math.random() * canvas.height * 0.5;
+    const color = colors[Math.floor(Math.random() * colors.length)];
+    for (let i = 0; i < 60; i++) {
+      const angle = Math.PI * 2 * i / 60;
+      const speed = Math.random() * 4 + 2;
+      particles.push({ x, y, vx: Math.cos(angle) * speed, vy: Math.sin(angle) * speed, alpha: 1, color });
+    }
+  }
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (bursts < burstCount && now - lastBurst > interval) {
+      createBurst();
+      bursts++;
+      lastBurst = now;
+    }
+    particles.forEach((p) => {
+      p.x += p.vx;
+      p.y += p.vy;
+      p.vy += 0.04;
+      p.alpha -= 0.015;
+      ctx.globalAlpha = Math.max(p.alpha, 0);
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
+      ctx.fillStyle = p.color;
+      ctx.fill();
+    });
+    ctx.globalAlpha = 1;
+    particles = particles.filter((p) => p.alpha > 0);
+    now - start < duration || particles.length > 0 ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function bubbles(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 25;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: canvas.height + Math.random() * 100,
+    radius: Math.random() * 15 + 10,
+    speed: Math.random() * 2.1 + 1.4,
+    drift: Math.random() * 1.5 - 0.75,
+    alpha: Math.random() * 0.4 + 0.4
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((b) => {
+      b.y -= b.speed;
+      b.x += Math.sin(now / 500) * b.drift;
+      if (b.y < canvas.height * 0.3) b.alpha = Math.max(0, b.alpha - 0.01);
+      ctx.beginPath();
+      ctx.arc(b.x, b.y, b.radius, 0, Math.PI * 2);
+      ctx.fillStyle = `rgba(180, 220, 255, ${b.alpha * 0.4})`;
+      ctx.fill();
+      ctx.strokeStyle = `rgba(255,255,255,${b.alpha})`;
+      ctx.lineWidth = 2;
+      ctx.stroke();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function emojis(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 30;
+  const emojiSet = options.emojis ?? ["\u{1F389}", "\u2728", "\u{1F525}", "\u{1F4AF}", "\u{1F60D}"];
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * -canvas.height,
+    char: emojiSet[Math.floor(Math.random() * emojiSet.length)],
+    size: Math.random() * 20 + 20,
+    speed: Math.random() * 2.5 + 1.5,
+    drift: Math.random() * 1.5 - 0.75,
+    rotation: Math.random() * 360,
+    rotationSpeed: Math.random() * 4 - 2,
+    alpha: 1
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((e) => {
+      e.y += e.speed;
+      e.x += Math.sin(now / 400) * e.drift;
+      e.rotation += e.rotationSpeed;
+      if (e.y > canvas.height * 0.8) e.alpha = Math.max(0, e.alpha - 0.02);
+      ctx.save();
+      ctx.translate(e.x, e.y);
+      ctx.rotate(e.rotation * Math.PI / 180);
+      ctx.globalAlpha = e.alpha;
+      ctx.font = `${e.size}px serif`;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(e.char, 0, 0);
+      ctx.restore();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function stars(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.count ?? 5;
+  const interval = options.interval ?? 500;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = [];
+  const start = performance.now();
+  let spawned = 0;
+  let lastSpawn = 0;
+  function spawnStar() {
+    const fromLeft = Math.random() > 0.5;
+    items.push({
+      x: fromLeft ? -100 : canvas.width + 100,
+      y: Math.random() * canvas.height * 0.4,
+      vx: fromLeft ? Math.random() * 12 + 8 : -(Math.random() * 12 + 8),
+      vy: Math.random() * 6 + 4,
+      alpha: 1
+    });
+  }
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (spawned < count && now - lastSpawn > interval) {
+      spawnStar();
+      spawned++;
+      lastSpawn = now;
+    }
+    items.forEach((s, i) => {
+      s.x += s.vx;
+      s.y += s.vy;
+      s.alpha -= 0.015;
+      ctx.beginPath();
+      ctx.moveTo(s.x, s.y);
+      ctx.lineTo(s.x - s.vx * 4, s.y - s.vy * 4);
+      ctx.strokeStyle = `rgba(251,188,5,${s.alpha})`;
+      ctx.lineWidth = 2;
+      ctx.lineCap = "round";
+      ctx.stroke();
+      if (s.alpha <= 0) items.splice(i, 1);
+    });
+    now - start < duration || items.length > 0 ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function snowfall(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 5e3;
+  const count = options.particleCount ?? 60;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const flakes = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * -canvas.height,
+    radius: Math.random() * 2.5 + 1,
+    speed: Math.random() * 0.6 + 0.3,
+    drift: Math.random() * 0.6 - 0.3,
+    alpha: Math.random() * 0.5 + 0.4
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    flakes.forEach((f) => {
+      f.y += f.speed;
+      f.x += Math.sin(now / 800) * f.drift;
+      if (f.y > canvas.height) {
+        f.y = -10;
+        f.x = Math.random() * canvas.width;
+      }
+      ctx.beginPath();
+      ctx.arc(f.x, f.y, f.radius, 0, Math.PI * 2);
+      ctx.fillStyle = `rgba(255,255,255,${f.alpha})`;
+      ctx.fill();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+var celebrate = Object.assign((options = {}) => {
+  if (shouldSkip(options)) return;
+  if (options.sound) {
+    playSound(options.sound, options.soundVolume);
+  }
+  const effect = options.effect ?? "confetti";
+  switch (effect) {
+    case "confetti":
+      confetti(options);
+      break;
+    case "balloons":
+      balloons(options);
+      break;
+    case "popper":
+      popper(options);
+      break;
+    case "fireworks":
+      fireworks(options);
+      break;
+    case "bubbles":
+      bubbles(options);
+      break;
+    case "emojis":
+      emojis(options);
+      break;
+    case "stars":
+      stars(options);
+      break;
+    case "snowfall":
+      snowfall(options);
+      break;
+  }
+}, {
+  confetti: (o) => celebrate({ ...o, effect: "confetti" }),
+  balloons: (o) => celebrate({ ...o, effect: "balloons" }),
+  popper: (o) => celebrate({ ...o, effect: "popper" }),
+  fireworks: (o) => celebrate({ ...o, effect: "fireworks" }),
+  bubbles: (o) => celebrate({ ...o, effect: "bubbles" }),
+  emojis: (o) => celebrate({ ...o, effect: "emojis" }),
+  stars: (o) => celebrate({ ...o, effect: "stars" }),
+  snowfall: (o) => celebrate({ ...o, effect: "snowfall" })
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  celebrate
+});

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+type CelebrateEffect = "confetti" | "balloons" | "popper" | "fireworks" | "bubbles" | "emojis" | "stars" | "snowfall";
+interface CelebrateOptions {
+    effect?: CelebrateEffect;
+    duration?: number;
+    particleCount?: number;
+    colors?: string[];
+    respectReducedMotion?: boolean;
+    sound?: boolean | string;
+    soundVolume?: number;
+    count?: number;
+    interval?: number;
+    emojis?: string[];
+}
+type CelebrateShortcut = (options?: CelebrateOptions) => void;
+interface Celebrate {
+    (options?: CelebrateOptions): void;
+    confetti: CelebrateShortcut;
+    balloons: CelebrateShortcut;
+    popper: CelebrateShortcut;
+    fireworks: CelebrateShortcut;
+    bubbles: CelebrateShortcut;
+    emojis: CelebrateShortcut;
+    stars: CelebrateShortcut;
+    snowfall: CelebrateShortcut;
+}
+declare const celebrate: Celebrate;
+
+export { type Celebrate, type CelebrateEffect, type CelebrateOptions, celebrate };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+type CelebrateEffect = "confetti" | "balloons" | "popper" | "fireworks" | "bubbles" | "emojis" | "stars" | "snowfall";
+interface CelebrateOptions {
+    effect?: CelebrateEffect;
+    duration?: number;
+    particleCount?: number;
+    colors?: string[];
+    respectReducedMotion?: boolean;
+    sound?: boolean | string;
+    soundVolume?: number;
+    count?: number;
+    interval?: number;
+    emojis?: string[];
+}
+type CelebrateShortcut = (options?: CelebrateOptions) => void;
+interface Celebrate {
+    (options?: CelebrateOptions): void;
+    confetti: CelebrateShortcut;
+    balloons: CelebrateShortcut;
+    popper: CelebrateShortcut;
+    fireworks: CelebrateShortcut;
+    bubbles: CelebrateShortcut;
+    emojis: CelebrateShortcut;
+    stars: CelebrateShortcut;
+    snowfall: CelebrateShortcut;
+}
+declare const celebrate: Celebrate;
+
+export { type Celebrate, type CelebrateEffect, type CelebrateOptions, celebrate };

package/dist/index.js

@@ -0,0 +1,462 @@
+// src/index.ts
+var googleColors = ["#4285F4", "#34A853", "#FBBC05", "#EA4335"];
+function shouldSkip(options) {
+  return options.respectReducedMotion && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function createCanvas() {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Canvas 2D context is not available.");
+  }
+  canvas.style.position = "fixed";
+  canvas.style.top = "0";
+  canvas.style.left = "0";
+  canvas.style.width = "100vw";
+  canvas.style.height = "100vh";
+  canvas.style.pointerEvents = "none";
+  canvas.style.zIndex = "9999";
+  document.body.appendChild(canvas);
+  const resize = () => {
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+  };
+  resize();
+  window.addEventListener("resize", resize);
+  return {
+    canvas,
+    ctx,
+    cleanup: () => {
+      window.removeEventListener("resize", resize);
+      canvas.remove();
+    }
+  };
+}
+function playCompletionSound(volume = 0.35) {
+  const AudioContextClass = window.AudioContext ?? window.webkitAudioContext;
+  if (!AudioContextClass) return;
+  const audio = new AudioContextClass();
+  const master = audio.createGain();
+  const now = audio.currentTime;
+  const safeVolume = Math.min(Math.max(volume, 0), 1);
+  const tone = (frequency, startOffset, duration, type, level) => {
+    const oscillator = audio.createOscillator();
+    const gain = audio.createGain();
+    const start = now + startOffset;
+    const end = start + duration;
+    oscillator.type = type;
+    oscillator.frequency.setValueAtTime(frequency, start);
+    oscillator.frequency.exponentialRampToValueAtTime(frequency * 1.015, end);
+    gain.gain.setValueAtTime(1e-4, start);
+    gain.gain.exponentialRampToValueAtTime(level, start + 0.012);
+    gain.gain.exponentialRampToValueAtTime(1e-4, end);
+    oscillator.connect(gain);
+    gain.connect(master);
+    oscillator.start(start);
+    oscillator.stop(end + 0.03);
+  };
+  const notes = [
+    { frequency: 523.25, start: 0, duration: 0.09 },
+    { frequency: 659.25, start: 0.08, duration: 0.1 },
+    { frequency: 783.99, start: 0.16, duration: 0.12 },
+    { frequency: 1046.5, start: 0.28, duration: 0.22 }
+  ];
+  const sparkles = [
+    { frequency: 1567.98, start: 0.2 },
+    { frequency: 2093, start: 0.32 },
+    { frequency: 2637.02, start: 0.42 }
+  ];
+  master.gain.setValueAtTime(1e-4, now);
+  master.gain.exponentialRampToValueAtTime(safeVolume, now + 0.02);
+  master.gain.exponentialRampToValueAtTime(1e-4, now + 0.78);
+  master.connect(audio.destination);
+  notes.forEach((note) => {
+    tone(note.frequency, note.start, note.duration, "triangle", 0.9);
+    tone(note.frequency * 2, note.start + 0.01, note.duration * 0.55, "sine", 0.18);
+  });
+  sparkles.forEach((sparkle) => {
+    tone(sparkle.frequency, sparkle.start, 0.055, "sine", 0.22);
+  });
+  window.setTimeout(() => {
+    void audio.close();
+  }, 1e3);
+}
+function playSound(sound, volume = 0.35) {
+  if (typeof sound === "string") {
+    const audio = new Audio(sound);
+    audio.volume = Math.min(Math.max(volume, 0), 1);
+    void audio.play();
+    return;
+  }
+  if (sound === true) {
+    playCompletionSound(volume);
+  }
+}
+function confetti(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 2e3;
+  const particleCount = options.particleCount ?? 150;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const particles = Array.from({ length: particleCount }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * canvas.height - canvas.height,
+    size: Math.random() * 6 + 4,
+    color: colors[Math.floor(Math.random() * colors.length)],
+    velocityX: Math.random() * 4 - 2,
+    velocityY: Math.random() * 6 + 4,
+    rotation: Math.random() * 360
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    for (const p of particles) {
+      p.x += p.velocityX;
+      p.y += p.velocityY;
+      p.rotation += 5;
+      ctx.save();
+      ctx.translate(p.x, p.y);
+      ctx.rotate(p.rotation * Math.PI / 180);
+      ctx.fillStyle = p.color;
+      ctx.fillRect(-p.size / 2, -p.size / 2, p.size, p.size);
+      ctx.restore();
+    }
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function balloons(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 20;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => {
+    const radius = Math.random() * 20 + 20;
+    return {
+      x: Math.random() * canvas.width,
+      y: canvas.height + radius + Math.random() * 120,
+      radius,
+      color: colors[Math.floor(Math.random() * colors.length)],
+      speed: Math.random() * 2 + 2.8,
+      sway: Math.random() * 2 + 1
+    };
+  });
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((b, i) => {
+      b.y -= b.speed;
+      b.x += Math.sin(now / 300 + i) * b.sway;
+      ctx.fillStyle = b.color;
+      ctx.beginPath();
+      ctx.ellipse(b.x, b.y, b.radius * 0.8, b.radius, 0, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.beginPath();
+      ctx.moveTo(b.x - b.radius * 0.18, b.y + b.radius * 0.78);
+      ctx.lineTo(b.x + b.radius * 0.18, b.y + b.radius * 0.78);
+      ctx.lineTo(b.x, b.y + b.radius * 1.08);
+      ctx.closePath();
+      ctx.fill();
+      ctx.beginPath();
+      ctx.moveTo(b.x, b.y + b.radius);
+      ctx.quadraticCurveTo(
+        b.x + Math.sin(now / 150 + i) * b.sway * 4,
+        b.y + b.radius + 17.5,
+        b.x,
+        b.y + b.radius + 35
+      );
+      ctx.strokeStyle = "#9AA0A6";
+      ctx.lineWidth = 1;
+      ctx.stroke();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function popper(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3200;
+  const particleCount = options.particleCount ?? 120;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const particles = [];
+  for (const side of ["left", "right"]) {
+    for (let i = 0; i < particleCount / 2; i++) {
+      const direction = side === "left" ? 1 : -1;
+      const angle = Math.random() * 0.75 + 0.2;
+      const power = Math.random() * 8 + 10;
+      particles.push({
+        x: side === "left" ? canvas.width * 0.08 : canvas.width * 0.92,
+        y: canvas.height * 0.82,
+        size: Math.random() * 6 + 4,
+        color: colors[Math.floor(Math.random() * colors.length)],
+        vx: Math.cos(angle) * power * direction,
+        vy: -Math.sin(angle) * power - Math.random() * 6,
+        rotation: Math.random() * 360,
+        rotationSpeed: Math.random() * 12 - 6
+      });
+    }
+  }
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    particles.forEach((p) => {
+      p.vy += 0.32;
+      p.vx *= 0.992;
+      p.vy *= 0.997;
+      p.x += p.vx;
+      p.y += p.vy;
+      p.rotation += p.rotationSpeed;
+      ctx.save();
+      ctx.translate(p.x, p.y);
+      ctx.rotate(p.rotation * Math.PI / 180);
+      ctx.fillStyle = p.color;
+      ctx.fillRect(-p.size / 2, -p.size / 2, p.size, p.size);
+      ctx.restore();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function fireworks(options = {}) {
+  var _a;
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 4e3;
+  const burstCount = options.count ?? 5;
+  const interval = options.interval ?? 500;
+  const colors = ((_a = options.colors) == null ? void 0 : _a.length) ? options.colors : googleColors;
+  const { canvas, ctx, cleanup } = createCanvas();
+  let particles = [];
+  let bursts = 0;
+  let lastBurst = 0;
+  const start = performance.now();
+  function createBurst() {
+    const x = Math.random() * canvas.width;
+    const y = Math.random() * canvas.height * 0.5;
+    const color = colors[Math.floor(Math.random() * colors.length)];
+    for (let i = 0; i < 60; i++) {
+      const angle = Math.PI * 2 * i / 60;
+      const speed = Math.random() * 4 + 2;
+      particles.push({ x, y, vx: Math.cos(angle) * speed, vy: Math.sin(angle) * speed, alpha: 1, color });
+    }
+  }
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (bursts < burstCount && now - lastBurst > interval) {
+      createBurst();
+      bursts++;
+      lastBurst = now;
+    }
+    particles.forEach((p) => {
+      p.x += p.vx;
+      p.y += p.vy;
+      p.vy += 0.04;
+      p.alpha -= 0.015;
+      ctx.globalAlpha = Math.max(p.alpha, 0);
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
+      ctx.fillStyle = p.color;
+      ctx.fill();
+    });
+    ctx.globalAlpha = 1;
+    particles = particles.filter((p) => p.alpha > 0);
+    now - start < duration || particles.length > 0 ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function bubbles(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 25;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: canvas.height + Math.random() * 100,
+    radius: Math.random() * 15 + 10,
+    speed: Math.random() * 2.1 + 1.4,
+    drift: Math.random() * 1.5 - 0.75,
+    alpha: Math.random() * 0.4 + 0.4
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((b) => {
+      b.y -= b.speed;
+      b.x += Math.sin(now / 500) * b.drift;
+      if (b.y < canvas.height * 0.3) b.alpha = Math.max(0, b.alpha - 0.01);
+      ctx.beginPath();
+      ctx.arc(b.x, b.y, b.radius, 0, Math.PI * 2);
+      ctx.fillStyle = `rgba(180, 220, 255, ${b.alpha * 0.4})`;
+      ctx.fill();
+      ctx.strokeStyle = `rgba(255,255,255,${b.alpha})`;
+      ctx.lineWidth = 2;
+      ctx.stroke();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function emojis(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.particleCount ?? 30;
+  const emojiSet = options.emojis ?? ["\u{1F389}", "\u2728", "\u{1F525}", "\u{1F4AF}", "\u{1F60D}"];
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * -canvas.height,
+    char: emojiSet[Math.floor(Math.random() * emojiSet.length)],
+    size: Math.random() * 20 + 20,
+    speed: Math.random() * 2.5 + 1.5,
+    drift: Math.random() * 1.5 - 0.75,
+    rotation: Math.random() * 360,
+    rotationSpeed: Math.random() * 4 - 2,
+    alpha: 1
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    items.forEach((e) => {
+      e.y += e.speed;
+      e.x += Math.sin(now / 400) * e.drift;
+      e.rotation += e.rotationSpeed;
+      if (e.y > canvas.height * 0.8) e.alpha = Math.max(0, e.alpha - 0.02);
+      ctx.save();
+      ctx.translate(e.x, e.y);
+      ctx.rotate(e.rotation * Math.PI / 180);
+      ctx.globalAlpha = e.alpha;
+      ctx.font = `${e.size}px serif`;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(e.char, 0, 0);
+      ctx.restore();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function stars(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 3e3;
+  const count = options.count ?? 5;
+  const interval = options.interval ?? 500;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const items = [];
+  const start = performance.now();
+  let spawned = 0;
+  let lastSpawn = 0;
+  function spawnStar() {
+    const fromLeft = Math.random() > 0.5;
+    items.push({
+      x: fromLeft ? -100 : canvas.width + 100,
+      y: Math.random() * canvas.height * 0.4,
+      vx: fromLeft ? Math.random() * 12 + 8 : -(Math.random() * 12 + 8),
+      vy: Math.random() * 6 + 4,
+      alpha: 1
+    });
+  }
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (spawned < count && now - lastSpawn > interval) {
+      spawnStar();
+      spawned++;
+      lastSpawn = now;
+    }
+    items.forEach((s, i) => {
+      s.x += s.vx;
+      s.y += s.vy;
+      s.alpha -= 0.015;
+      ctx.beginPath();
+      ctx.moveTo(s.x, s.y);
+      ctx.lineTo(s.x - s.vx * 4, s.y - s.vy * 4);
+      ctx.strokeStyle = `rgba(251,188,5,${s.alpha})`;
+      ctx.lineWidth = 2;
+      ctx.lineCap = "round";
+      ctx.stroke();
+      if (s.alpha <= 0) items.splice(i, 1);
+    });
+    now - start < duration || items.length > 0 ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+function snowfall(options = {}) {
+  if (shouldSkip(options)) return;
+  const duration = options.duration ?? 5e3;
+  const count = options.particleCount ?? 60;
+  const { canvas, ctx, cleanup } = createCanvas();
+  const flakes = Array.from({ length: count }).map(() => ({
+    x: Math.random() * canvas.width,
+    y: Math.random() * -canvas.height,
+    radius: Math.random() * 2.5 + 1,
+    speed: Math.random() * 0.6 + 0.3,
+    drift: Math.random() * 0.6 - 0.3,
+    alpha: Math.random() * 0.5 + 0.4
+  }));
+  const start = performance.now();
+  function draw(now) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    flakes.forEach((f) => {
+      f.y += f.speed;
+      f.x += Math.sin(now / 800) * f.drift;
+      if (f.y > canvas.height) {
+        f.y = -10;
+        f.x = Math.random() * canvas.width;
+      }
+      ctx.beginPath();
+      ctx.arc(f.x, f.y, f.radius, 0, Math.PI * 2);
+      ctx.fillStyle = `rgba(255,255,255,${f.alpha})`;
+      ctx.fill();
+    });
+    now - start < duration ? requestAnimationFrame(draw) : cleanup();
+  }
+  requestAnimationFrame(draw);
+}
+var celebrate = Object.assign((options = {}) => {
+  if (shouldSkip(options)) return;
+  if (options.sound) {
+    playSound(options.sound, options.soundVolume);
+  }
+  const effect = options.effect ?? "confetti";
+  switch (effect) {
+    case "confetti":
+      confetti(options);
+      break;
+    case "balloons":
+      balloons(options);
+      break;
+    case "popper":
+      popper(options);
+      break;
+    case "fireworks":
+      fireworks(options);
+      break;
+    case "bubbles":
+      bubbles(options);
+      break;
+    case "emojis":
+      emojis(options);
+      break;
+    case "stars":
+      stars(options);
+      break;
+    case "snowfall":
+      snowfall(options);
+      break;
+  }
+}, {
+  confetti: (o) => celebrate({ ...o, effect: "confetti" }),
+  balloons: (o) => celebrate({ ...o, effect: "balloons" }),
+  popper: (o) => celebrate({ ...o, effect: "popper" }),
+  fireworks: (o) => celebrate({ ...o, effect: "fireworks" }),
+  bubbles: (o) => celebrate({ ...o, effect: "bubbles" }),
+  emojis: (o) => celebrate({ ...o, effect: "emojis" }),
+  stars: (o) => celebrate({ ...o, effect: "stars" }),
+  snowfall: (o) => celebrate({ ...o, effect: "snowfall" })
+});
+export {
+  celebrate
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "celebrate-js",
+  "version": "0.0.1",
+  "description": "Delightful UI celebration effects (confetti, balloons, fireworks, and more)",
+  "keywords": [
+    "celebration",
+    "confetti",
+    "balloons",
+    "animations",
+    "effects",
+    "ui",
+    "canvas",
+    "frontend",
+    "micro-interactions"
+  ],
+  "homepage": "https://github.com/akshaywritescode/celebrate-js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akshaywritescode/celebrate-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/akshaywritescode/celebrate-js/issues"
+  },
+  "license": "MIT",
+  "author": "Akshay <debugwithakshay@gmail.com>",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "vite --host 0.0.0.0",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "eslint": "^8.56.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}