ghostdust 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dalzein
+
+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 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,80 @@
+# ghostdust
+
+Turn text, SVGs, and images into interactive anti-gravity particles. Sweep your cursor through them to scatter the dust; springs pull every particle back home.
+
+Framework-agnostic WebGL core with a React wrapper. No dependencies.
+
+## Install
+
+```sh
+npm install ghostdust
+```
+
+## Vanilla
+
+```js
+import ghostdust from 'ghostdust';
+
+// text, in any loaded font
+const gd = await ghostdust.fromText('#logo', 'ghostdust', {
+  fontFamily: 'Google Sans',
+  colors: ['#e8e6f0', '#a78bfa'],   // one color = solid, more = gradient
+});
+
+// an image: File, Blob, <img> element, or URL
+await ghostdust.fromImage(canvasEl, '/hero.png', {
+  removeBackground: false,          // keep opaque backgrounds as particles
+});
+
+// raw SVG markup
+await ghostdust.fromSvg(canvasEl, '<svg>...</svg>', { intro: 'scatter' });
+
+gd.count;      // number of particles
+gd.engine;     // the ParticleEngine, for live param tweaks
+gd.destroy();  // stop and release everything
+
+// swap content on a live instance without rebuilding it
+await gd.setText('boo', { colors: ['#22d3ee'] });
+await gd.setImage(file, { removeBackground: false });
+await gd.setSvg('<svg>...</svg>');
+```
+
+Each `from*` call takes a `<canvas>` element (or selector) plus options:
+
+| Option | Default | |
+| --- | --- | --- |
+| `targetParticles` | `14000` | approximate particle count |
+| `margin` | `0.72` | fraction of the canvas the art may occupy |
+| `intro` | `'scatter'` (`'bloom'` for text) | entrance: fly in from outside, or condense from a local haze (best for small canvases) |
+| `physics` | engine defaults | `{ radius, force, stiffness, damping, speedBoost }` |
+| `pointer` | `true` | wire up cursor/touch tracking |
+| `removeBackground` | `true` | images only: drop pixels matching the estimated background color of opaque images; `false` keeps every visible pixel |
+| `fontFamily`, `weight`, `colors` | `system-ui`, `600`, white | text only |
+
+## React
+
+```jsx
+import { ParticleText, ParticleImage } from 'ghostdust/react';
+
+<ParticleText
+  text="ghostdust"
+  fontFamily="Google Sans"
+  colors={['#e8e6f0', '#a78bfa']}
+  physics={{ radius: 60, force: 900 }}
+  className="wordmark"          // size it with CSS; any size works
+/>
+
+<ParticleImage src="/hero.png" removeBackground={false} label="Hero artwork" />
+```
+
+Props mirror the vanilla options. Components resize with their element (not just the window), and are accessible by default: pass `label` for an image description, or `label={null}` when a nearby heading already names the content.
+
+Components also take `bleed` (default `0.75`): the transparent canvas overhangs the layout box by that fraction on every side, so particles pushed around by the cursor aren't clipped at the element's edges. It never affects layout or clicks — set `bleed={0}` for a tightly bounded canvas.
+
+## Local development
+
+```sh
+npm run dev        # demo site
+npm run build:lib  # build the package to dist/
+npm run build      # build the demo site to dist-site/
+```

package/dist/index.js

