@mkbabb/glass-ui 4.0.1 → 4.1.0

package/dist/goo-dot-matrix.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/goo-dot-matrix";

package/dist/goo-dot-matrix.js

@@ -0,0 +1,591 @@
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { t } from "./usePointerVelocityField-QLsy3_kv.js";
+import { a as n, t as r } from "./useGpuSubstrate-4pTcp6mX.js";
+import { n as i, t as a } from "./compile-nZ1xVYTp.js";
+import { s as o, t as s } from "./color-Cs0-oxYL.js";
+import { t as c } from "./useIntersectionPause-Dbozzjgm.js";
+import { u as l } from "./dotMatrixField-D_x9_1qq.js";
+import { a as u, c as d, d as f, i as p, l as m, n as h, o as g, r as _, s as v, t as y, u as b } from "./uniformBridgeWGPU-CtAKl45L.js";
+import { computed as x, createElementBlock as S, createElementVNode as C, defineComponent as w, normalizeStyle as T, onScopeDispose as E, openBlock as D, ref as ee, useTemplateRef as O, watch as k } from "vue";
+//#region src/components/custom/goo-dot-matrix/constants.ts
+var A = 4, j = 96, M = [{
+	L: .92,
+	C: .03,
+	h: 78
+}, {
+	L: .84,
+	C: .07,
+	h: 62
+}], N = {
+	variant: "dot-field",
+	field: {
+		...f,
+		variant: "blob"
+	},
+	dotPixelSize: 10,
+	dotMin: .18,
+	dotMax: .42,
+	fieldFloor: .06,
+	dotBrightFloor: .35,
+	cols: 56,
+	flowAmt: .35,
+	palette: M,
+	background: "transparent",
+	interactive: !1,
+	pointerMode: "repel",
+	pointerRadius: .35,
+	respectReducedMotion: !0
+}, P = {
+	s8: 0,
+	s9: 4,
+	s10: 8,
+	s11: 12
+};
+function F(e) {
+	return +(e === "dot-dither");
+}
+function I(e) {
+	return e === "attract" ? -1 : 1;
+}
+function L() {
+	return {
+		x: 0,
+		y: 0,
+		active: 0,
+		bloom: 0
+	};
+}
+function R() {
+	let e = /* @__PURE__ */ new ArrayBuffer(64);
+	return {
+		buffer: e,
+		f32: new Float32Array(e)
+	};
+}
+function z(e, t, n, r, i) {
+	let { f32: a } = e;
+	return a[P.s8 + 0] = F(t.variant), a[P.s8 + 1] = Math.max(t.dotPixelSize * r, 4), a[P.s8 + 2] = t.fieldFloor, a[P.s8 + 3] = t.dotBrightFloor, a[P.s9 + 0] = t.dotMin, a[P.s9 + 1] = t.dotMax, a[P.s9 + 2] = t.pointerRadius, a[P.s9 + 3] = I(t.pointerMode), a[P.s10 + 0] = n.w, a[P.s10 + 1] = n.h, a[P.s10 + 2] = r, a[P.s10 + 3] = 0, a[P.s11 + 0] = t.interactive ? i.active : 0, a[P.s11 + 1] = i.x, a[P.s11 + 2] = i.y, a[P.s11 + 3] = i.bloom, e;
+}
+//#endregion
+//#region src/components/custom/goo-dot-matrix/shaders/goo-dot.wgsl.ts
+var B = p.indexOf("// ── Full-screen triangle vertex stage"), V = `
+${B >= 0 ? p.slice(0, B) : p}
+
+// ── Dot-grid uniforms (the s8/s9 lanes — see uniformBridgeWGPU.ts; the SoT extend) ──
+struct DotUniforms {
+  // s8: (uDotMode, uDotPixelSize, uFieldFloor, uDotBrightFloor)
+  s8: vec4<f32>,
+  // s9: (uDotMin, uDotMax, uPointerRadius, uPointerMode)
+  s9: vec4<f32>,
+  // s10: (uResX, uResY, uDpr, _pad) — the device-px resolution the cell grid quantizes to
+  s10: vec4<f32>,
+  // s11: (uPointerActive, uPointerX, uPointerY, uBloom) — the dot-cursor influence
+  s11: vec4<f32>,
+};
+@group(0) @binding(1) var<uniform> dg: DotUniforms;
+
+// The classic ordered-dither Bayer macros (Codrops — the §T2 halftone). Bayer8 is the
+// perceptual ceiling ("beyond 8×8 the gain is minimal"). The metaball field already carries
+// the warped-FBM membrane, so the dither inherits the organic edge for free.
+fn bayer2(a0: vec2<f32>) -> f32 {
+  let a = floor(a0);
+  return fract(a.x / 2.0 + a.y * a.y * 0.75);
+}
+fn bayer4(a: vec2<f32>) -> f32 {
+  return bayer2(0.5 * a) * 0.25 + bayer2(a);
+}
+fn bayer8(a: vec2<f32>) -> f32 {
+  return bayer4(0.5 * a) * 0.25 + bayer2(a);
+}
+
+// ── Register A: the full-screen triangle vertex stage (the metaball idiom — no buffer) ──
+struct DotVSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,   // [0,1] across the canvas (the metaball.vert convention)
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> DotVSOut {
+  var p = vec2<f32>(-1.0, -1.0);
+  if (vi == 1u) { p = vec2<f32>(3.0, -1.0); }
+  else if (vi == 2u) { p = vec2<f32>(-1.0, 3.0); }
+  var out: DotVSOut;
+  out.pos = vec4<f32>(p, 0.0, 1.0);
+  out.uv = p * 0.5 + 0.5;
+  return out;
+}
+
+// ── Register A: the dot-stamp fragment (§T1/§T2 — the dot-grid OUTPUT over sceneDistG) ──
+@fragment
+fn fs_main(in: DotVSOut) -> @location(0) vec4<f32> {
+  let uDotMode        = dg.s8.x;          // 0 = smooth field-driven dot, 1 = Bayer dither
+  let uDotPixelSize   = max(dg.s8.y, 1.0);
+  let uFieldFloor     = dg.s8.z;
+  let uDotBrightFloor = dg.s8.w;
+  let uDotMin         = dg.s9.x;
+  let uDotMax         = dg.s9.y;
+  let uPointerRadius  = max(dg.s9.z, 1e-4);
+  let uPointerMode    = dg.s9.w;          // +1 repel (push out), -1 attract (pull in)
+  let uRes            = dg.s10.xy;
+  let pAct            = dg.s11.x;
+  let cursor          = dg.s11.yz;        // NDC-ish [-0.5,0.5] (the field's uv space)
+  let uBloom          = dg.s11.w;
+
+  let bodyR = u.s0.y + breath(u.s0.z) * u.s0.w;
+
+  // 1. Quantize fragCoord to a dot grid (cell = uDotPixelSize device px). The fragment's
+  //    pixel coordinate is in.pos.xy (device px).
+  let fragCoord = in.pos.xy;
+  let cell      = floor(fragCoord / uDotPixelSize);
+  let cellCtr   = (cell + 0.5) * uDotPixelSize;
+
+  // 2. The field AT THE CELL CENTER (so every fragment in a cell agrees on ONE dot). The cell
+  //    center maps to the field uv = (cellCtr/res - 0.5) — the SAME uv the metaball pass uses.
+  let cellCtrUv = cellCtr / uRes - 0.5;
+
+  // 3. The dot-cursor influence (§T7 — the Metal dotted-bg idiom): dots near the cursor swell
+  //    + brighten; the cell uv shifts toward/away (attract/repel). The field-lean is carried
+  //    by the metaball pass's own uPointer deformation inside sceneDistG (KEEP); this is the
+  //    LOCAL dot influence on TOP.
+  let toCursor   = cellCtrUv - cursor;
+  let cdist      = length(toCursor);
+  let influence  = (1.0 - smoothstep(0.0, uPointerRadius, cdist)) * pAct;
+  let sampleUv   = cellCtrUv + normalize(toCursor + vec2<f32>(1e-6)) * influence * uPointerMode * 0.03;
+
+  // 4. The field value at the cell — thickness = clamp(-d/bodyR, 0, 1) (metaball.wgsl line 500,
+  //    the one-line re-use). 0 at the silhouette → 1 deep in the core — the goo↔dot bridge.
+  let scene = sceneDistG(sampleUv);
+  let fCell = clamp(-scene.x / max(bodyR, 1e-4), 0.0, 1.0);
+
+  // 5. The dot radius (px) — field-driven: dense+big inside, small at the rim, 0 outside the
+  //    floor. The cursor swells the near-cursor dots (mix toward 1.5× + the accel bloom).
+  let cellHalf = uDotPixelSize * 0.5;
+  let baseR    = (uDotMin + (uDotMax - uDotMin) * smoothstep(uFieldFloor, 1.0, fCell)) * cellHalf;
+  let dotR     = baseR * (1.0 + influence * 0.5 + uBloom * influence);
+
+  var mask = 1.0;
+  if (uDotMode > 0.5) {
+    // §T2 Register-A dither: ORDERED-dither the field thickness into ON/OFF dots — denser at
+    // the core, sparser at the rim (the classic halftone). The dot still AA-stamps below.
+    mask = step(0.5, fCell + bayer8(cell) - 0.5);
+  }
+
+  // 6. The antialiased circle at the cell center (the fwidth-feathered Book-of-Shaders dot —
+  //    the ONE AA canon, ~1px band at any DPR). fwidth lives in fs_main ONLY.
+  let pd  = length(fragCoord - cellCtr);
+  let aa  = max(fwidth(pd), 1e-4);
+  let dot = (1.0 - smoothstep(dotR - aa, dotR + aa, pd)) * mask;
+
+  // 7. The brightness/color ALSO reads fCell (dim outside, bright inside) on the SAME OKLCh
+  //    ramp the metaball pass samples (the ONE color source). The tone reads DEPTH (the core
+  //    is the bright cream stop, the rim the amber stop) so the field reads TONALLY on both
+  //    grounds; the brightness multiplies the sampled stop's luminance.
+  let bright = uDotBrightFloor + (1.0 - uDotBrightFloor) * fCell + uBloom * influence * 0.6;
+  let tone   = clamp(1.0 - fCell, 0.0, 1.0);
+  var oklch  = samplePaletteOklch(tone);
+  oklch.x    = clamp(oklch.x * clamp(bright, 0.0, 1.6), 0.0, 1.0);
+  let lin    = oklabToLinearSrgb(oklchToOklab(gamutClampOklch(oklch)));
+  let rgb    = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+
+  // No dot where the field is below the floor (the dots stop at the silhouette band).
+  let alpha = dot * step(uFieldFloor, fCell);
+  if (alpha < 0.002) { discard; }
+
+  // Premultiplied-alpha output (the warm-cream dots additive over the clear).
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, H = g.indexOf("void main()"), U = H >= 0 ? g.slice(0, H) : g, W = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition * 0.5 + 0.5;\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}", G = `${U}
+
+// ── Dot-grid uniforms (the s8/s9 lanes — see uniformBridgeWGPU.ts; the SoT extend) ──
+uniform float uDotMode;        // 0 = smooth field-driven dot, 1 = Bayer dither
+uniform float uDotPixelSize;   // device-px cell size
+uniform float uFieldFloor;     // no dot below this field value
+uniform float uDotBrightFloor; // dim-outside brightness floor
+uniform float uDotMin;         // rim dot radius (fraction of the cell)
+uniform float uDotMax;         // core dot radius (fraction of the cell)
+uniform float uDotPointerRadius;
+uniform float uDotPointerMode; // +1 repel, -1 attract
+uniform float uDotPointerActive;
+uniform vec2  uDotCursor;      // field-uv cursor [-0.5,0.5]
+uniform float uDotBloom;       // accel-burst bloom
+
+// The Codrops Bayer8 ordered-dither macros (the §T2 halftone).
+float bayer2(vec2 a0){ vec2 a = floor(a0); return fract(a.x / 2.0 + a.y * a.y * 0.75); }
+float bayer4(vec2 a){ return bayer2(0.5 * a) * 0.25 + bayer2(a); }
+float bayer8(vec2 a){ return bayer4(0.5 * a) * 0.25 + bayer2(a); }
+
+void main() {
+  float bodyR = uBodyRadius + breath(uPulsePhase) * uPulseAmp;
+
+  // 1. Quantize gl_FragCoord (device px) to a dot grid (cell = uDotPixelSize device px).
+  vec2 fragCoord = gl_FragCoord.xy;
+  float pix = max(uDotPixelSize, 1.0);
+  vec2 cell = floor(fragCoord / pix);
+  vec2 cellCtr = (cell + 0.5) * pix;
+
+  // 2. The field uv at the cell center (the SAME uv the metaball pass uses).
+  vec2 cellCtrUv = cellCtr / uResolution - 0.5;
+
+  // 3. The dot-cursor influence (the §T7 local influence on TOP of the field-lean).
+  vec2 toCursor = cellCtrUv - uDotCursor;
+  float cdist = length(toCursor);
+  float influence = (1.0 - smoothstep(0.0, max(uDotPointerRadius, 1e-4), cdist)) * uDotPointerActive;
+  vec2 sampleUv = cellCtrUv + normalize(toCursor + vec2(1e-6)) * influence * uDotPointerMode * 0.03;
+
+  // 4. The field value at the cell — thickness = clamp(-d/bodyR, 0, 1) (the goo↔dot bridge).
+  vec3 scene = sceneDistG(sampleUv);
+  float fCell = clamp(-scene.x / max(bodyR, 1e-4), 0.0, 1.0);
+
+  // 5. The field-driven dot radius (px) + the cursor swell + the accel bloom.
+  float cellHalf = pix * 0.5;
+  float baseR = (uDotMin + (uDotMax - uDotMin) * smoothstep(uFieldFloor, 1.0, fCell)) * cellHalf;
+  float dotR = baseR * (1.0 + influence * 0.5 + uDotBloom * influence);
+
+  float mask = 1.0;
+  if (uDotMode > 0.5) {
+    mask = step(0.5, fCell + bayer8(cell) - 0.5);
+  }
+
+  // 6. The crisp fwidth-feathered SDF dot (the ONE AA canon, ~1px band at any DPR).
+  float pd = length(fragCoord - cellCtr);
+  float aa = max(fwidth(pd), 1e-4);
+  float dot = (1.0 - smoothstep(dotR - aa, dotR + aa, pd)) * mask;
+
+  // 7. The brightness/color reads fCell on the SAME OKLCh ramp (the ONE color source).
+  float bright = uDotBrightFloor + (1.0 - uDotBrightFloor) * fCell + uDotBloom * influence * 0.6;
+  float tone = clamp(1.0 - fCell, 0.0, 1.0);
+  vec3 oklch = samplePaletteOklch(tone);
+  oklch.x = clamp(oklch.x * clamp(bright, 0.0, 1.6), 0.0, 1.0);
+  vec3 lin = oklabToLinearSrgb(oklchToOklab(gamutClampOklch(oklch)));
+  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+
+  float alpha = dot * step(uFieldFloor, fCell);
+  if (alpha < 0.002) discard;
+
+  fragColor = vec4(rgb * alpha, alpha);
+}`, K = 64, q = 8, J = 1, Y = 2, X = "[GooDotMatrix]";
+function Z(e, t) {
+	let n = e.createShaderModule({
+		label: `${X} goo-dot.wgsl`,
+		code: V
+	}), r = e.createBuffer({
+		label: `${X} field-uniforms`,
+		size: y,
+		usage: K | q
+	}), i = e.createBuffer({
+		label: `${X} dot-uniforms`,
+		size: 64,
+		usage: K | q
+	}), a = e.createBindGroupLayout({
+		label: `${X} bgl`,
+		entries: [{
+			binding: 0,
+			visibility: J | Y,
+			buffer: { type: "uniform" }
+		}, {
+			binding: 1,
+			visibility: Y,
+			buffer: { type: "uniform" }
+		}]
+	});
+	return {
+		pipeline: e.createRenderPipeline({
+			label: `${X} pipeline`,
+			layout: e.createPipelineLayout({ bindGroupLayouts: [a] }),
+			vertex: {
+				module: n,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: n,
+				entryPoint: "fs_main",
+				targets: [{
+					format: t,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}),
+		bindGroup: e.createBindGroup({
+			label: `${X} bg`,
+			layout: a,
+			entries: [{
+				binding: 0,
+				resource: { buffer: r }
+			}, {
+				binding: 1,
+				resource: { buffer: i }
+			}]
+		}),
+		fieldBuffer: r,
+		dotBuffer: i,
+		fieldScratch: h(),
+		dotScratch: R()
+	};
+}
+function Q(e) {
+	let t = a(e, e.VERTEX_SHADER, W, X), n = a(e, e.FRAGMENT_SHADER, G, X), r = i(e, t, n, X);
+	e.useProgram(r);
+	let o = e.createVertexArray();
+	e.bindVertexArray(o);
+	let s = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, s), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		-1,
+		1,
+		1,
+		-1,
+		1,
+		1
+	]), e.STATIC_DRAW);
+	let c = e.getAttribLocation(r, "aPosition");
+	e.enableVertexAttribArray(c), e.vertexAttribPointer(c, 2, e.FLOAT, !1, 0, 0);
+	let l = {};
+	for (let t of b) l[t] = e.getUniformLocation(r, t);
+	let u = [], d = [], f = [];
+	for (let t = 0; t < 4; t++) u.push(e.getUniformLocation(r, `uSatPos[${t}]`)), d.push(e.getUniformLocation(r, `uSatRadius[${t}]`)), f.push(e.getUniformLocation(r, `uSatOpacity[${t}]`));
+	let p = [], m = [];
+	for (let t = 0; t < 15; t++) p.push(e.getUniformLocation(r, `uTrailPos[${t}]`)), m.push(e.getUniformLocation(r, `uTrailRadius[${t}]`));
+	let h = [];
+	for (let t = 0; t < 4; t++) h.push(e.getUniformLocation(r, `uPalette[${t}]`));
+	let g = {
+		U: l,
+		satPosLocs: u,
+		satRadLocs: d,
+		satOpLocs: f,
+		trailPosLocs: p,
+		trailRadLocs: m,
+		paletteLocs: h
+	}, _ = {
+		mode: e.getUniformLocation(r, "uDotMode"),
+		pix: e.getUniformLocation(r, "uDotPixelSize"),
+		floor: e.getUniformLocation(r, "uFieldFloor"),
+		bright: e.getUniformLocation(r, "uDotBrightFloor"),
+		min: e.getUniformLocation(r, "uDotMin"),
+		max: e.getUniformLocation(r, "uDotMax"),
+		pr: e.getUniformLocation(r, "uDotPointerRadius"),
+		pm: e.getUniformLocation(r, "uDotPointerMode"),
+		pa: e.getUniformLocation(r, "uDotPointerActive"),
+		cursor: e.getUniformLocation(r, "uDotCursor"),
+		bloom: e.getUniformLocation(r, "uDotBloom")
+	};
+	return e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), {
+		prog: r,
+		vs: t,
+		fs: n,
+		buf: s,
+		vao: o,
+		locs: g,
+		dU: _
+	};
+}
+//#endregion
+//#region src/components/custom/goo-dot-matrix/composables/useGooDotMatrix.ts
+function $(e, i) {
+	let { config: a } = i, l = i.mode ?? "live", f = a.field, p = ee(null), h = m(), g = d(p), y = v(f, "goo-dot"), b = t({ respectReducedMotion: a.respectReducedMotion }), x = L(), S = /* @__PURE__ */ new Map();
+	function C(e) {
+		let t = S.get(e);
+		if (t) return t;
+		let n = o(s(e));
+		return S.size > 256 && S.clear(), S.set(e, n), n;
+	}
+	let w = a.palette.map((e) => `oklch(${e.L} ${e.C} ${e.h})`), T = w[w.length - 1] ?? "oklch(0.92 0.03 78)", D = null, O = !1, k = 0, A = 0;
+	function j(e) {
+		let t = k ? (e - k) * 1e3 : 16;
+		k = e;
+		let n = Math.max(0, Math.min(t, 50)), r = D?.reducedMotion ?? !1, i = r || O ? 0 : f.tempo, o = i * n;
+		if (A += o, i > 0 && g.active.value) {
+			let e = g.pointer.value;
+			b.setPointer(e.x * .5 + .5, e.y * .5 + .5);
+		}
+		if (b.tick(i === 0 ? 0 : n), r || h.update({
+			pointerActive: g.active.value,
+			clicked: g.consumeClick(),
+			idleMs: g.idleMs()
+		}), h.tick(o), r ? g.rest() : g.tick(o), y.tick(A, h.params.value), a.interactive && g.active.value && i > 0) {
+			let e = g.pointer.value;
+			x.x = e.x * .5, x.y = e.y * .5, x.active += (1 - x.active) * .2, a.pointerMode, x.bloom = Math.max(x.bloom * .9, b.burst.value);
+		} else x.active += (0 - x.active) * .12, x.bloom *= .9;
+		return {
+			params: h.params.value,
+			rgb: C(T),
+			simTimeMs: A,
+			timeSec: e,
+			resolveColor: C,
+			rimColor: f.surface.rimColor,
+			paletteStops: w
+		};
+	}
+	function M() {
+		return O ? !1 : !h.isSettled() || !g.isAtRest() || !y.isQuiescent() || x.active > .001 || x.bloom > .001;
+	}
+	function N(e) {
+		return function(t, r, i) {
+			let o = Z(t, i);
+			function s() {
+				let t = n(), r = e.clientWidth || f.geometry.canvasSize, i = e.clientHeight || f.geometry.canvasSize, a = Math.max(1, Math.round(r * t)), o = Math.max(1, Math.round(i * t));
+				(e.width !== a || e.height !== o) && (e.width = a, e.height = o);
+			}
+			function c(i) {
+				let s = j(i);
+				_(o.fieldScratch, e, f, g, y, s), t.queue.writeBuffer(o.fieldBuffer, 0, o.fieldScratch.buffer), z(o.dotScratch, a, {
+					w: e.width || 1,
+					h: e.height || 1
+				}, n(), x), t.queue.writeBuffer(o.dotBuffer, 0, o.dotScratch.buffer);
+				let c = r.getCurrentTexture().createView(), l = t.createCommandEncoder({ label: `${X} frame` }), u = l.beginRenderPass({ colorAttachments: [{
+					view: c,
+					clearValue: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					loadOp: "clear",
+					storeOp: "store"
+				}] });
+				u.setPipeline(o.pipeline), u.setBindGroup(0, o.bindGroup), u.draw(3, 1, 0, 0), u.end(), t.queue.submit([l.finish()]);
+			}
+			return {
+				frame: c,
+				shouldContinue: M,
+				resize: s,
+				teardown: () => {
+					o.fieldBuffer.destroy(), o.dotBuffer.destroy();
+				}
+			};
+		};
+	}
+	function P(e) {
+		return function(t) {
+			let r = Q(t), { prog: i, vao: o, locs: s, dU: c } = r;
+			function l() {
+				let r = n(), i = e.clientWidth || f.geometry.canvasSize, a = e.clientHeight || f.geometry.canvasSize, o = Math.max(1, Math.round(i * r)), s = Math.max(1, Math.round(a * r));
+				(e.width !== o || e.height !== s) && (e.width = o, e.height = s), t.viewport(0, 0, e.width, e.height);
+			}
+			function d(r) {
+				let l = j(r);
+				t.useProgram(i);
+				let d = n();
+				t.uniform1f(c.mode, +(a.variant === "dot-dither")), t.uniform1f(c.pix, Math.max(a.dotPixelSize * d, 4)), t.uniform1f(c.floor, a.fieldFloor), t.uniform1f(c.bright, a.dotBrightFloor), t.uniform1f(c.min, a.dotMin), t.uniform1f(c.max, a.dotMax), t.uniform1f(c.pr, a.pointerRadius), t.uniform1f(c.pm, I(a.pointerMode)), t.uniform1f(c.pa, a.interactive ? x.active : 0), t.uniform2f(c.cursor, x.x, x.y), t.uniform1f(c.bloom, x.bloom), u(t, i, o, s, e, f, g, y, l);
+			}
+			return {
+				frame: d,
+				shouldContinue: M,
+				resize: l,
+				teardown: () => {
+					t.deleteProgram(r.prog), t.deleteShader(r.vs), t.deleteShader(r.fs), t.deleteBuffer(r.buf), t.deleteVertexArray(r.vao);
+				}
+			};
+		};
+	}
+	c(e, {
+		pause: () => D?.suspend("off-screen-io"),
+		resume: () => D?.resume("off-screen-io")
+	}, {
+		rootMargin: "200px",
+		pauseWhenHidden: !1
+	});
+	let F = () => {
+		let t = e.value;
+		return t ? (D || (p.value = t.parentElement ?? t, D = r(t, {
+			mode: l,
+			contextAttrs: {
+				alpha: !0,
+				premultipliedAlpha: !0,
+				antialias: !1,
+				preserveDrawingBuffer: !1
+			},
+			respectReducedMotion: a.respectReducedMotion,
+			setupWGPU: N(t),
+			setupGL: P(t)
+		}), D.armAsync()), D) : null;
+	};
+	queueMicrotask(() => F());
+	let R = {
+		get backend() {
+			return F()?.backend ?? "webgpu";
+		},
+		pause: () => {
+			O = !0, F()?.suspend("manual");
+		},
+		resume: () => {
+			O = !1, F()?.resume("manual");
+		},
+		wake: () => F()?.wake(),
+		renderAt: (e) => F()?.renderAt(e),
+		get reducedMotion() {
+			return D?.reducedMotion ?? !1;
+		},
+		dispose: () => {
+			b.dispose(), D?.dispose(), D = null;
+		}
+	};
+	return E(() => R.dispose()), R;
+}
+//#endregion
+//#region src/components/custom/goo-dot-matrix/GooDotMatrix.vue
+var te = /* @__PURE__ */ e(/* @__PURE__ */ w({
+	__name: "GooDotMatrix",
+	props: {
+		config: { default: () => N },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:paused"],
+	setup(e, { expose: t }) {
+		let n = O("canvasRef"), r = $(n, { config: e.config });
+		k(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = x(() => {
+			let t = e.config.background;
+			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		});
+		return t({
+			pause: r.pause,
+			resume: r.resume,
+			wake: r.wake,
+			renderAt: r.renderAt
+		}), (e, t) => (D(), S("div", {
+			class: "goo-dot-matrix-wrapper",
+			style: T(i.value ? { background: i.value } : void 0)
+		}, [C("canvas", {
+			ref_key: "canvasRef",
+			ref: n,
+			class: "goo-dot-matrix-canvas",
+			"aria-hidden": "true",
+			"data-testid": "goo-dot-matrix-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__scopeId", "data-v-2580c8f0"]]);
+//#endregion
+//#region src/components/custom/goo-dot-matrix/composables/gooDotLattice.ts
+function ne(e, t, n) {
+	let r = Math.max(t, 1), i = e % r, a = Math.floor(e / r), o = (r - 1) / 2;
+	return {
+		x: (i - o) * n,
+		y: (a - o) * n
+	};
+}
+function re(e) {
+	let t = Math.max(e, 1);
+	return t * t;
+}
+//#endregion
+export { N as DEFAULT_GOO_DOT_CONFIG, te as GooDotMatrix, j as MAX_LATTICE_COLS, A as MIN_DOT_PIXEL_SIZE, M as WARM_IDENTITY_PALETTE, l as fibonacciDot, ne as gridOrigin, re as latticeInstanceCount, $ as useGooDotMatrix };

package/dist/handmark.js

@@ -1,5 +1,5 @@
 import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { n as t } from "./prng-Za0Rmgag.js";
+import { n as t } from "./prng-B-d9eYX8.js";
 import { Fragment as n, computed as r, createCommentVNode as i, createElementBlock as a, defineComponent as o, normalizeClass as s, normalizeStyle as c, onBeforeUnmount as l, onMounted as u, openBlock as d, ref as f, renderList as p, renderSlot as m, unref as h, useId as g, watch as _ } from "vue";
 import { catmullRomToBezier as v, ellipsePoints as y, perturbPoints as b, perturbPointsClosed as x, pointsToLinear as S, useLineBoil as C, wobbleLinePoints as w } from "@mkbabb/pencil-boil";
 //#region src/components/custom/handmark/brush.ts

package/dist/hover-card.js

@@ -1,2 +1,2 @@
-import { n as e, r as t, t as n } from "./HoverCardContent-b2uaAMRR.js";
+import { n as e, r as t, t as n } from "./HoverCardContent-Bel1gdLZ.js";
 export { t as HoverCard, n as HoverCardContent, e as HoverCardTrigger };

package/dist/hover-popover.js

@@ -1,2 +1,2 @@
-import { t as e } from "./HoverPopover-CbqbNwgU.js";
+import { t as e } from "./HoverPopover-BcIxvyqZ.js";
 export { e as HoverPopover };

package/dist/icon-chip.js

@@ -1,2 +1,2 @@
-import { t as e } from "./IconChip-BTD-nay5.js";
+import { t as e } from "./IconChip-DhbdGdFQ.js";
 export { e as IconChip };

package/dist/icon-tooltip.js

@@ -1,2 +1,2 @@
-import { t as e } from "./IconTooltip-Bl8gFZ8d.js";
+import { t as e } from "./IconTooltip-B0zimd2H.js";
 export { e as IconTooltip };

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export * from "./components/custom/hover-popover";
 export * from "./components/custom/configurator";
 export * from "./components/custom/scrolling-text";
 export * from "./components/custom/icon-chip";
+export * from "./components/custom/split-chars";
 export * from "./composables/reactive";
 export * from "./composables/dom";
 export * from "./composables/glass";
@@ -47,4 +48,5 @@ export { vReveal } from "./composables/motion/vReveal";
 export { useTextHighlight, type HighlightMatcher, type UseTextHighlightControls, } from "./composables/motion/useTextHighlight";
 export { useLiquidFlex, type LiquidFlexAxis, type UseLiquidFlexParams, type UseLiquidFlexReturn, } from "./composables/motion/useLiquidFlex";
 export { usePointerVelocityField, type PointerVec2, type UsePointerVelocityField, type UsePointerVelocityFieldOptions, } from "./composables/motion/usePointerVelocityField";
+export { useCharStagger, type UseCharStaggerOptions, type UseCharStaggerReturn, } from "./composables/motion/useCharStagger";
 export * from "./utils";

package/dist/instrument-chassis.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./InstrumentChassis-Bx0F_q5g.js";
+import { n as e, t } from "./InstrumentChassis-CxsHSyMj.js";
 export { e as ChassisDivider, t as InstrumentChassis };

package/dist/keyboard.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, r, t as i } from "./useKeyboardShortcuts-BXWXOZ-9.js";
+import { a as e, i as t, n, r, t as i } from "./useKeyboardShortcuts-BPRp33Im.js";
 export { i as formatCombo, n as formatComboParts, r as isMac, t as registerShortcut, e as useRegisteredShortcuts };