@mkbabb/glass-ui 4.0.0 → 4.0.1

package/dist/concentric.js

@@ -0,0 +1,562 @@
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { n as t, r as n } from "./procedural-color.glsl-CIFsJhwI.js";
+import { a as r, n as i, r as a, u as o } from "./procedural-color.wgsl-CToRHugY.js";
+import { c as s } from "./color-DweYl7pE.js";
+import { computed as c, createElementBlock as l, createElementVNode as u, defineComponent as d, normalizeStyle as f, onScopeDispose as p, openBlock as m, useTemplateRef as h, watch as g } from "vue";
+//#region src/components/custom/concentric/shaders/concentric.wgsl.ts
+var _ = `
+const PI: f32 = 3.141592653589793;
+const TAU: f32 = 6.283185307179586;
+const RING_GRAVITY: f32 = 9.81;
+const MAX_RINGS: i32 = 8;
+const MAX_CENTERS: i32 = 4;
+const MAX_RING_STOPS: i32 = 4;
+
+// ── Concentric uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+struct ConcentricUniforms {
+  // u0: (uTime, uSpeed, uAxisA, uAxisB)
+  u0: vec4<f32>,
+  // ints: (uCenterCount, uRingCount, uStopCount, _pad)
+  ints: vec4<i32>,
+  // bg: (background.rgb (linear), hasBackground)
+  bg: vec4<f32>,
+  // norm: (uFieldNorm, uAspect, _pad, _pad) — field → [0,1] scale
+  norm: vec4<f32>,
+  // each ring row: (amplitude, wavelength, phase, _pad)
+  rings: array<vec4<f32>, 8>,
+  // each center row: (x, y, weight, _pad)
+  centers: array<vec4<f32>, 4>,
+  // each palette stop: linear-sRGB rgb + _pad
+  palette: array<vec4<f32>, 4>,
+};
+
+@group(0) @binding(0) var<uniform> u: ConcentricUniforms;
+
+${i}
+${a}
+
+// Full-screen-triangle (the pilot idiom): NDC corners (-1,-1),(3,-1),(-1,3) cover the
+// viewport from a single 3-vertex draw — no vertex buffer.
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,  // domain [-1,1]², aspect-corrected x
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VSOut {
+  var corners = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0),
+  );
+  let c = corners[vi];
+  var out: VSOut;
+  out.pos = vec4<f32>(c, 0.0, 1.0);
+  // aspect-correct so the rings stay circular under the ellipsoidal norm (NOT squashed
+  // by the canvas aspect): widen the domain x by the aspect ratio.
+  out.uv = vec2<f32>(c.x, c.y);
+  return out;
+}
+
+// The ellipsoidal radial distance ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²). The single radial
+// metric (transcribes ringField.ts ellipsoidalRadius).
+fn ellipsoidalRadius(p: vec2<f32>, center: vec2<f32>, axisA: f32, axisB: f32) -> f32 {
+  let dx = (p.x - center.x) / max(axisA, 1e-4);
+  let dy = (p.y - center.y) / max(axisB, 1e-4);
+  return sqrt(dx * dx + dy * dy);
+}
+
+// The radial-Fourier ring-interference value f(p,t) — the multi-center weighted sum of
+// radial sinusoids (transcribes ringField.ts sampleRingField line-for-line).
+fn sampleRingField(p: vec2<f32>, t: f32) -> f32 {
+  var acc = 0.0;
+  let speed = u.u0.y;
+  let axisA = u.u0.z;
+  let axisB = u.u0.w;
+  let centerCount = u.ints.x;
+  let ringCount = u.ints.y;
+  for (var j = 0; j < MAX_CENTERS; j = j + 1) {
+    if (j >= centerCount) { break; }
+    let cj = u.centers[j];
+    let radius = ellipsoidalRadius(p, cj.xy, axisA, axisB);
+    var centerSum = 0.0;
+    for (var i = 0; i < MAX_RINGS; i = i + 1) {
+      if (i >= ringCount) { break; }
+      let r = u.rings[i];
+      let k = TAU / max(r.y, 1e-4);
+      // ω = √(g·k); speed scales the travel (the shared dispersion law).
+      let omega = sqrt(RING_GRAVITY * k) * speed;
+      let theta = k * radius - omega * t + r.z;
+      centerSum = centerSum + r.x * sin(theta);
+    }
+    acc = acc + centerSum * cj.z;
+  }
+  return acc;
+}
+
+// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+fn samplePaletteLin(t: f32) -> vec3<f32> {
+  let stopCount = u.ints.z;
+  if (stopCount <= 1) { return u.palette[0].rgb; }
+  let n = f32(stopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let f = ft - f32(i0);
+  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);
+  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  // aspect-correct the domain x so the rings read circular under the ellipsoidal norm.
+  let aspect = max(u.norm.y, 1e-4);
+  let p = vec2<f32>(in.uv.x * aspect, in.uv.y);
+  let t = u.u0.x;
+
+  let raw = sampleRingField(p, t);
+  // Normalize the field → [0,1] for the palette ramp (uFieldNorm is the amplitude scale).
+  let v = clamp(0.5 + raw * u.norm.x, 0.0, 1.0);
+
+  let lin = samplePaletteLin(v);
+  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+
+  // Premultiplied-alpha output over the (transparent / themed) ground.
+  let hasBg = u.bg.w;
+  if (hasBg > 0.5) {
+    // opaque themed ground: the field paints fully opaque.
+    return vec4<f32>(rgb, 1.0);
+  }
+  // transparent ground: the field's alpha rides its own brightness so the page reads
+  // through the troughs (the ring crests carry the ink; the calm field is faint).
+  let alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, v = 9.81, y = Math.PI * 2;
+function b(e, t, n, r) {
+	let i = (e.x - t.x) / Math.max(n, 1e-4), a = (e.y - t.y) / Math.max(r, 1e-4);
+	return Math.sqrt(i * i + a * a);
+}
+function x(e, t, n, r, i, a, o) {
+	let s = 0;
+	for (let c of n) {
+		let n = b(e, c, i, a), l = 0;
+		for (let e of r) {
+			let r = y / Math.max(e.wavelength, 1e-4), i = Math.sqrt(v * r) * o, a = r * n - i * t + e.phase;
+			l += e.amplitude * Math.sin(a);
+		}
+		s += l * c.weight;
+	}
+	return s;
+}
+function S(e = 5) {
+	let t = [], n = .7;
+	for (let r = 0; r < e; r++) {
+		let e = y / n, i = Math.exp(-1 / (e * 1.4) ** 2) / (e * e);
+		t.push({
+			amplitude: i * .9,
+			wavelength: n,
+			phase: r * 1.618033 % y
+		}), n *= .62;
+	}
+	return t;
+}
+//#endregion
+//#region src/components/custom/concentric/constants.ts
+var C = 8, w = 4, T = 4, E = [
+	{
+		L: .94,
+		C: .025,
+		h: 80
+	},
+	{
+		L: .82,
+		C: .075,
+		h: 62
+	},
+	{
+		L: .66,
+		C: .105,
+		h: 44
+	}
+], D = S(5), O = [{
+	x: -.22,
+	y: -.14,
+	weight: 1
+}, {
+	x: .28,
+	y: .2,
+	weight: .7
+}], k = {
+	centers: O,
+	ringComponents: D,
+	axisRatio: [1, .62],
+	speed: .5,
+	palette: E,
+	background: "transparent",
+	interactive: !1,
+	respectReducedMotion: !0
+}, A = 320, j = {
+	u0: 0,
+	ints: 4,
+	bg: 8,
+	norm: 12,
+	rings: 16,
+	centers: 48,
+	palette: 64
+}, M = .55;
+function N() {
+	let e = new ArrayBuffer(A);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function P(e, t, n, r, i) {
+	let { f32: a, i32: o } = e, [c, l] = t.axisRatio;
+	a[j.u0 + 0] = n, a[j.u0 + 1] = t.speed, a[j.u0 + 2] = c, a[j.u0 + 3] = l;
+	let u = Math.min(t.centers.length, 4), d = Math.min(t.ringComponents.length, 8), f = Math.min(i.length, 4);
+	if (o[j.ints + 0] = u, o[j.ints + 1] = d, o[j.ints + 2] = f, o[j.ints + 3] = 0, t.background === "transparent") a[j.bg + 0] = 0, a[j.bg + 1] = 0, a[j.bg + 2] = 0, a[j.bg + 3] = 0;
+	else {
+		let e = s(t.background);
+		a[j.bg + 0] = e[0], a[j.bg + 1] = e[1], a[j.bg + 2] = e[2], a[j.bg + 3] = 1;
+	}
+	a[j.norm + 0] = M, a[j.norm + 1] = r, a[j.norm + 2] = 0, a[j.norm + 3] = 0, F(a, j.rings, t.ringComponents), I(a, j.centers, t.centers);
+	for (let e = 0; e < 4; e++) {
+		let t = j.palette + e * 4, n = s(i[Math.min(e, f - 1)] ?? i[0]);
+		a[t + 0] = n[0], a[t + 1] = n[1], a[t + 2] = n[2], a[t + 3] = 0;
+	}
+	return e;
+}
+function F(e, t, n) {
+	for (let r = 0; r < 8; r++) {
+		let i = t + r * 4, a = n[r];
+		a ? (e[i + 0] = a.amplitude, e[i + 1] = a.wavelength, e[i + 2] = a.phase, e[i + 3] = 0) : (e[i + 0] = 0, e[i + 1] = 1, e[i + 2] = 0, e[i + 3] = 0);
+	}
+}
+function I(e, t, n) {
+	for (let r = 0; r < 4; r++) {
+		let i = t + r * 4, a = n[r];
+		a ? (e[i + 0] = a.x, e[i + 1] = a.y, e[i + 2] = a.weight, e[i + 3] = 0) : (e[i + 0] = 0, e[i + 1] = 0, e[i + 2] = 0, e[i + 3] = 0);
+	}
+}
+//#endregion
+//#region src/components/custom/concentric/composables/concentricWGPUSetup.ts
+var L = 64, R = 8, z = 2;
+function B(e) {
+	let { canvas: t, config: n, getPalette: r, shouldContinue: i } = e;
+	return function(e, a, s) {
+		let c = e.createShaderModule({
+			label: "[Concentric] concentric.wgsl",
+			code: _
+		}), l = N(), u = e.createBuffer({
+			label: "[Concentric] uniforms",
+			size: l.buffer.byteLength,
+			usage: L | R
+		}), d = e.createBindGroupLayout({
+			label: "[Concentric] bgl",
+			entries: [{
+				binding: 0,
+				visibility: z,
+				buffer: { type: "uniform" }
+			}]
+		}), f = e.createRenderPipeline({
+			label: "[Concentric] pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [d] }),
+			vertex: {
+				module: c,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: c,
+				entryPoint: "fs_main",
+				targets: [{
+					format: s,
+					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" }
+		}), p = e.createBindGroup({
+			label: "[Concentric] bg",
+			layout: d,
+			entries: [{
+				binding: 0,
+				resource: { buffer: u }
+			}]
+		});
+		function m() {
+			let e = o(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), a = Math.max(1, Math.round(r * e));
+			(t.width !== i || t.height !== a) && (t.width = i, t.height = a);
+		}
+		function h(i) {
+			P(l, n, i, (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1), r()), e.queue.writeBuffer(u, 0, l.buffer);
+			let o = e.createCommandEncoder({ label: "[Concentric] frame" }), s = a.getCurrentTexture().createView(), c = o.beginRenderPass({ colorAttachments: [{
+				view: s,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			c.setPipeline(f), c.setBindGroup(0, p), c.draw(3, 1, 0, 0), c.end(), e.queue.submit([o.finish()]);
+		}
+		return {
+			frame: h,
+			shouldContinue: i,
+			resize: m,
+			teardown: () => {
+				u.destroy();
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/concentric/shaders/concentric.glsl.ts
+var V = "#version 300 es\nprecision highp float;\nin vec2 aPosition;\nout vec2 vUv;\nvoid main() {\n  vUv = aPosition;            // [-1,1]² domain\n  gl_Position = vec4(aPosition, 0.0, 1.0);\n}", H = `#version 300 es
+precision highp float;
+
+#define PI 3.141592653589793
+#define TAU 6.283185307179586
+#define RING_GRAVITY 9.81
+#define MAX_RINGS 8
+#define MAX_CENTERS 4
+#define MAX_RING_STOPS 4
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform float uTime;
+uniform float uSpeed;
+uniform vec2  uAxis;          // (a, b) ellipsoidal-norm axis ratio
+uniform float uFieldNorm;     // field → [0,1] amplitude scale
+uniform float uAspect;
+uniform int   uCenterCount;
+uniform int   uRingCount;
+uniform int   uStopCount;
+uniform float uHasBackground;
+uniform vec3  uRings[MAX_RINGS];     // (amplitude, wavelength, phase)
+uniform vec3  uCenters[MAX_CENTERS]; // (x, y, weight)
+uniform vec3  uPalette[MAX_RING_STOPS]; // linear-sRGB stops
+
+${t}
+${n}
+
+// ‖p − c‖_e = sqrt((dx/a)² + (dy/b)²) — transcribes ringField.ts ellipsoidalRadius.
+float ellipsoidalRadius(vec2 p, vec2 center, float axisA, float axisB) {
+  float dx = (p.x - center.x) / max(axisA, 1e-4);
+  float dy = (p.y - center.y) / max(axisB, 1e-4);
+  return sqrt(dx * dx + dy * dy);
+}
+
+// f(p,t) — the multi-center weighted radial sum (transcribes ringField.ts sampleRingField).
+float sampleRingField(vec2 p, float t) {
+  float acc = 0.0;
+  for (int j = 0; j < MAX_CENTERS; j++) {
+    if (j >= uCenterCount) break;
+    vec3 cj = uCenters[j];
+    float radius = ellipsoidalRadius(p, cj.xy, uAxis.x, uAxis.y);
+    float centerSum = 0.0;
+    for (int i = 0; i < MAX_RINGS; i++) {
+      if (i >= uRingCount) break;
+      vec3 r = uRings[i];
+      float k = TAU / max(r.y, 1e-4);
+      float omega = sqrt(RING_GRAVITY * k) * uSpeed;
+      float theta = k * radius - omega * t + r.z;
+      centerSum += r.x * sin(theta);
+    }
+    acc += centerSum * cj.z;
+  }
+  return acc;
+}
+
+// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+vec3 samplePaletteLin(float t) {
+  if (uStopCount <= 1) return uPalette[0];
+  float n = float(uStopCount);
+  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  int i0 = int(floor(ft));
+  int i1 = min(i0 + 1, uStopCount - 1);
+  float f = ft - float(i0);
+  // cube-root LMS (the GLSL chunk inlines cbrt as sign(x)·pow(|x|,1/3) — no cbrt3 fn).
+  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];
+  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];
+  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));
+  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+void main() {
+  float aspect = max(uAspect, 1e-4);
+  vec2 p = vec2(vUv.x * aspect, vUv.y);
+  float raw = sampleRingField(p, uTime);
+  float v = clamp(0.5 + raw * uFieldNorm, 0.0, 1.0);
+  vec3 lin = samplePaletteLin(v);
+  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+  if (uHasBackground > 0.5) {
+    fragColor = vec4(rgb, 1.0);
+    return;
+  }
+  float alpha = clamp(v * 0.92 + 0.08, 0.0, 1.0);
+  fragColor = vec4(rgb * alpha, alpha);
+}`;
+//#endregion
+//#region src/components/custom/concentric/composables/concentricGLSetup.ts
+function U(e, t, n) {
+	let r = e.createShader(t);
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(r);
+		throw e.deleteShader(r), Error(`[Concentric] shader compile failed: ${t}`);
+	}
+	return r;
+}
+function W(e) {
+	let { canvas: t, config: n, getPalette: r, shouldContinue: i } = e;
+	return function(e) {
+		let a = U(e, e.VERTEX_SHADER, V), c = U(e, e.FRAGMENT_SHADER, H), l = e.createProgram();
+		if (e.attachShader(l, a), e.attachShader(l, c), e.linkProgram(l), !e.getProgramParameter(l, e.LINK_STATUS)) throw Error(`[Concentric] link failed: ${e.getProgramInfoLog(l)}`);
+		e.deleteShader(a), e.deleteShader(c);
+		let u = e.createVertexArray();
+		e.bindVertexArray(u);
+		let d = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, d), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			3,
+			-1,
+			-1,
+			3
+		]), e.STATIC_DRAW);
+		let f = e.getAttribLocation(l, "aPosition");
+		e.enableVertexAttribArray(f), e.vertexAttribPointer(f, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null);
+		let p = (t) => e.getUniformLocation(l, t), m = p("uTime"), h = p("uSpeed"), g = p("uAxis"), _ = p("uFieldNorm"), v = p("uAspect"), y = p("uCenterCount"), b = p("uRingCount"), x = p("uStopCount"), S = p("uHasBackground"), C = p("uRings[0]"), w = p("uCenters[0]"), T = p("uPalette[0]");
+		function E() {
+			let n = o(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * n)), s = Math.max(1, Math.round(i * n));
+			(t.width !== a || t.height !== s) && (t.width = a, t.height = s), e.viewport(0, 0, t.width, t.height);
+		}
+		function D(i) {
+			let a = t.clientWidth || 320, o = t.clientHeight || 320, c = a / Math.max(o, 1);
+			e.useProgram(l), e.bindVertexArray(u), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), e.uniform1f(m, i), e.uniform1f(h, n.speed), e.uniform2f(g, n.axisRatio[0], n.axisRatio[1]), e.uniform1f(_, M), e.uniform1f(v, c);
+			let d = Math.min(n.centers.length, 4), f = Math.min(n.ringComponents.length, 8), p = r(), E = Math.min(p.length, 4);
+			e.uniform1i(y, d), e.uniform1i(b, f), e.uniform1i(x, E), n.background === "transparent" ? e.uniform1f(S, 0) : e.uniform1f(S, 1);
+			let D = new Float32Array(24);
+			for (let e = 0; e < 8; e++) {
+				let t = n.ringComponents[e];
+				D[e * 3 + 0] = t?.amplitude ?? 0, D[e * 3 + 1] = t?.wavelength ?? 1, D[e * 3 + 2] = t?.phase ?? 0;
+			}
+			e.uniform3fv(C, D);
+			let O = new Float32Array(12);
+			for (let e = 0; e < 4; e++) {
+				let t = n.centers[e];
+				O[e * 3 + 0] = t?.x ?? 0, O[e * 3 + 1] = t?.y ?? 0, O[e * 3 + 2] = t?.weight ?? 0;
+			}
+			e.uniform3fv(w, O);
+			let k = new Float32Array(12);
+			for (let e = 0; e < 4; e++) {
+				let t = s(p[Math.min(e, E - 1)] ?? p[0]);
+				k[e * 3 + 0] = t[0], k[e * 3 + 1] = t[1], k[e * 3 + 2] = t[2];
+			}
+			e.uniform3fv(T, k), e.drawArrays(e.TRIANGLES, 0, 3), e.bindVertexArray(null);
+		}
+		return {
+			frame: D,
+			shouldContinue: i,
+			resize: E,
+			teardown: () => {
+				e.deleteProgram(l), e.deleteVertexArray(u), e.deleteBuffer(d);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/concentric/composables/useConcentric.ts
+function G(e, t) {
+	let { config: n, getPalette: i } = t, a = t.mode ?? "live", o = null, s = () => {
+		let t = e.value;
+		return t ? (o || (o = r(t, {
+			mode: a,
+			respectReducedMotion: n.respectReducedMotion,
+			setupWGPU: B({
+				canvas: t,
+				config: n,
+				getPalette: i,
+				shouldContinue: () => !0
+			}),
+			setupGL: W({
+				canvas: t,
+				config: n,
+				getPalette: i,
+				shouldContinue: () => !0
+			})
+		}), o.armAsync()), o) : null;
+	};
+	queueMicrotask(() => s());
+	let c = {
+		get backend() {
+			return s()?.backend ?? "webgpu";
+		},
+		pause: () => s()?.suspend("manual"),
+		resume: () => s()?.resume("manual"),
+		wake: () => s()?.wake(),
+		renderAt: (e) => s()?.renderAt(e),
+		get reducedMotion() {
+			return o?.reducedMotion ?? !1;
+		},
+		dispose: () => o?.dispose()
+	};
+	return p(() => c.dispose()), c;
+}
+//#endregion
+//#region src/components/custom/concentric/Concentric.vue
+var K = /* @__PURE__ */ e(/* @__PURE__ */ d({
+	__name: "Concentric",
+	props: {
+		config: { default: () => k },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:paused"],
+	setup(e, { expose: t }) {
+		let n = h("canvasRef"), r = G(n, {
+			config: e.config,
+			getPalette: () => e.config.palette
+		});
+		g(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = c(() => {
+			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) => (m(), l("div", {
+			class: "concentric-wrapper",
+			style: f(i.value ? { background: i.value } : void 0)
+		}, [u("canvas", {
+			ref_key: "canvasRef",
+			ref: n,
+			class: "concentric-canvas",
+			"aria-hidden": "true",
+			"data-testid": "concentric-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__scopeId", "data-v-f8bbc88a"]]);
+//#endregion
+export { K as Concentric, O as DEFAULT_CENTERS, k as DEFAULT_CONCENTRIC_CONFIG, D as DEFAULT_RING_COMPONENTS, w as MAX_CENTERS, C as MAX_RINGS, T as MAX_RING_STOPS, v as RING_GRAVITY, E as WARM_IDENTITY_PALETTE, S as buildRingLadder, b as ellipsoidalRadius, x as sampleRingField, G as useConcentric };

package/dist/configurator.js

@@ -1,2 +1,3 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-kiIlun8I.js";
-export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };
+import { a as e, i as t, n, r, t as i } from "./ConfiguratorRow-BR4l-ixA.js";
+import { n as a, t as o } from "./useConfiguratorState-DNlOh6c8.js";
+export { r as CONFIGURATOR_DENSITY_KEY, a as Configurator, n as ConfiguratorLayer, i as ConfiguratorRow, t as provideConfiguratorDensity, o as useConfiguratorState, e as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.js

@@ -1,14 +1,12 @@
-import { t as e } from "./createLucideIcon-DydS2qgk.js";
-import { n as t } from "./button-BNDWhAZb.js";
-import { t as n } from "./_plugin-vue_export-helper-CBt_VvXa.js";
+import { u as e } from "./vendor-CKmzio-i.js";
+import { n as t } from "./button-DYCUa-tH.js";
+import { t as n } from "./_plugin-vue_export-helper-C1je1s0u.js";
 import { Transition as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, createVNode as l, defineComponent as u, mergeModels as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, useModel as g, withCtx as _, withKeys as v, withModifiers as y } from "vue";
-var b = e("loader-circle", [["path", {
-	d: "M21 12a9 9 0 1 1-6.219-8.56",
-	key: "13zald"
-}]]), x = {
+//#region src/components/custom/confirm-dialog/ConfirmDialog.vue?vue&type=script&setup=true&lang.ts
+var b = {
 	key: 0,
 	class: "w-[calc(100%-2rem)] sm:max-w-sm bg-card text-card-foreground border border-border rounded-dialog shadow-lg"
-}, S = { class: "p-6 grid gap-4" }, C = { class: "grid gap-2" }, w = { class: "font-display text-lg font-semibold leading-none tracking-tight" }, T = { class: "fira-code text-sm text-muted-foreground" }, E = { class: "flex justify-end gap-2" }, D = /* @__PURE__ */ n(/* @__PURE__ */ u({
+}, x = { class: "p-6 grid gap-4" }, S = { class: "grid gap-2" }, C = { class: "font-display text-lg font-semibold leading-none tracking-tight" }, w = { class: "fira-code text-sm text-muted-foreground" }, T = { class: "flex justify-end gap-2" }, E = /* @__PURE__ */ n(/* @__PURE__ */ u({
 	__name: "ConfirmDialog",
 	props: /* @__PURE__ */ d({
 		title: {},
@@ -24,39 +22,39 @@ var b = e("loader-circle", [["path", {
 		openModifiers: {}
 	}),
 	emits: /* @__PURE__ */ d(["confirm"], ["update:open"]),
-	setup(e, { emit: n }) {
-		let u = e, d = g(e, "open"), D = n;
+	setup(n, { emit: u }) {
+		let d = n, E = g(n, "open"), D = u;
 		function O() {
-			u.loading || (D("confirm"), d.value = !1);
+			d.loading || (D("confirm"), E.value = !1);
 		}
-		return (n, u) => (f(), i(r, { name: "fade" }, {
-			default: _(() => [d.value ? (f(), o("div", {
+		return (u, d) => (f(), i(r, { name: "fade" }, {
+			default: _(() => [E.value ? (f(), o("div", {
 				key: 0,
 				class: "absolute inset-0 z-popover grid place-items-center bg-overlay-scrim rounded-dialog",
-				onClick: u[1] ||= y((t) => !e.loading && (d.value = !1), ["self"]),
-				onKeydown: u[2] ||= v((t) => !e.loading && (d.value = !1), ["escape"])
+				onClick: d[1] ||= y((e) => !n.loading && (E.value = !1), ["self"]),
+				onKeydown: d[2] ||= v((e) => !n.loading && (E.value = !1), ["escape"])
 			}, [l(r, {
 				name: "confirm-panel",
 				appear: ""
 			}, {
-				default: _(() => [d.value ? (f(), o("div", x, [s("div", S, [s("div", C, [s("h2", w, m(e.title), 1), s("div", T, [p(n.$slots, "default", {}, () => [c(m(e.description), 1)], !0)])]), s("div", E, [l(h(t), {
+				default: _(() => [E.value ? (f(), o("div", b, [s("div", x, [s("div", S, [s("h2", C, m(n.title), 1), s("div", w, [p(u.$slots, "default", {}, () => [c(m(n.description), 1)], !0)])]), s("div", T, [l(h(t), {
 					variant: "outline",
 					class: "cursor-pointer rounded-pill",
-					disabled: e.loading,
-					onClick: u[0] ||= (e) => d.value = !1
+					disabled: n.loading,
+					onClick: d[0] ||= (e) => E.value = !1
 				}, {
-					default: _(() => [...u[3] ||= [c(" Cancel ", -1)]]),
+					default: _(() => [...d[3] ||= [c(" Cancel ", -1)]]),
 					_: 1
 				}, 8, ["disabled"]), l(h(t), {
-					variant: e.destructive ? "destructive" : "default",
+					variant: n.destructive ? "destructive" : "default",
 					class: "cursor-pointer gap-1.5 rounded-pill",
-					disabled: e.loading,
+					disabled: n.loading,
 					onClick: O
 				}, {
-					default: _(() => [e.loading ? (f(), i(h(b), {
+					default: _(() => [n.loading ? (f(), i(h(e), {
 						key: 0,
 						class: "size-4 animate-spin"
-					})) : a("", !0), p(n.$slots, "action", {}, () => [c(m(e.confirmLabel), 1)], !0)]),
+					})) : a("", !0), p(u.$slots, "action", {}, () => [c(m(n.confirmLabel), 1)], !0)]),
 					_: 3
 				}, 8, ["variant", "disabled"])])])])) : a("", !0)]),
 				_: 3
@@ -66,4 +64,4 @@ var b = e("loader-circle", [["path", {
 	}
 }), [["__scopeId", "data-v-01b48b6e"]]);
 //#endregion
-export { D as ConfirmDialog };
+export { E as ConfirmDialog };