@@ -0,0 +1,86 @@
+import { i as e, n as t, r as n, t as r } from "./sampler-p8JbOhAo.js";
+//#region src/lib/core/ghostdust.js
+function i(e) {
+	let t = typeof e == "string" ? document.querySelector(e) : e;
+	if (!t || typeof t.getContext != "function") throw Error("ghostdust: target must be a <canvas> element or selector");
+	return t;
+}
+function a(i, a) {
+	let { margin: o, intro: s, physics: c, pointer: l = !0 } = a, u = new e(i, {
+		margin: o,
+		intro: s
+	});
+	c && Object.assign(u.params, c), u.start();
+	let d = null;
+	if (l) {
+		let e = (e, t) => {
+			let n = i.getBoundingClientRect();
+			u.setPointer(e - n.left, t - n.top, !0);
+		}, t = (t) => e(t.clientX, t.clientY), n = (t) => {
+			let n = t.touches[0];
+			n && e(n.clientX, n.clientY);
+		}, r = () => u.setPointer(0, 0, !1);
+		window.addEventListener("pointermove", t), window.addEventListener("blur", r), window.addEventListener("touchmove", n, { passive: !0 }), window.addEventListener("touchend", r), d = () => {
+			window.removeEventListener("pointermove", t), window.removeEventListener("blur", r), window.removeEventListener("touchmove", n), window.removeEventListener("touchend", r);
+		};
+	}
+	return {
+		engine: u,
+		canvas: i,
+		get count() {
+			return u.count;
+		},
+		async setText(e, t = {}) {
+			u.setParticles(await n(e, t));
+		},
+		async setImage(e, t = {}) {
+			u.setParticles(await r(e, t));
+		},
+		async setSvg(e, n = {}) {
+			u.setParticles(await t(e, n));
+		},
+		destroy() {
+			d?.(), u.destroy();
+		}
+	};
+}
+async function o(e, t, n) {
+	let r = a(i(e), t);
+	try {
+		return await n(r), r;
+	} catch (e) {
+		throw r.destroy(), e;
+	}
+}
+function s(e, t, n = {}) {
+	let { fontFamily: r, weight: i, colors: a, targetParticles: s, ...c } = n;
+	return o(e, {
+		intro: "bloom",
+		...c
+	}, (e) => e.setText(t, {
+		fontFamily: r,
+		weight: i,
+		colors: a,
+		targetParticles: s
+	}));
+}
+function c(e, t, n = {}) {
+	let { targetParticles: r, removeBackground: i, ...a } = n;
+	return o(e, a, (e) => e.setImage(t, {
+		targetParticles: r,
+		removeBackground: i
+	}));
+}
+function l(e, t, n = {}) {
+	let { targetParticles: r, ...i } = n;
+	return o(e, i, (e) => e.setSvg(t, { targetParticles: r }));
+}
+//#endregion
+//#region src/lib/index.js
+var u = {
+	fromText: s,
+	fromImage: c,
+	fromSvg: l
+};
+//#endregion
+export { e as ParticleEngine, u as default, c as fromImage, l as fromSvg, s as fromText, r as sampleImage, t as sampleSvg, n as sampleText };

package/dist/react.js

@@ -0,0 +1,120 @@
+import { i as e, r as t, t as n } from "./sampler-p8JbOhAo.js";
+import { useEffect as r, useRef as i } from "react";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/lib/react.jsx
+function o(t, n, { margin: a, intro: o, physicsKey: s }) {
+	let c = i(null);
+	return r(() => {
+		let n = c.current, r;
+		try {
+			r = new e(n, {
+				margin: a,
+				intro: o
+			});
+		} catch {
+			return;
+		}
+		s && Object.assign(r.params, JSON.parse(s)), r.start();
+		let i = !1;
+		t().then((e) => {
+			i || r.setParticles(e);
+		}).catch(() => {});
+		let l = (e) => {
+			let t = n.getBoundingClientRect();
+			r.setPointer(e.clientX - t.left, e.clientY - t.top, !0);
+		}, u = (e) => {
+			let t = e.touches[0];
+			if (t) {
+				let e = n.getBoundingClientRect();
+				r.setPointer(t.clientX - e.left, t.clientY - e.top, !0);
+			}
+		}, d = () => r.setPointer(0, 0, !1);
+		return window.addEventListener("pointermove", l), window.addEventListener("blur", d), window.addEventListener("touchmove", u, { passive: !0 }), window.addEventListener("touchend", d), () => {
+			i = !0, window.removeEventListener("pointermove", l), window.removeEventListener("blur", d), window.removeEventListener("touchmove", u), window.removeEventListener("touchend", d), r.destroy();
+		};
+	}, n), c;
+}
+function s(e) {
+	return e ? {
+		role: "img",
+		"aria-label": e
+	} : { "aria-hidden": "true" };
+}
+function c({ canvasRef: e, bleed: t, label: n, className: r, style: i }) {
+	let o = 1 + 2 * t;
+	return /* @__PURE__ */ a("span", {
+		className: r,
+		style: {
+			display: "block",
+			position: "relative",
+			...i
+		},
+		...s(n),
+		children: /* @__PURE__ */ a("canvas", {
+			ref: e,
+			"aria-hidden": "true",
+			style: {
+				position: "absolute",
+				left: `${-t * 100}%`,
+				top: `${-t * 100}%`,
+				width: `${o * 100}%`,
+				height: `${o * 100}%`,
+				pointerEvents: "none"
+			}
+		})
+	});
+}
+function l({ text: e, colors: n = ["#ffffff"], fontFamily: r = "system-ui", weight: i = 600, targetParticles: s = 1600, margin: l = .9, bleed: u = .75, intro: d = "bloom", physics: f, label: p = e, className: m, style: h }) {
+	let g = n.join(","), _ = f ? JSON.stringify(f) : "", v = l / (1 + 2 * u), y = o(() => t(e, {
+		colors: g.split(","),
+		fontFamily: r,
+		weight: i,
+		targetParticles: s
+	}), [
+		e,
+		g,
+		r,
+		i,
+		s,
+		v,
+		d,
+		_
+	], {
+		margin: v,
+		intro: d,
+		physicsKey: _
+	});
+	return /* @__PURE__ */ a(c, {
+		canvasRef: y,
+		bleed: u,
+		label: p,
+		className: m,
+		style: h
+	});
+}
+function u({ src: e, targetParticles: t = 4e3, removeBackground: r = !0, margin: i = .9, bleed: s = .75, intro: l = "bloom", physics: u, label: d = null, className: f, style: p }) {
+	let m = u ? JSON.stringify(u) : "", h = i / (1 + 2 * s), g = o(() => n(e, {
+		targetParticles: t,
+		removeBackground: r
+	}), [
+		e,
+		t,
+		r,
+		h,
+		l,
+		m
+	], {
+		margin: h,
+		intro: l,
+		physicsKey: m
+	});
+	return /* @__PURE__ */ a(c, {
+		canvasRef: g,
+		bleed: s,
+		label: d,
+		className: f,
+		style: p
+	});
+}
+//#endregion
+export { u as ParticleImage, l as ParticleText };

package/dist/sampler-p8JbOhAo.js

@@ -0,0 +1,234 @@
+function e(e, t, n) {
+	let r = e.createShader(t);
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) throw Error(e.getShaderInfoLog(r));
+	return r;
+}
+var t = class {
+	constructor(t, { margin: n = .72, intro: r = "scatter" } = {}) {
+		this.canvas = t, this.margin = n, this.intro = r;
+		let i = t.getContext("webgl", {
+			antialias: !1,
+			alpha: !0,
+			premultipliedAlpha: !1
+		});
+		if (!i) throw Error("WebGL not supported");
+		this.gl = i;
+		let a = i.createProgram();
+		if (i.attachShader(a, e(i, i.VERTEX_SHADER, "\nattribute vec2 a_pos;\nattribute vec4 a_color;\nattribute float a_size;\nattribute float a_speed;\n\nuniform vec2 u_resolution;\nuniform float u_dpr;\n\nvarying vec4 v_color;\nvarying float v_speed;\n\nvoid main() {\n  // pixel coords -> clip space\n  vec2 clip = (a_pos / u_resolution) * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  gl_PointSize = a_size * u_dpr * (1.0 + min(a_speed * 0.0016, 0.9));\n  v_color = a_color;\n  v_speed = a_speed;\n}\n")), i.attachShader(a, e(i, i.FRAGMENT_SHADER, "\nprecision mediump float;\nvarying vec4 v_color;\nvarying float v_speed;\n\nvoid main() {\n  vec2 uv = gl_PointCoord * 2.0 - 1.0;\n  float d = dot(uv, uv);\n  if (d > 1.0) discard;\n  float alpha = smoothstep(1.0, 0.55, d);\n  // particles glow slightly hotter while moving fast\n  float heat = min(v_speed * 0.0012, 1.0);\n  vec3 col = mix(v_color.rgb, vec3(1.0), heat * 0.55);\n  gl_FragColor = vec4(col, alpha * v_color.a);\n}\n")), i.linkProgram(a), !i.getProgramParameter(a, i.LINK_STATUS)) throw Error(i.getProgramInfoLog(a));
+		this.program = a, this.loc = {
+			pos: i.getAttribLocation(a, "a_pos"),
+			color: i.getAttribLocation(a, "a_color"),
+			size: i.getAttribLocation(a, "a_size"),
+			speed: i.getAttribLocation(a, "a_speed"),
+			resolution: i.getUniformLocation(a, "u_resolution"),
+			dpr: i.getUniformLocation(a, "u_dpr")
+		}, this.posBuf = i.createBuffer(), this.colorBuf = i.createBuffer(), this.sizeBuf = i.createBuffer(), this.speedBuf = i.createBuffer(), i.enable(i.BLEND), i.blendFunc(i.SRC_ALPHA, i.ONE_MINUS_SRC_ALPHA), this.count = 0, this.pos = null, this.vel = null, this.home = null, this.norm = null, this.speed = null, this.params = {
+			stiffness: 42,
+			damping: 5.2,
+			radius: 130,
+			force: 2600,
+			speedBoost: 14
+		}, this.pointer = {
+			x: -1e6,
+			y: -1e6,
+			vx: 0,
+			vy: 0,
+			speed: 0,
+			active: !1
+		}, this._lastPointer = null, this.dpr = 1, this._raf = 0, this._lastT = 0, this._running = !1, this._onResize = () => this.resize(), window.addEventListener("resize", this._onResize), this._ro = typeof ResizeObserver < "u" ? new ResizeObserver(this._onResize) : null, this._ro?.observe(t), this.resize();
+	}
+	resize() {
+		let { canvas: e } = this;
+		this.dpr = Math.min(window.devicePixelRatio || 1, 2);
+		let t = e.clientWidth, n = e.clientHeight;
+		!t || !n || (e.width = Math.round(t * this.dpr), e.height = Math.round(n * this.dpr), this.gl.viewport(0, 0, e.width, e.height), this.layoutHomes());
+	}
+	layoutHomes() {
+		if (!this.norm) return;
+		let e = this.canvas.clientWidth, t = this.canvas.clientHeight, n = Infinity, r = -Infinity, i = Infinity, a = -Infinity;
+		for (let e = 0; e < this.count; e++) {
+			let t = this.norm[e * 2], o = this.norm[e * 2 + 1];
+			t < n && (n = t), t > r && (r = t), o < i && (i = o), o > a && (a = o);
+		}
+		let o = Math.max(r - n, 1e-6), s = Math.max(a - i, 1e-6), c = Math.min(e / o, t / s) * this.margin, l = e / 2, u = t / 2;
+		for (let e = 0; e < this.count; e++) this.home[e * 2] = l + this.norm[e * 2] * c, this.home[e * 2 + 1] = u + this.norm[e * 2 + 1] * c;
+	}
+	setParticles(e) {
+		let t = e.norm.length / 2;
+		this.count = t, this.norm = e.norm, this.pos = new Float32Array(t * 2), this.vel = new Float32Array(t * 2), this.home = new Float32Array(t * 2), this.speed = new Float32Array(t), this.layoutHomes();
+		let n = this.canvas.clientWidth, r = this.canvas.clientHeight;
+		for (let e = 0; e < t; e++) {
+			if (this.intro === "bloom") {
+				let i = e / t * Math.PI * 2 + e % 7 * .9, a = Math.min(n, r) * .5 * (e * 2654435761 % 1e3 / 1e3);
+				this.pos[e * 2] = this.home[e * 2] + Math.cos(i) * a, this.pos[e * 2 + 1] = this.home[e * 2 + 1] + Math.sin(i) * a;
+			} else {
+				let i = e / t * Math.PI * 2 + e % 7 * .9, a = Math.max(n, r) * (.6 + e * 2654435761 % 1e3 / 2500);
+				this.pos[e * 2] = n / 2 + Math.cos(i) * a, this.pos[e * 2 + 1] = r / 2 + Math.sin(i) * a;
+			}
+			this.vel[e * 2] = 0, this.vel[e * 2 + 1] = 0;
+		}
+		let i = this.gl, a = new Float32Array(t);
+		for (let e = 0; e < t; e++) a[e] = 1.6 + e * 40503 % 1e3 / 1e3 * 1.3;
+		i.bindBuffer(i.ARRAY_BUFFER, this.colorBuf), i.bufferData(i.ARRAY_BUFFER, e.colors, i.STATIC_DRAW), i.bindBuffer(i.ARRAY_BUFFER, this.sizeBuf), i.bufferData(i.ARRAY_BUFFER, a, i.STATIC_DRAW), i.bindBuffer(i.ARRAY_BUFFER, this.posBuf), i.bufferData(i.ARRAY_BUFFER, this.pos, i.DYNAMIC_DRAW), i.bindBuffer(i.ARRAY_BUFFER, this.speedBuf), i.bufferData(i.ARRAY_BUFFER, this.speed, i.DYNAMIC_DRAW);
+	}
+	setPointer(e, t, n) {
+		let r = performance.now(), i = this.pointer;
+		if (this._lastPointer && n) {
+			let n = Math.max((r - this._lastPointer.t) / 1e3, 1e-4), a = (e - this._lastPointer.x) / n, o = (t - this._lastPointer.y) / n;
+			i.vx = i.vx * .7 + a * .3, i.vy = i.vy * .7 + o * .3;
+		}
+		i.x = e, i.y = t, i.active = n, i.speed = Math.hypot(i.vx, i.vy), this._lastPointer = n ? {
+			x: e,
+			y: t,
+			t: r
+		} : null, n || (i.vx = 0, i.vy = 0, i.speed = 0, i.x = -1e6, i.y = -1e6);
+	}
+	step(e) {
+		let { pos: t, vel: n, home: r, speed: i, count: a, params: o, pointer: s } = this;
+		if (!t) return;
+		let c = o.stiffness, l = Math.exp(-o.damping * e), u = o.radius, d = u * u, f = s.x, p = s.y, m = o.force + s.speed * o.speedBoost;
+		for (let o = 0; o < a; o++) {
+			let a = o * 2, s = a + 1, h = t[a], g = t[s], _ = n[a], v = n[s];
+			_ += (r[a] - h) * c * e, v += (r[s] - g) * c * e;
+			let y = h - f, b = g - p, x = y * y + b * b;
+			if (x < d) {
+				let t = Math.sqrt(x) || 1e-4, n = 1 - t / u, r = m * n * n / t;
+				_ += y * r * e, v += b * r * e;
+			}
+			_ *= l, v *= l, h += _ * e, g += v * e, t[a] = h, t[s] = g, n[a] = _, n[s] = v, i[o] = Math.hypot(_, v);
+		}
+	}
+	render() {
+		let e = this.gl;
+		e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), this.count && (e.useProgram(this.program), e.uniform2f(this.loc.resolution, this.canvas.clientWidth, this.canvas.clientHeight), e.uniform1f(this.loc.dpr, this.dpr), e.bindBuffer(e.ARRAY_BUFFER, this.posBuf), e.bufferSubData(e.ARRAY_BUFFER, 0, this.pos), e.enableVertexAttribArray(this.loc.pos), e.vertexAttribPointer(this.loc.pos, 2, e.FLOAT, !1, 0, 0), e.bindBuffer(e.ARRAY_BUFFER, this.speedBuf), e.bufferSubData(e.ARRAY_BUFFER, 0, this.speed), e.enableVertexAttribArray(this.loc.speed), e.vertexAttribPointer(this.loc.speed, 1, e.FLOAT, !1, 0, 0), e.bindBuffer(e.ARRAY_BUFFER, this.colorBuf), e.enableVertexAttribArray(this.loc.color), e.vertexAttribPointer(this.loc.color, 4, e.UNSIGNED_BYTE, !0, 0, 0), e.bindBuffer(e.ARRAY_BUFFER, this.sizeBuf), e.enableVertexAttribArray(this.loc.size), e.vertexAttribPointer(this.loc.size, 1, e.FLOAT, !1, 0, 0), e.drawArrays(e.POINTS, 0, this.count));
+	}
+	start() {
+		if (this._running) return;
+		this._running = !0, this._lastT = performance.now();
+		let e = (t) => {
+			if (!this._running) return;
+			let n = Math.min((t - this._lastT) / 1e3, 1 / 30);
+			this._lastT = t, this.step(n), this.render(), this._raf = requestAnimationFrame(e);
+		};
+		this._raf = requestAnimationFrame(e);
+	}
+	destroy() {
+		this._running = !1, cancelAnimationFrame(this._raf), window.removeEventListener("resize", this._onResize), this._ro?.disconnect();
+		let e = this.gl;
+		e.deleteBuffer(this.posBuf), e.deleteBuffer(this.colorBuf), e.deleteBuffer(this.sizeBuf), e.deleteBuffer(this.speedBuf), e.deleteProgram(this.program);
+	}
+}, n = 1e3, r = 14e3, i = 40;
+function a(e) {
+	let t = new DOMParser().parseFromString(e, "image/svg+xml"), r = t.querySelector("svg");
+	if (!r || t.querySelector("parsererror")) throw Error("Not a valid SVG file");
+	let i = parseFloat(r.getAttribute("width")), a = parseFloat(r.getAttribute("height")), o = r.getAttribute("viewBox");
+	if ((!i || !a) && o) {
+		let e = o.trim().split(/[\s,]+/).map(Number);
+		i = e[2], a = e[3];
+	}
+	(!i || !a) && (i = 512, a = 512), o || r.setAttribute("viewBox", `0 0 ${i} ${a}`);
+	let s = n / Math.max(i, a);
+	return r.setAttribute("width", Math.round(i * s)), r.setAttribute("height", Math.round(a * s)), new XMLSerializer().serializeToString(r);
+}
+function o(e) {
+	return new Promise((t, n) => {
+		let r = URL.createObjectURL(e), i = new Image();
+		i.onload = () => {
+			URL.revokeObjectURL(r), t(i);
+		}, i.onerror = () => {
+			URL.revokeObjectURL(r), n(/* @__PURE__ */ Error("Could not decode image"));
+		}, i.src = r;
+	});
+}
+function s(e, t, n) {
+	let r = [
+		[0, 0],
+		[t - 1, 0],
+		[0, n - 1],
+		[t - 1, n - 1],
+		[t >> 1, 0],
+		[t >> 1, n - 1],
+		[0, n >> 1],
+		[t - 1, n >> 1]
+	], i = 0, a = 0, o = 0, s = 0;
+	for (let [n, c] of r) {
+		let r = (c * t + n) * 4;
+		e[r + 3] > 200 && (i += e[r], a += e[r + 1], o += e[r + 2], s++);
+	}
+	return s < r.length / 2 ? null : [
+		i / s,
+		a / s,
+		o / s
+	];
+}
+function c(e, t, n, r) {
+	let a = r ? s(e, t, n) : null;
+	return {
+		test: (t) => {
+			if (e[t + 3] <= i) return !1;
+			if (!a) return !0;
+			let n = e[t] - a[0], r = e[t + 1] - a[1], o = e[t + 2] - a[2];
+			return n * n + r * r + o * o > 3600;
+		},
+		hasBg: !!a
+	};
+}
+function l(e, t = {}) {
+	let { targetParticles: a = r, removeBackground: o = !0 } = t, s = Math.min(n / Math.max(e.width, e.height, 1), 4), l = Math.max(Math.round(e.width * s), 1), u = Math.max(Math.round(e.height * s), 1), d = document.createElement("canvas");
+	d.width = l, d.height = u;
+	let f = d.getContext("2d", { willReadFrequently: !0 });
+	f.drawImage(e, 0, 0, l, u);
+	let { data: p } = f.getImageData(0, 0, l, u), { test: m, hasBg: h } = c(p, l, u, o), g = 0;
+	for (let e = 0; e < p.length; e += 4) m(e) && g++;
+	if (!g && h) {
+		m = (e) => p[e + 3] > i;
+		for (let e = 0; e < p.length; e += 4) m(e) && g++;
+	}
+	if (!g) throw Error("Image appears to be empty (no visible pixels)");
+	let _ = Math.max(1, Math.round(Math.sqrt(g / a))), v = [], y = [], b = [], x = Infinity, S = -Infinity, C = Infinity, w = -Infinity;
+	for (let e = 0; e < u; e += _) for (let t = 0; t < l; t += _) {
+		let n = (e * l + t) * 4;
+		if (m(n)) {
+			let r = t + ((t * 7919 + e * 104729) % 100 / 100 - .5) * _ * .8, i = e + ((t * 15485 + e * 32452) % 100 / 100 - .5) * _ * .8;
+			v.push(r), y.push(i), b.push(p[n], p[n + 1], p[n + 2], p[n + 3]), r < x && (x = r), r > S && (S = r), i < C && (C = i), i > w && (w = i);
+		}
+	}
+	let T = v.length, E = Math.max(S - x, 1), D = Math.max(w - C, 1), O = (x + S) / 2, k = (C + w) / 2, A = Math.max(E, D), j = new Float32Array(T * 2);
+	for (let e = 0; e < T; e++) j[e * 2] = (v[e] - O) / A, j[e * 2 + 1] = (y[e] - k) / A;
+	return {
+		norm: j,
+		colors: new Uint8Array(b)
+	};
+}
+async function u(e, t = {}) {
+	let n = a(e);
+	return l(await o(new Blob([n], { type: "image/svg+xml" })), t);
+}
+var d = 220;
+async function f(e, t = {}) {
+	let { fontFamily: n = "system-ui", weight: i = 600, colors: a = ["#ffffff"], targetParticles: o = r } = t, s = e.trim();
+	if (!s) throw Error("Text is empty");
+	let c = `${i} ${d}px "${n}", sans-serif`;
+	try {
+		await document.fonts.load(c, s);
+	} catch {}
+	let u = document.createElement("canvas"), f = u.getContext("2d");
+	f.font = c;
+	let p = f.measureText(s), m = p.actualBoundingBoxAscent || d * .8, h = p.actualBoundingBoxDescent || d * .25, g = Math.round(d * .1);
+	if (u.width = Math.ceil(p.width) + 44, u.height = Math.ceil(m + h) + 44, f.font = c, a.length > 1) {
+		let e = f.createLinearGradient(g, 0, u.width - g, 0);
+		a.forEach((t, n) => e.addColorStop(n / (a.length - 1), t)), f.fillStyle = e;
+	} else f.fillStyle = a[0];
+	return f.fillText(s, g, g + m), l(u, { targetParticles: o });
+}
+async function p(e, t = {}) {
+	if (typeof e == "string") {
+		let n = new Image();
+		return n.crossOrigin = "anonymous", await new Promise((t, r) => {
+			n.onload = t, n.onerror = () => r(/* @__PURE__ */ Error("Could not load image URL")), n.src = e;
+		}), l(n, t);
+	}
+	return typeof HTMLImageElement < "u" && e instanceof HTMLImageElement ? l(e, t) : /svg/i.test(e.type) || /\.svg$/i.test(e.name || "") ? u(await e.text(), t) : l(await o(e), t);
+}
+//#endregion
+export { t as i, u as n, f as r, p as t };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "ghostdust",
+  "version": "0.1.0",
+  "description": "Turn text, SVGs, and images into interactive anti-gravity particles.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Daniel Alzein",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dalzein/ghostdust.git"
+  },
+  "homepage": "https://github.com/dalzein/ghostdust#readme",
+  "bugs": {
+    "url": "https://github.com/dalzein/ghostdust/issues"
+  },
+  "keywords": [
+    "particles",
+    "webgl",
+    "canvas",
+    "text-effect",
+    "logo",
+    "animation",
+    "react"
+  ],
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./react": "./dist/react.js"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:lib": "vite build --config vite.lib.config.js",
+    "prepublishOnly": "npm run build:lib",
+    "lint": "oxlint",
+    "preview": "vite preview"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.4",
+    "oxlint": "^1.75.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "vite": "^8.2.0"
+  }
+}