@popcorn245/cornfield-components 0.48.0 → 0.49.0

package/dist/chunks/corn-map-C9msiSKP.js

@@ -0,0 +1,2664 @@
+import { n as e, r as t, t as n } from "./runtime-DFu6W5g-.js";
+import { $ as r, B as i, C as a, D as o, E as s, F as c, G as l, H as u, I as d, J as f, K as p, L as m, M as h, N as g, O as _, P as v, Q as y, R as b, S as x, T as S, U as C, V as w, W as T, X as E, Z as D, _ as O, a as k, b as A, c as j, ct as M, d as N, dt as P, et as F, f as I, ft as ee, g as te, h as ne, it as L, j as R, k as z, l as B, m as V, nt as H, o as U, p as W, q as G, rt as re, s as ie, t as ae, tt as oe, v as se, w as ce, x as le, y as ue, z as de } from "./_corn-default-tokens-CoghUocx.js";
+var K = 96, fe = "letters:", pe = (e) => `${fe}${e}`, me = (e) => typeof e == "string" && e.startsWith(fe), he = (e) => e.slice(8), ge = (e, t) => !!e.letters && !e.icon && e.r * 2 * t >= 14, _e = /* @__PURE__ */ new Map();
+function ve(e, t = null) {
+	if (typeof e != "string" || !e) return null;
+	let n = `${typeof t == "string" ? t : ""}|${e}`;
+	if (_e.has(n)) return _e.get(n);
+	if (_e.size >= 128) return null;
+	let r = null;
+	try {
+		let n = typeof OffscreenCanvas < "u" ? new OffscreenCanvas(K, K) : typeof document < "u" ? Object.assign(document.createElement("canvas"), {
+			width: K,
+			height: K
+		}) : null, i = n && n.getContext && n.getContext("2d");
+		if (i && i.fillText) {
+			i.font = `700 ${e.length > 1 ? 56 : 72}px ${R}`, i.textAlign = "center", i.textBaseline = "middle", i.lineJoin = "round", i.lineWidth = 10;
+			let a = typeof t == "string" ? t : f;
+			i.strokeStyle = F(a) === "#ffffff" ? "rgba(11, 18, 32, 0.92)" : "rgba(255, 255, 255, 0.92)", i.strokeText(e, K / 2, 51), i.fillStyle = a, i.fillText(e, K / 2, 51), r = n;
+		}
+	} catch {
+		r = null;
+	}
+	return _e.set(n, r), r;
+}
+// ../explorer/renderer-canvas2d.js
+var ye = Math.PI * 2, be = 1.5, q = (e, t, n, r) => {
+	e.beginPath(), e.arc(t, n, r, 0, ye);
+};
+function xe(e, t, n, r, i) {
+	if (t === "rounded-square" || t === "square") {
+		let a = i * (t === "square" ? v.squareHalf : v.roundedHalf), o = i * (t === "square" ? v.squareCorner : v.roundedCorner);
+		e.beginPath(), e.roundRect ? e.roundRect(n - a, r - a, a * 2, a * 2, o) : e.rect(n - a, r - a, a * 2, a * 2);
+	} else if (t === "hexagon") {
+		let t = i * v.hexInradius / Math.cos(Math.PI / 6);
+		e.beginPath();
+		for (let i = 0; i < 6; i++) {
+			let a = Math.PI / 6 + i * Math.PI / 3, o = n + t * Math.cos(a), s = r + t * Math.sin(a);
+			i ? e.lineTo(o, s) : e.moveTo(o, s);
+		}
+		e.closePath();
+	} else if (t === "diamond") {
+		let t = i * v.diamondHalf;
+		e.beginPath(), e.moveTo(n, r - t), e.lineTo(n + t, r), e.lineTo(n, r + t), e.lineTo(n - t, r), e.closePath();
+	} else q(e, n, r, i);
+}
+function Se(e, t, n, r, i) {
+	let a = -n.x / n.zoom - t.margin, o = (r - n.x) / n.zoom + t.margin, s = -n.y / n.zoom - t.margin, c = (i - n.y) / n.zoom + t.margin;
+	e.beginPath(), e.strokeStyle = t.color, e.lineWidth = t.width;
+	for (let n = Math.floor(a / t.size) * t.size; n < o; n += t.size) e.moveTo(n, s), e.lineTo(n, c);
+	for (let n = Math.floor(s / t.size) * t.size; n < c; n += t.size) e.moveTo(a, n), e.lineTo(o, n);
+	e.stroke();
+}
+function Ce(e, t) {
+	e.save(), t.forEach((t) => {
+		e.lineWidth = t.width, e.setLineDash(t.dash), e.strokeStyle = t.color, q(e, t.x, t.y, t.r), e.stroke();
+	}), e.restore();
+}
+function we(e, t) {
+	e.save(), t.forEach((t) => {
+		e.fillStyle = t.fill, e.strokeStyle = t.stroke, e.lineWidth = t.strokeWidth, e.beginPath(), e.roundRect(t.x, t.y, t.w, t.h, t.radius), e.fill(), e.stroke();
+	}), e.restore();
+}
+function Te(e, t, n, r, i = !0) {
+	if (e.save(), e.globalAlpha = t.alpha, e.beginPath(), e.moveTo(t.x1, t.y1), t.curve ? e.quadraticCurveTo(t.curve.cx, t.curve.cy, t.x2, t.y2) : e.lineTo(t.x2, t.y2), e.strokeStyle = t.color, e.lineWidth = t.mark && t.mark !== "none" ? Math.max(t.width, g.edge / r) : t.width, e.setLineDash(t.dash || []), t.glow && t.glow * r >= be) {
+		let n = e.lineWidth;
+		e.save(), e.globalAlpha = t.alpha * .3, e.strokeStyle = t.glowColor || t.color, e.lineWidth = n + t.glow * .6, e.stroke(), e.restore();
+	}
+	if (e.stroke(), e.setLineDash([]), t.mark === "removed") {
+		let n = m(t, .5), i = Math.hypot(t.x2 - t.x1, t.y2 - t.y1), [a, o] = i > 0 ? [(t.x2 - t.x1) / i, (t.y2 - t.y1) / i] : [1, 0];
+		e.beginPath(), e.moveTo(n.x - o * _.halfLength, n.y + a * _.halfLength), e.lineTo(n.x + o * _.halfLength, n.y - a * _.halfLength), e.lineWidth = Math.max(_.width, 1.5 / r), e.stroke();
+	}
+	if (t.ticks && De(e, t, r), t.arrow) {
+		let { cx: n, cy: i } = t.curve || {
+			cx: t.x1,
+			cy: t.y1
+		};
+		Ee(e, t, Math.atan2(t.y2 - i, t.x2 - n), r);
+	}
+	i && t.packet && Oe(e, t, n, r), e.restore();
+}
+function Ee(e, t, n, r) {
+	let i = t.end || "triangle", { x2: a, y2: o, color: c } = t, l = Math.cos(n), u = Math.sin(n), d = (e, t) => [a - l * e - u * t, o - u * e + l * t], f = Math.max(z.strokeWidth, 1.2 / r);
+	if (e.beginPath(), i === "triangle") e.moveTo(a, o), e.lineTo(a - Math.cos(n - s.spread) * s.length, o - Math.sin(n - s.spread) * s.length), e.lineTo(a - Math.cos(n + s.spread) * s.length, o - Math.sin(n + s.spread) * s.length), e.closePath(), e.fillStyle = c, e.fill();
+	else {
+		if (e.strokeStyle = c, e.lineWidth = f, e.lineJoin = "miter", i === "chevron") {
+			let t = s.length * Math.cos(s.spread), n = s.length * Math.sin(s.spread);
+			e.moveTo(...d(t, n)), e.lineTo(a, o), e.lineTo(...d(t, -n));
+		} else if (i === "bar") e.moveTo(...d(f / 2, z.barHalf)), e.lineTo(...d(f / 2, -z.barHalf));
+		else {
+			let t = z.diamondHalf;
+			e.moveTo(a, o), e.lineTo(...d(t, z.diamondAcross)), e.lineTo(...d(2 * t, 0)), e.lineTo(...d(t, -z.diamondAcross)), e.closePath();
+		}
+		e.stroke();
+	}
+}
+function De(e, t, n) {
+	let r = Math.hypot(t.x2 - t.x1, t.y2 - t.y1), [i, a] = r > 0 ? [(t.x2 - t.x1) / r, (t.y2 - t.y1) / r] : [1, 0], o = m(t, .5);
+	e.beginPath();
+	for (let n = 0; n < t.ticks; n++) {
+		let r = (n - (t.ticks - 1) / 2) * z.tickGap, s = o.x + i * r, c = o.y + a * r;
+		e.moveTo(s - a * z.tickHalf, c + i * z.tickHalf), e.lineTo(s + a * z.tickHalf, c - i * z.tickHalf);
+	}
+	e.strokeStyle = t.color, e.lineWidth = Math.max(z.tickWidth, 1.5 / n), e.setLineDash([]), e.stroke();
+}
+function Oe(e, t, n, r) {
+	let i = w(t, n), { packet: a } = t;
+	a.glow && a.glow * r >= be && (e.beginPath(), e.arc(i.x, i.y, a.radius + a.glow * .5, 0, ye), e.globalAlpha = t.alpha * .3, e.fillStyle = a.glowColor || a.color, e.fill(), e.globalAlpha = t.alpha), e.beginPath(), e.arc(i.x, i.y, a.radius, 0, ye), e.fillStyle = a.color, e.fill();
+}
+function ke(e, t, n, r) {
+	e.save(), e.globalAlpha = t.alpha, Oe(e, t, n, r), e.restore();
+}
+var Ae = 16, je = /* @__PURE__ */ new WeakMap();
+function Me(e) {
+	let t = je.get(e);
+	return t || (t = new Float64Array(e.edges.length * 4), e.edges.forEach((e, n) => {
+		let r = e.curve ? e.curve.cx : e.x1, i = e.curve ? e.curve.cy : e.y1, a = (e.glow || 0) * .6 + (e.packet ? e.packet.radius + (e.packet.glow || 0) * .5 : 0), o = (e.width || 0) / 2 + a + Ae;
+		t[n * 4] = Math.min(e.x1, e.x2, r) - o, t[n * 4 + 1] = Math.min(e.y1, e.y2, i) - o, t[n * 4 + 2] = Math.max(e.x1, e.x2, r) + o, t[n * 4 + 3] = Math.max(e.y1, e.y2, i) + o;
+	}), je.set(e, t)), t;
+}
+function Ne(e, t, n, r) {
+	let i = Me(e), a = t.zoom || 1, o = 4 / a, s = -t.x / a - o, c = -t.y / a - o, l = (n - t.x) / a + o, u = (r - t.y) / a + o, d = [];
+	for (let t = 0; t < e.edges.length; t++) i[t * 4 + 2] < s || i[t * 4] > l || i[t * 4 + 3] < c || i[t * 4 + 1] > u || d.push(e.edges[t]);
+	return d;
+}
+function Pe(e, t, n, r, i) {
+	e.save(), e.globalAlpha = t.alpha;
+	let a = r.halo[t.halo];
+	a && (a.fill && (q(e, t.x, t.y, t.r + a.fillR), e.fillStyle = a.fill, e.fill()), q(e, t.x, t.y, t.r + a.ringR), e.strokeStyle = a.ring, e.lineWidth = a.ringWidth, e.stroke());
+	let s = r.mark[t.mark];
+	if (s) {
+		let r = t.r + Math.max(s.ringR, g.gap / n);
+		q(e, t.x, t.y, r), e.strokeStyle = s.color, e.lineWidth = Math.max(s.ringWidth, g.ring / n), e.setLineDash(s.ringDash || []), e.stroke(), e.setLineDash([]), t.mark === "removed" && (e.beginPath(), e.moveTo(t.x - r, t.y), e.lineTo(t.x + r, t.y), e.stroke());
+	}
+	xe(e, t.shape, t.x, t.y, t.r), t.glow && t.glow * n >= be && (e.save(), e.globalAlpha = t.alpha * .28, q(e, t.x, t.y, t.r + t.glow * .7), e.fillStyle = t.color, e.fill(), e.restore(), xe(e, t.shape, t.x, t.y, t.r)), e.fillStyle = t.color, e.fill();
+	let c = t.icon && i.icons ? i.icons.get(t.icon) : null, l = !c && ge(t, n), u = !c && !l && H(t, n) ? E(t.glyph, D(t, i)) : null;
+	if (u || (q(e, t.x, t.y, t.r * o), e.fillStyle = r.core, e.fill()), t.stroke && (xe(e, t.shape, t.x, t.y, Math.max(0, t.r - t.stroke.width / 2)), e.strokeStyle = t.stroke.color, e.lineWidth = t.stroke.width, e.stroke()), c) {
+		let n = t.r * le;
+		e.imageSmoothingEnabled = !i.pixelated, e.drawImage(c, t.x - n / 2, t.y - n / 2, n, n);
+	} else if (l) {
+		let n = ve(t.letters, i.values && i.values["--corn-map-glyph"]);
+		if (n) {
+			let r = t.r * 1;
+			e.imageSmoothingEnabled = !0, e.drawImage(n, t.x - r / 2, t.y - r / 2, r, r);
+		}
+	} else if (u) {
+		let n = t.r * G;
+		e.imageSmoothingEnabled = !0, e.drawImage(u, t.x - n / 2, t.y - n / 2, n, n);
+	}
+	e.restore();
+}
+function Fe(e, t = {}) {
+	let n = t.mapStyle || (() => x), r = e.getContext("2d"), o = 0, s = 0, c = 1, l = null, u = null, d = null, f = () => {
+		if (l) return l;
+		try {
+			l = typeof OffscreenCanvas < "u" ? new OffscreenCanvas(e.width || 1, e.height || 1) : e.ownerDocument ? e.ownerDocument.createElement("canvas") : null, u = l && l.getContext ? l.getContext("2d") : null;
+		} catch {
+			u = null;
+		}
+		return u || (l = null), l;
+	}, p = t.layerMinEdges ?? 600, m = /* @__PURE__ */ new WeakMap(), h = (e) => (m.has(e) || m.set(e, e.edges.some((e) => e.packet)), m.get(e));
+	function g(e, t, n) {
+		e.save(), e.translate(n.x, n.y), e.scale(n.zoom, n.zoom);
+		let { decor: r } = t;
+		r.grid && Se(e, r.grid, n, o, s), r.lanes.length && we(e, r.lanes), r.rings.length && Ce(e, r.rings), Ne(t, n, o, s).forEach((t) => Te(e, t, 0, n.zoom, !1)), e.restore();
+	}
+	return {
+		kind: "canvas2d",
+		resize(t, n, i) {
+			o = t, s = n, c = i, e.width = t * i, e.height = n * i, r.setTransform(i, 0, 0, i, 0, 0), d = null, l && (l.width = e.width, l.height = e.height, u.setTransform(i, 0, 0, i, 0, 0));
+		},
+		draw(t, m, _) {
+			let v = n(), y = S(t, v);
+			r.clearRect(0, 0, o, s);
+			let b = a(i(y.theme), v), x = Ne(y, m, o, s);
+			if (h(y) && x.length > p && f()) {
+				d && d.scene === y && d.x === m.x && d.y === m.y && d.zoom === m.zoom && d.w === e.width && d.h === e.height || ((l.width !== e.width || l.height !== e.height) && (l.width = e.width, l.height = e.height), u.setTransform(c, 0, 0, c, 0, 0), u.clearRect(0, 0, o, s), g(u, y, m), d = {
+					scene: y,
+					x: m.x,
+					y: m.y,
+					zoom: m.zoom,
+					w: e.width,
+					h: e.height
+				}), r.save(), r.setTransform(1, 0, 0, 1, 0, 0), r.drawImage(l, 0, 0), r.restore(), r.save(), r.translate(m.x, m.y), r.scale(m.zoom, m.zoom), x.forEach((e) => {
+					e.packet && ke(r, e, _, m.zoom);
+				}), y.nodes.forEach((e) => Pe(r, e, m.zoom, b, v)), r.restore();
+				return;
+			}
+			r.save(), r.translate(m.x, m.y), r.scale(m.zoom, m.zoom);
+			let { decor: C } = y;
+			C.grid && Se(r, C.grid, m, o, s), C.lanes.length && we(r, C.lanes), C.rings.length && Ce(r, C.rings), x.forEach((e) => Te(r, e, _, m.zoom)), y.nodes.forEach((e) => Pe(r, e, m.zoom, b, v)), r.restore();
+		},
+		destroy() {
+			l = null, u = null, d = null;
+		}
+	};
+}
+var Ie = (e) => typeof e.hitR == "number" && e.hitR > e.r ? e.hitR : e.r;
+function Le(e, { cellSize: t = 64 } = {}) {
+	let n = /* @__PURE__ */ new Map(), r = 0, i = (e, t) => e * 4194304 + t;
+	for (let a = 0; a < e.length; a++) {
+		let o = e[a];
+		Ie(o) > r && (r = Ie(o));
+		let s = i(Math.floor(o.x / t), Math.floor(o.y / t)), c = n.get(s);
+		c ? c.push(a) : n.set(s, [a]);
+	}
+	let a = (e) => typeof e == "number" ? e : e && e.pad || 0, o = (e) => typeof e == "number" ? 0 : e && e.min || 0;
+	return {
+		size: e.length,
+		cellSize: t,
+		nodeAt(s, c, l = 0) {
+			if (e.length === 0) return null;
+			let u = a(l), d = o(l), f = Math.max(r + u, d), p = Math.floor((s - f) / t), m = Math.floor((s + f) / t), h = Math.floor((c - f) / t), g = Math.floor((c + f) / t), _ = -1;
+			for (let t = p; t <= m; t++) for (let r = h; r <= g; r++) {
+				let a = n.get(i(t, r));
+				if (a) for (let t = 0; t < a.length; t++) {
+					let n = a[t];
+					if (n <= _) continue;
+					let r = e[n], i = Math.max(Ie(r) + u, d);
+					Math.hypot(r.x - s, r.y - c) <= i && (_ = n);
+				}
+			}
+			return _ < 0 ? null : e[_];
+		},
+		nodesIn(a) {
+			if (e.length === 0) return [];
+			let { minX: o, minY: s, maxX: c, maxY: l } = a, u = Math.floor((o - r) / t), d = Math.floor((c + r) / t), f = Math.floor((s - r) / t), p = Math.floor((l + r) / t), m = [];
+			for (let t = u; t <= d; t++) for (let r = f; r <= p; r++) {
+				let a = n.get(i(t, r));
+				if (a) for (let t = 0; t < a.length; t++) {
+					let n = a[t], r = e[n], i = r.x - Math.min(Math.max(r.x, o), c), u = r.y - Math.min(Math.max(r.y, s), l);
+					i * i + u * u <= Ie(r) ** 2 && m.push(n);
+				}
+			}
+			return m.sort((e, t) => e - t).map((t) => e[t]);
+		}
+	};
+}
+function Re(e, t, n, r, i = !1) {
+	let a = t.zoom;
+	return e.nodeAt((n - t.x) / a, (r - t.y) / a, {
+		pad: (i ? 16 : 6) / a,
+		min: (i ? 32 : 12) / a
+	});
+}
+function ze(e) {
+	let t = null, n = null, r = {
+		builds: 0,
+		get(i) {
+			return n && t === i || (n = Le(i.nodes, e), t = i, r.builds++), n;
+		}
+	};
+	return r;
+}
+// ../explorer/frame.js
+var Be = 3e4;
+function Ve({ dirty: e, packetsVisible: t, hidden: n, reduceMotion: r, idleMs: i, clientsWant: a = !1 }) {
+	if (n) return {
+		draw: !1,
+		again: !1
+	};
+	let o = t && !r && i < 3e4 || a;
+	return {
+		draw: e || o,
+		again: o
+	};
+}
+function He(e, t, n, r) {
+	let i = We(e);
+	if (i.length === 0) return !1;
+	if (!(n > 0) || !(r > 0)) return !0;
+	let a = -t.x / t.zoom, o = -t.y / t.zoom, s = (n - t.x) / t.zoom, c = (r - t.y) / t.zoom;
+	for (let e of i) {
+		let t = e.curve ? e.curve.cx : e.x1, n = e.curve ? e.curve.cy : e.y1, r = e.packet.radius + e.packet.glow;
+		if (!(Math.max(e.x1, e.x2, t) + r < a || Math.min(e.x1, e.x2, t) - r > s) && !(Math.max(e.y1, e.y2, n) + r < o || Math.min(e.y1, e.y2, n) - r > c)) return !0;
+	}
+	return !1;
+}
+var Ue = /* @__PURE__ */ new WeakMap();
+function We(e) {
+	let t = Ue.get(e);
+	return t || (t = e.edges.filter((e) => e.packet), Ue.set(e, t)), t;
+}
+function Ge(e) {
+	let { draw: t, packetsVisible: n, isHidden: r, reduceMotion: i, extraDirty: a, tickClients: o, clientsWant: s, now: c, raf: l, caf: u } = e, d = !0, f = null, p = -Infinity, m = c(), h = !1, g = /* @__PURE__ */ new Set(), _ = () => {
+		if (g.size === 0) return;
+		let e = [...g];
+		g.clear(), e.forEach((e) => e());
+	}, v = () => {
+		!h && f === null && (f = l(y));
+	};
+	function y(e) {
+		f = null, _();
+		let n = o && !r() ? o(e) : !1, i = d || (a ? a() : !1), { draw: s, again: c } = b(i, n);
+		s && (i || e - p >= 31) && (d = !1, p = e, x.draws++, t()), x.frames++, c && v();
+	}
+	let b = (e, t) => Ve({
+		dirty: e,
+		packetsVisible: n(),
+		hidden: r(),
+		reduceMotion: i(),
+		idleMs: c() - m,
+		clientsWant: t
+	}), x = {
+		frames: 0,
+		draws: 0,
+		markDirty() {
+			d = !0, v();
+		},
+		queue(e, { draw: t = !0 } = {}) {
+			g.add(e), t ? x.markDirty() : v();
+		},
+		wake() {
+			v();
+		},
+		noteInput() {
+			let e = c(), t = e - m >= Be;
+			m = e, t && v();
+		},
+		shown() {
+			m = c();
+			let e = d || (a ? a() : !1), { draw: t, again: n } = b(e, s ? s() : !1);
+			(t || n) && v();
+		},
+		drawNow() {
+			_(), d = !1, p = c(), x.draws++, t();
+		},
+		hold(e) {
+			h = !!e, h ? x.cancel() : x.markDirty();
+		},
+		get pending() {
+			return f !== null;
+		},
+		cancel() {
+			f !== null && u(f), f = null;
+		}
+	};
+	return x;
+}
+var Ke = 1, qe = .3, Je = .58, Ye = 3, Xe = 100, J = 64, Y = {
+	selected: 0,
+	current: 1,
+	match: 2,
+	lit: 3,
+	marked: 4,
+	hub: 5,
+	rest: 6,
+	greyed: 7
+}, Ze = 1.5, Qe = (e) => Number.isFinite(e) && e >= 9 ? Math.max(11, e) : 11, $e = (e) => Qe(e.labelMin), et = (e) => h.includes(e.type) && !e.greyed, tt = (e, t) => e.selected ? Y.selected : e.current ? Y.current : e.match ? Y.match : t && e.connected ? Y.lit : e.mark && e.mark !== "none" || e.labelKeep && !et(e) ? Y.marked : e.greyed ? Y.greyed : et(e) ? Y.hub : Y.rest;
+function nt(e, t, n = {}) {
+	let { measure: r = null } = n, i = $e(e), a = e.nodes.some((e) => e.selected || !e.connected), o = [];
+	e.nodes.forEach((e, t) => {
+		e.label && e.labelAlpha >= .15 && o.push({
+			node: e,
+			index: t,
+			tier: tt(e, a)
+		});
+	}), o.sort((e, t) => e.tier - t.tier || t.node.r - e.node.r || (t.node.degree || 0) - (e.node.degree || 0) || e.index - t.index);
+	let s = /* @__PURE__ */ new Map(), c = (e, t) => (e + 8192) * 16384 + (t + 8192), l = [], u = Math.max(Ye, Ye * t);
+	for (let { node: e, index: n, tier: a } of o) {
+		let o = et(e), d = !e.greyed && (!!e.labelBold || o), f = Math.max(o ? i + 2 : i, e.labelSize * t), p = r ? r(e.label, Xe, d) * f / Xe : e.label.length * f * Je, m = e.x * t, h = e.y * t + e.r * t + u + f, g = m - p / 2, _ = m + p / 2, v = h - f * Ke, y = h + f * qe, b = a === Y.greyed ? 2 + f * Ze : 2, x = Math.floor((g - b) / J), S = Math.floor((_ + b) / J), C = Math.floor((v - b) / J), w = Math.floor((y + b) / J), T = !1;
+		for (let e = x; e <= S && !T; e++) for (let t = C; t <= w && !T; t++) {
+			let n = s.get(c(e, t));
+			if (n) for (let e = 0; e < n.length; e++) {
+				let t = n[e];
+				if (g - b < t.r && _ + b > t.l && v - b < t.b && y + b > t.t) {
+					T = !0;
+					break;
+				}
+			}
+		}
+		if (T) continue;
+		let E = {
+			index: n,
+			id: e.id,
+			rank: l.length,
+			tier: a,
+			px: f,
+			bold: d,
+			screen: e.labelSize * t <= (o ? i + 2 : i),
+			size: f / t,
+			x: e.x,
+			y: e.y + e.r + (u + f) / t,
+			node: e,
+			l: g,
+			t: v,
+			r: _,
+			b: y
+		};
+		l.push(E);
+		let D = Math.floor(g / J), O = Math.floor(_ / J), k = Math.floor(v / J), A = Math.floor(y / J);
+		for (let e = D; e <= O; e++) for (let t = k; t <= A; t++) {
+			let n = c(e, t), r = s.get(n);
+			r ? r.push(E) : s.set(n, [E]);
+		}
+	}
+	return l;
+}
+function rt(e, t, n, r = {}) {
+	let { max: a = 400, margin: o = 32, measure: s = null, hover: c = null } = r, l = [], u = e.labelOutline || i(e.theme).labelOutline;
+	for (let t of e.decor.lanes) for (let n of [
+		t.title,
+		t.note,
+		t.arrow
+	]) n && l.push({
+		kind: "lane",
+		text: n.text,
+		x: n.x,
+		y: n.y,
+		size: n.size,
+		bold: n.bold,
+		italic: !1,
+		color: n.color,
+		alpha: 1,
+		outline: null,
+		align: "center",
+		family: e.labelFont || "\"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, sans-serif"
+	});
+	let { zoom: d } = t, f = r.placed || nt(e, d, { measure: s }), p = -o - t.x, m = n.width + o - t.x, h = -o - t.y, g = n.height + o - t.y, _ = f.filter((e) => e.r >= p && e.l <= m && e.b >= h && e.t <= g);
+	_.length > a && (_ = _.slice(0, Math.max(0, a))), _.sort((e, t) => e.index - t.index);
+	let v = e.labelFont || "\"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, sans-serif";
+	for (let e of _) {
+		let t = Math.max(1, 1 / d);
+		l.push({
+			kind: "node",
+			id: e.id,
+			text: e.node.label,
+			x: e.x,
+			y: e.y,
+			size: e.size,
+			bold: e.bold,
+			italic: !1,
+			color: e.node.labelColor,
+			alpha: e.node.labelAlpha,
+			outline: u.node ? {
+				color: u.node.color,
+				width: u.node.width * t
+			} : null,
+			align: "center",
+			family: v,
+			strike: !!e.node.labelStrike,
+			px: e.px,
+			screen: e.screen
+		});
+	}
+	let y = $e(e), b = _.map((e) => ({
+		l: t.x + e.l,
+		r: t.x + e.r,
+		t: t.y + e.t,
+		b: t.y + e.b
+	}));
+	for (let r of e.nodes) {
+		if (r.alpha < .5) continue;
+		let e = t.x + r.x * d, i = t.y + r.y * d, a = r.r * d;
+		e + a < 0 || e - a > n.width || i + a < 0 || i - a > n.height || b.push({
+			l: e - a,
+			r: e + a,
+			t: i - a,
+			b: i + a
+		});
+	}
+	let x = 0;
+	for (let r of e.edges) {
+		let i = r.label;
+		if (!i || x >= 120) continue;
+		let a = t.x + i.x * d, o = t.y + i.y * d;
+		if (a < 0 || a > n.width || o < 0 || o > n.height) continue;
+		let c = (s ? s(i.text, y, !1) : i.text.length * y * .55) / 2 + 2, f = {
+			l: a - c,
+			r: a + c,
+			t: o - y * .6 - 2,
+			b: o + y * .6 + 2
+		};
+		b.some((e) => f.l < e.r && f.r > e.l && f.t < e.b && f.b > e.t) || (b.push(f), x++, l.push({
+			kind: "edge",
+			text: i.text,
+			x: i.x,
+			y: i.y + y * .35 / d,
+			size: y / d,
+			px: y,
+			screen: !0,
+			bold: !1,
+			italic: !!i.italic,
+			color: i.color,
+			alpha: r.alpha,
+			outline: u.edge,
+			align: "center",
+			family: e.labelFont || "\"Segoe UI\", -apple-system, sans-serif"
+		}));
+	}
+	if (c) {
+		let n = e.nodes.find((e) => e.id === c);
+		if (n && n.label && !f.some((e) => e.id === c && _.includes(e))) {
+			let r = $e(e), i = t.y + n.y * d - n.r * d > 40 ? n.y - n.r - 5 / d : n.y + n.r + (5 + r) / d;
+			l.push({
+				kind: "chip",
+				id: n.id,
+				text: n.label,
+				x: n.x,
+				y: i,
+				size: r / d,
+				px: r,
+				screen: !0,
+				bold: !1,
+				italic: !1,
+				color: (e.nodes.find((e) => e.connected) || n).labelColor,
+				alpha: 1,
+				outline: u.node,
+				align: "center",
+				family: v,
+				strike: !1
+			});
+		}
+	}
+	return l;
+}
+var it = (e) => `${e.italic ? "italic " : ""}${e.bold ? "bold " : ""}${e.screen ? e.px : e.size}px ${e.family}`, at = {
+	ox: 0,
+	oy: 0,
+	k: 1
+};
+function ot(e, t, n) {
+	e.font = it(t);
+	let r = e.measureText(t.text).width + 8, i = t.px * 1.3 + 4, a = n.ox + t.x * n.k, o = n.oy + t.y * n.k, s = a - r / 2, c = o - t.px * Ke - 2;
+	e.globalAlpha = 1, e.beginPath(), e.roundRect ? e.roundRect(s, c, r, i, 4) : e.rect(s, c, r, i), e.fillStyle = t.outline ? t.outline.color : "rgba(9, 13, 22, 0.95)", e.fill(), e.lineWidth = 1, e.strokeStyle = t.color, e.stroke(), e.textAlign = t.align, e.fillStyle = t.color, e.fillText(t.text, a, o);
+}
+function st() {
+	return {
+		font: "",
+		alpha: -1,
+		fill: "",
+		stroke: "",
+		width: -1,
+		align: ""
+	};
+}
+function ct(e, t, n, r = at) {
+	if (t.kind === "chip") {
+		ot(e, t, r);
+		return;
+	}
+	n.alpha !== t.alpha && (e.globalAlpha = t.alpha, n.alpha = t.alpha);
+	let i = it(t);
+	n.font !== i && (e.font = i, n.font = i), n.align !== t.align && (e.textAlign = t.align, n.align = t.align);
+	let a = r.ox + t.x * r.k, o = r.oy + t.y * r.k;
+	if (t.outline) {
+		e.lineJoin = "round";
+		let i = t.outline.width * r.k;
+		n.stroke !== t.outline.color && (e.strokeStyle = t.outline.color, n.stroke = t.outline.color), n.width !== i && (e.lineWidth = i, n.width = i), e.strokeText(t.text, a, o);
+	}
+	if (n.fill !== t.color && (e.fillStyle = t.color, n.fill = t.color), e.fillText(t.text, a, o), t.strike) {
+		let i = e.measureText(t.text).width / 2, s = t.screen ? t.px : t.size * r.k;
+		e.beginPath(), e.moveTo(a - i, o - s * .32), e.lineTo(a + i, o - s * .32), e.strokeStyle = t.color, e.lineWidth = 1.4, e.stroke(), n.stroke = t.color, n.width = 1.4;
+	}
+}
+function lt(e, t, n, r) {
+	let i = null;
+	for (let a of e) n >= t.x + a.l && n <= t.x + a.r && r >= t.y + a.t && r <= t.y + a.b && (!i || a.index > i.index) && (i = a);
+	return i ? i.id : null;
+}
+function ut(e, t = {}) {
+	let n = t.mapStyle || (() => x), r = e.getContext("2d"), i = 0, a = 0, o = 1, s = null, c, l, u, d, f, p, m = null, h = !0, g = !1, _ = /* @__PURE__ */ new Map(), v = R, y = (e, t, n) => {
+		let i = `${n ? "b" : "n"}${t}|${v}|${e}`, a = _.get(i);
+		return a === void 0 && (_.size > 2e4 && _.clear(), r.font = it({
+			italic: !1,
+			bold: n,
+			size: t,
+			family: v
+		}), a = r.measureText(e).width, _.set(i, a)), a;
+	};
+	return {
+		hit(e, t) {
+			return m && s ? lt(m, {
+				x: l,
+				y: u,
+				zoom: d
+			}, e, t) : null;
+		},
+		resize(t, n, s) {
+			i = t, a = n, o = s, e.width = t * s, e.height = n * s, r.setTransform(s, 0, 0, s, 0, 0), h = !0;
+		},
+		draw(e, t, _ = {}) {
+			if (g) return !1;
+			let b = n(), x = b.plain ? 0 : b.version, C = _.hover || null;
+			if (!h && e === s && e.version === c && t.x === l && t.y === u && t.zoom === d && x === f && C === p) return !1;
+			let w = m && e === s && e.version === c && t.zoom === d && x === f && !h;
+			s = e, c = e.version, l = t.x, u = t.y, d = t.zoom, f = x, p = C, h = !1;
+			let T = S(e, b);
+			v = T.labelFont || "\"Segoe UI\", -apple-system, BlinkMacSystemFont, Roboto, sans-serif", r.setTransform(o, 0, 0, o, 0, 0), r.clearRect(0, 0, i, a), r.save(), r.translate(t.x, t.y), r.scale(t.zoom, t.zoom), w || (m = nt(T, t.zoom, { measure: y }));
+			let E = rt(T, t, {
+				width: i,
+				height: a
+			}, {
+				measure: y,
+				hover: C,
+				placed: m
+			}), D = st();
+			for (let e of E) e.kind === "lane" && ct(r, e, D);
+			for (let e of E) e.kind === "node" && !e.screen && ct(r, e, D);
+			r.restore();
+			let O = {
+				ox: t.x,
+				oy: t.y,
+				k: t.zoom
+			};
+			D = st();
+			for (let e of E) e.kind === "node" && e.screen && ct(r, e, D, O);
+			for (let e of E) e.kind === "edge" && ct(r, e, D, O);
+			for (let e of E) e.kind === "chip" && ct(r, e, D, O);
+			return !0;
+		},
+		destroy() {
+			g = !0, s = null, m = null, _.clear(), r.setTransform(1, 0, 0, 1, 0, 0), r.clearRect(0, 0, i, a);
+		}
+	};
+}
+// ../explorer/engine/render.js
+var dt = [
+	"pointerdown",
+	"pointermove",
+	"mousedown",
+	"mousemove",
+	"wheel",
+	"touchstart",
+	"touchmove",
+	"keydown"
+];
+function ft(e, t = {}) {
+	if (e.map) return e.map;
+	let { state: n } = e, r = t.measureCovered || (() => n.coveredBottom || 0), i = ce(e).get, a = !1, o = (e) => de(n, e), s = (e) => de(n, e, { viewer: !0 }), l = (t, r = e.viewEdges(), i = {
+		throughChildren: !!n.throughChildren,
+		kind: n.selectedKind || null
+	}) => b(t, r, i), f = d((t) => c(t, { reduceMotion: e.reducedMotion })), p = () => f.get(n), m = () => f.builds, h = ze(), g = () => h.get(p()), _ = () => h.builds, v = null, y = null;
+	function x() {
+		return v && y === n.canvas || (v && v.destroy(), v = Fe(n.canvas, { mapStyle: i }), y = n.canvas, n.width && v.resize(n.width, n.height, e.dpr())), v;
+	}
+	let S = null, w = null;
+	function T() {
+		return n.labelCanvas ? (S && w === n.labelCanvas || (S && S.destroy(), S = ut(n.labelCanvas, { mapStyle: i }), w = n.labelCanvas, n.width && S.resize(n.width, n.height, e.dpr())), S) : null;
+	}
+	function E(t) {
+		v && v !== t && v.destroy(), v = t, y = n.canvas, n.width && v.resize(n.width, n.height, e.dpr()), V();
+	}
+	function D() {
+		let { canvas: t } = n;
+		n.width = t.parentElement.clientWidth, n.height = t.parentElement.clientHeight, x().resize(n.width, n.height, e.dpr());
+		let r = T();
+		r && r.resize(n.width, n.height, e.dpr()), V();
+	}
+	function O() {
+		let t = n.canvas && n.canvas.parentElement, r = e.win && e.win.ResizeObserver;
+		if (!t || !r) return () => {};
+		let i = new r(() => {
+			n.canvas && (t.clientWidth !== n.width || t.clientHeight !== n.height) && D();
+		});
+		i.observe(t);
+		let a = () => i.disconnect();
+		return e.own(a), a;
+	}
+	function k(e, t = null) {
+		let { nodes: i, width: a, height: s } = n, c = i.filter(o);
+		if (t) {
+			let e = c.filter((e) => t.has(e.id));
+			e.length && (c = e);
+		}
+		if (c.length === 0) return null;
+		let l = Math.max(160, s - r()), u = Infinity, d = -Infinity, f = Infinity, p = -Infinity;
+		c.forEach((e) => {
+			let t = e.r || 18;
+			u = Math.min(u, e.x - t - 25), d = Math.max(d, e.x + t + 25), f = Math.min(f, e.y - t - 25), p = Math.max(p, e.y + t + 35);
+		}), n.view === "dataflow" && n.flow && (f = Math.min(f, n.flow.top - 10)), n.view === "house" && n.house && n.house.fit && !t && ({minX: u, maxX: d, minY: f, maxY: p} = n.house.fit);
+		let m = Math.max(160, a - e * 2), h = Math.max(160, l - e * 2), g = Math.min(m / (d - u), h / (p - f));
+		return {
+			minX: u,
+			maxX: d,
+			minY: f,
+			maxY: p,
+			mapHeight: l,
+			raw: g
+		};
+	}
+	let A = "", j = C;
+	function M() {
+		let e = `${n.sceneVersion}|${n.width}|${n.height}|${n.view}|${r()}`;
+		if (e !== A) {
+			A = e;
+			let t = k(P());
+			j = t && t.raw > 0 && Number.isFinite(t.raw) ? Math.max(u, Math.min(C, t.raw)) : C;
+		}
+		return j;
+	}
+	function N(e = 40, t = null) {
+		let { width: r, camera: i } = n, a = k(e, t);
+		if (!a) return;
+		let { minX: o, maxX: s, minY: c, maxY: l, mapHeight: d } = a, f = Math.min(1, Math.max(u, a.raw));
+		i.zoom = f, i.x = r / 2 - (o + s) / 2 * f, i.y = d / 2 - (c + l) / 2 * f, V();
+	}
+	let P = () => n.width < 640 ? 24 : 48, F = (e, t) => ({
+		x: (e - n.camera.x) / n.camera.zoom,
+		y: (t - n.camera.y) / n.camera.zoom
+	}), I = -1;
+	function ee() {
+		if (!n.canvas) return;
+		let e = p();
+		I = e.version, x().draw(e, n.camera, performance.now());
+		let t = T();
+		t && t.draw(e, n.camera, { hover: n.hoverNodeId }), L.forEach((t) => t(e, n.camera));
+	}
+	function te(e, t) {
+		let n = T();
+		return n ? n.hit(e, t) : null;
+	}
+	function ne(e) {
+		let t = e || null;
+		if (n.hoverNodeId === t) return;
+		n.hoverNodeId = t;
+		let r = T();
+		r && n.canvas && n.width && r.draw(p(), n.camera, { hover: t });
+	}
+	let L = /* @__PURE__ */ new Set(), R = (e) => (L.add(e), () => L.delete(e)), z = /* @__PURE__ */ new Set(), B = Ge({
+		draw: ee,
+		packetsVisible: () => !!n.canvas && He(p(), n.camera, n.width, n.height),
+		isHidden: () => e.hidden(),
+		tickClients: (e) => {
+			let t = !1;
+			return z.forEach((n) => {
+				n.tick(e), n.wants() && (t = !0);
+			}), t;
+		},
+		clientsWant: () => [...z].some((e) => e.wants()),
+		reduceMotion: () => e.reducedMotion,
+		extraDirty: () => n.sceneVersion !== I,
+		now: () => performance.now(),
+		raf: (e) => requestAnimationFrame(e),
+		caf: (e) => cancelAnimationFrame(e)
+	});
+	function V() {
+		!a && n.canvas && B.markDirty();
+	}
+	function H() {
+		!a && n.canvas && B.drawNow();
+	}
+	function U(e) {
+		return z.add(e), () => z.delete(e);
+	}
+	if (e.root) {
+		let t = () => B.noteInput();
+		for (let n of dt) e.listen(e.root, n, t, {
+			passive: !0,
+			capture: !0
+		});
+	}
+	e.onShown(() => B.shown());
+	function W() {
+		a = !0, e.map === G && (e.map = null), B.cancel(), v && (v.release ? v.release() : v.destroy(), v = null, y = null), S && (S.destroy(), S = null, w = null), L.clear(), z.clear();
+	}
+	let G = {
+		isNodeVisible: o,
+		isNodeVisibleToViewer: s,
+		getActiveSubgraph: l,
+		getScene: p,
+		sceneBuilds: m,
+		getSpatialIndex: g,
+		spatialBuilds: _,
+		getRenderer: x,
+		setRenderer: E,
+		resize: D,
+		watchSize: O,
+		getMinZoom: M,
+		fitGraphToViewport: N,
+		fitPadding: P,
+		screenToWorld: F,
+		labelNodeAt: te,
+		setHoverNode: ne,
+		onPaint: R,
+		render: V,
+		renderNow: H,
+		addFrameClient: U,
+		queueFrameWork: (e, t) => {
+			a || B.queue(e, t);
+		},
+		frameStats: () => ({
+			frames: B.frames,
+			draws: B.draws
+		}),
+		holdFrames: (e) => {
+			a || B.hold(e);
+		},
+		cancelFrame: () => B.cancel(),
+		ensureFlowLoop: () => {
+			a || B.wake();
+		},
+		destroy: W
+	};
+	return e.map = G, e.own(W), G;
+}
+// ../explorer/shaders.js
+var X = "#version 300 es\nprecision highp float;\nuniform vec2 u_viewport;\nuniform vec3 u_cam;\nuniform float u_dpr;\n", Z = "\nvec4 toClip(vec2 pos) {\n  return vec4(pos.x / u_viewport.x * 2.0 - 1.0, 1.0 - pos.y / u_viewport.y * 2.0, 0.0, 1.0);\n}\n", Q = "\nout vec4 outColor;\n\n// Coverage of one device pixel by the half plane d < 0 (d: signed distance in CSS px, pix: the pixel's size)\nfloat coverEdge(float d, float pix) {\n  return clamp(0.5 - d / pix, 0.0, 1.0);\n}\n\n// Coverage of one pixel by a band of half width hw around dist = 0 (dist >= 0: distance from the centre line)\nfloat coverBand(float dist, float hw, float pix) {\n  float hi = min(hw, dist + 0.5 * pix);\n  float lo = max(-hw, dist - 0.5 * pix);\n  return clamp((hi - lo) / pix, 0.0, 1.0);\n}\n\n// Coverage by a dash pattern along an arc (on / off in world units; on <= 0 or off <= 0 is solid)\nfloat coverDash(float arc, float on, float off, float pixWorld) {\n  if (on <= 0.0 || off <= 0.0) return 1.0;\n  float period = on + off;\n  float u = mod(arc - on * 0.5 + period * 0.5, period) - period * 0.5;\n  return clamp((on * 0.5 - abs(u)) / pixWorld + 0.5, 0.0, 1.0);\n}\n\n// Straight colour at alpha a, composited over acc (premultiplied)\nvoid over(inout vec4 acc, vec3 rgb, float a) {\n  acc = vec4(rgb * a, a) + acc * (1.0 - a);\n}\n\n// What Canvas 2D's shadowBlur gives a disc of radius R at distance len from its centre: a blurred copy\n// of the disc. s is the blur's sigma in CSS px (shadowBlur is in DEVICE px and sigma = blur / 2). A big\n// disc has a straight-edge profile (a logistic stands in for the Gaussian's CDF); a small one is a\n// Gaussian bump whose height is what the blur leaves of it.\nfloat glowDisc(float len, float R, float s) {\n  float wide = 1.0 / (1.0 + exp(clamp(1.702 * (len - R) / s, -30.0, 30.0)));\n  float narrow = (1.0 - exp(-R * R / (2.0 * s * s))) * exp(-len * len / (2.0 * s * s));\n  return mix(narrow, wide, smoothstep(0.5 * s, 2.5 * s, R));\n}\n\n// The normal distribution's CDF, as the same logistic (error under 0.01)\nfloat phi(float x) {\n  return 1.0 / (1.0 + exp(clamp(-1.702 * x, -30.0, 30.0)));\n}\n", pt = `${X}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_grid;   // size, width
+layout(location = 2) in vec4 a_color;
+out vec2 v_pos;
+flat out vec4 v_grid;
+flat out vec4 v_color;
+void main() {
+  v_pos = vec2((a_corner.x * 0.5 + 0.5) * u_viewport.x, (0.5 - a_corner.y * 0.5) * u_viewport.y);
+  v_grid = a_grid;
+  v_color = a_color;
+  gl_Position = vec4(a_corner, 0.0, 1.0);
+}
+`, mt = `${X}${Q}
+in vec2 v_pos;
+flat in vec4 v_grid;
+flat in vec4 v_color;
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  vec2 world = (v_pos - u_cam.xy) / zoom;
+  vec2 dist = abs(world - floor(world / v_grid.x + 0.5) * v_grid.x) * zoom;
+  float hw = v_grid.y * zoom * 0.5;
+  float cover = max(coverBand(dist.x, hw, pix), coverBand(dist.y, hw, pix));
+  outColor = vec4(v_color.rgb * v_color.a, v_color.a) * cover;
+}
+`, ht = `${X}${Z}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_rect;    // x, y, w, h (world)
+layout(location = 2) in vec4 a_fill;
+layout(location = 3) in vec4 a_stroke;
+layout(location = 4) in vec2 a_style;   // corner radius, stroke width (world)
+out vec2 v_local;
+flat out vec2 v_half;
+flat out vec2 v_style;
+flat out vec4 v_fill;
+flat out vec4 v_stroke;
+void main() {
+  float zoom = u_cam.z;
+  vec2 half_ = a_rect.zw * 0.5 * zoom;
+  vec2 centre = u_cam.xy + (a_rect.xy + a_rect.zw * 0.5) * zoom;
+  vec2 ext = half_ + a_style.y * zoom * 0.5 + 2.0;
+  vec2 pos = clamp(centre + a_corner * ext, vec2(0.0), u_viewport);
+  v_local = pos - centre;
+  v_half = half_;
+  v_style = a_style;
+  v_fill = a_fill;
+  v_stroke = a_stroke;
+  gl_Position = toClip(pos);
+}
+`, gt = `${X}${Q}
+in vec2 v_local;
+flat in vec2 v_half;
+flat in vec2 v_style;
+flat in vec4 v_fill;
+flat in vec4 v_stroke;
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float rad = min(v_style.x * zoom, min(v_half.x, v_half.y));
+  vec2 q = abs(v_local) - v_half + rad;
+  float sd = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - rad;
+  vec4 acc = vec4(0.0);
+  over(acc, v_fill.rgb, v_fill.a * coverEdge(sd, pix));
+  over(acc, v_stroke.rgb, v_stroke.a * coverBand(abs(sd), v_style.y * zoom * 0.5, pix));
+  outColor = acc;
+}
+`, _t = `${X}${Z}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_geom;    // x, y, r, width (world)
+layout(location = 2) in vec4 a_color;
+layout(location = 3) in vec2 a_dash;    // on, off (world)
+out vec2 v_local;
+flat out vec4 v_geom;
+flat out vec4 v_color;
+flat out vec2 v_dash;
+void main() {
+  float zoom = u_cam.z;
+  vec2 centre = u_cam.xy + a_geom.xy * zoom;
+  float ext = (a_geom.z + a_geom.w * 0.5) * zoom + 2.0;
+  vec2 pos = clamp(centre + a_corner * ext, vec2(0.0), u_viewport);
+  v_local = pos - centre;
+  v_geom = a_geom;
+  v_color = a_color;
+  v_dash = a_dash;
+  gl_Position = toClip(pos);
+}
+`, vt = `${X}${Q}
+in vec2 v_local;
+flat in vec4 v_geom;
+flat in vec4 v_color;
+flat in vec2 v_dash;
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float len = length(v_local);
+  float cover = coverBand(abs(len - v_geom.z * zoom), v_geom.w * zoom * 0.5, pix);
+  // Dashes run clockwise from angle 0, as Canvas 2D's arc() does
+  float arc = mod(atan(v_local.y, v_local.x) + 6.2831853, 6.2831853) * v_geom.z;
+  cover *= coverDash(arc, v_dash.x, v_dash.y, pix / zoom);
+  outColor = vec4(v_color.rgb * v_color.a, v_color.a) * cover;
+}
+`, yt = `${X}${Z}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_geom;    // x, y, r (world), alpha
+layout(location = 2) in vec4 a_color;   // r, g, b (0..1), glow (px)
+layout(location = 3) in vec4 a_kind;    // halo code, mark code, colour alpha, shape code (0 circle, 1 rounded square, 2 hexagon, 3 square, 4 diamond; plus 8 when a glyph takes the core dot's place)
+uniform vec4 u_haloGeom[4];             // fillR, ringR, ringWidth (world)
+uniform vec4 u_markGeom[5];             // per mark code: ringR, ringWidth (world), dash on, dash off
+uniform vec3 u_markMin;                 // MARK_MIN_PX, in screen px: ring thickness, edge thickness, gap from the node
+out vec2 v_local;
+flat out vec4 v_geom;
+flat out vec4 v_color;
+flat out vec4 v_kind;
+void main() {
+  float zoom = u_cam.z;
+  int halo = int(a_kind.x + 0.5);
+  int mark = int(a_kind.y + 0.5);
+  // The quad reaches as far as the farthest thing drawn: the glow (3 sigma), the halo ring, the mark ring
+  float pad = a_color.w * 1.5 / u_dpr;
+  if (halo > 0) pad = max(pad, (u_haloGeom[halo].y + u_haloGeom[halo].z * 0.5) * zoom);
+  if (mark > 0) pad = max(pad, max(u_markGeom[mark].x * zoom, u_markMin.z) + max(u_markGeom[mark].y * zoom, u_markMin.x) + 1.5);
+  float ext = a_geom.z * zoom * 1.2 + pad + 2.0; // a diamond reaches 1.15 radii
+  vec2 centre = u_cam.xy + a_geom.xy * zoom;
+  v_local = a_corner * ext;
+  v_geom = a_geom;
+  v_color = a_color;
+  v_kind = a_kind;
+  gl_Position = toClip(centre + v_local);
+}
+`, bt = `${X}${Q}
+in vec2 v_local;
+flat in vec4 v_geom;
+flat in vec4 v_color;
+flat in vec4 v_kind;
+uniform vec4 u_shape;                   // rounded square half side, its corner, hexagon inradius, square half side (x radius)
+uniform vec2 u_shape2;                  // square corner, diamond half diagonal (x radius)
+uniform float u_glyphMin;               // GLYPH_MIN_PX: a node this wide on screen shows its glyph (the icon pass) instead of the core dot
+uniform vec4 u_haloFill[4];
+uniform vec4 u_haloRing[4];
+uniform vec4 u_haloGeom[4];
+uniform vec4 u_markColor[5];
+uniform vec4 u_markGeom[5];
+uniform vec3 u_markMin;
+uniform vec4 u_core;
+uniform float u_coreRatio;
+// Signed distance (px) to a node's silhouette of radius R: the same shapes renderer-canvas2d.js draws (silhouette)
+float sdRoundBox(vec2 p, float h, float c) {
+  vec2 q = abs(p) - vec2(h - c);
+  return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - c;
+}
+float sdHex(vec2 p, float r) {
+  const vec3 k = vec3(-0.866025404, 0.5, 0.577350269);
+  p = abs(p);
+  p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+  p -= vec2(clamp(p.x, -k.z * r, k.z * r), r);
+  return length(p) * sign(p.y);
+}
+float sdShape(vec2 p, float R, int shape, float len) {
+  if (shape == 1) return sdRoundBox(p, u_shape.x * R, u_shape.y * R);
+  if (shape == 2) return sdHex(p.yx, u_shape.z * R);
+  if (shape == 3) return sdRoundBox(p, u_shape.w * R, u_shape2.x * R);
+  if (shape == 4) return (abs(p.x) + abs(p.y) - u_shape2.y * R) * 0.70710678;
+  return len - R;
+}
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float rw = v_geom.z;
+  float R = rw * zoom;
+  float al = v_geom.w;
+  float len = length(v_local);
+  vec4 acc = vec4(0.0);
+
+  // Halo: a translucent disc, then a ring
+  int halo = int(v_kind.x + 0.5);
+  if (halo > 0) {
+    vec4 fill = u_haloFill[halo];
+    if (fill.a > 0.0) over(acc, fill.rgb, fill.a * al * coverEdge(len - (rw + u_haloGeom[halo].x) * zoom, pix));
+    vec4 ring = u_haloRing[halo];
+    over(acc, ring.rgb, ring.a * al * coverBand(abs(len - (rw + u_haloGeom[halo].y) * zoom), u_haloGeom[halo].z * zoom * 0.5, pix));
+  }
+
+  // Glow: a blurred copy of the disc under it (see glowDisc)
+  float glow = v_color.w;
+  if (glow > 0.0) over(acc, v_color.rgb, v_kind.z * al * glowDisc(len, R, glow * 0.5 / u_dpr));
+
+  // The silhouette, and its white core unless the type's glyph is drawn there (glyphs.js: the icon pass draws it once the node is wide enough)
+  int shapeCode = int(v_kind.w + 0.5);
+  bool glyph = shapeCode >= 8;
+  if (glyph) shapeCode -= 8;
+  over(acc, v_color.rgb, v_kind.z * al * coverEdge(sdShape(v_local, R, shapeCode, len), pix));
+  if (!glyph || 2.0 * R < u_glyphMin) over(acc, u_core.rgb, u_core.a * al * coverEdge(len - R * u_coreRatio, pix));
+
+  // Mark: a ring with the look of its own mark (dashed when its dash is set: added), and for removed a
+  // strike through the node. However far out the camera is, the ring stays u_markMin.z px from the node
+  // and u_markMin.x px thick (scene.js MARK_MIN_PX; renderer-canvas2d.js drawNode does the same).
+  int mark = int(v_kind.y + 0.5);
+  if (mark > 0) {
+    vec4 mc = u_markColor[mark];
+    vec4 mg = u_markGeom[mark];
+    float ringW = rw + max(mg.x, u_markMin.z / zoom);
+    float rr = ringW * zoom;
+    float wpx = max(mg.y * zoom, u_markMin.x);
+    float cover = coverBand(abs(len - rr), wpx * 0.5, pix);
+    if (mg.z > 0.0 && mg.w > 0.0 && len > 0.5) {
+      // a whole number of dashes round the ring, so the pattern closes
+      float circ = 6.2831853 * ringW;
+      float n = max(floor(circ / (mg.z + mg.w) + 0.5), 1.0);
+      float period = circ / n;
+      float on = period * mg.z / (mg.z + mg.w);
+      float arc = mod(atan(v_local.y, v_local.x) + 6.2831853, 6.2831853) * ringW;
+      cover *= coverDash(arc, on, period - on, pix / zoom);
+    }
+    if (mark == 3) cover = max(cover, coverBand(abs(v_local.y), wpx * 0.5, pix) * coverEdge(abs(v_local.x) - rr, pix));
+    over(acc, mc.rgb, mc.a * al * cover);
+  }
+
+  outColor = acc;
+}
+`, xt = "\nvec2 bez(vec2 a, vec2 c, vec2 b, float t) {\n  float u = 1.0 - t;\n  return u * u * a + 2.0 * u * t * c + t * t * b;\n}\nvec2 bezD(vec2 a, vec2 c, vec2 b, float t) {\n  return 2.0 * (1.0 - t) * (c - a) + 2.0 * t * (b - c);\n}\n// Arc length from 0 to t, in world units (midpoint rule, 8 steps: the speed is smooth)\nfloat bezArc(vec2 a, vec2 c, vec2 b, float t) {\n  float sum = 0.0;\n  for (int j = 0; j < 8; j++) sum += length(bezD(a, c, b, (float(j) + 0.5) * t / 8.0));\n  return sum * t / 8.0;\n}\n", St = "\nvec2 packetPos(vec4 ends, vec4 mot, float timeSec) {\n  float k = fract(timeSec * mot.z + mot.w);\n  return bez(ends.xy, mot.xy, ends.zw, k);\n}\n", Ct = (e) => `${X}${xt}
+#define SEGS ${e}
+layout(location = 1) in vec4 a_ends;    // x1, y1, x2, y2 (world)
+layout(location = 2) in vec4 a_geom;    // control x, y (world), width (world), glow blur (px)
+layout(location = 3) in vec4 a_color;   // straight rgb, alpha (the edge's alpha folded in)
+layout(location = 4) in vec4 a_glow;    // glow rgb, glow strength (colour alpha x edge alpha)
+layout(location = 5) in vec2 a_dash;    // on, off (world); 0 = solid
+layout(location = 6) in float a_marked; // 1 = a proposal's mark: never thinner than u_markMin.y px
+uniform vec3 u_markMin;                 // MARK_MIN_PX in screen px: ring thickness, edge thickness, gap
+out float v_across;                     // CSS px from the centre line, signed
+out float v_arc;                        // world units along the edge from its start; below 0 and past the length on the end caps
+flat out float v_len;
+flat out float v_halfWidth;             // the stroke's half width in CSS px, minimum included
+flat out vec4 v_geom;
+flat out vec4 v_color;
+flat out vec4 v_glow;
+flat out vec2 v_dash;
+void main() {
+  float zoom = u_cam.z;
+  vec2 a = a_ends.xy;
+  vec2 b = a_ends.zw;
+  vec2 c = a_geom.xy;
+  int pair = gl_VertexID / 2;
+  float side = (gl_VertexID - pair * 2 == 0) ? -1.0 : 1.0;
+  float t = float(clamp(pair - 1, 0, SEGS)) / float(SEGS);
+  vec2 dir = bezD(a, c, b, t);
+  dir = dot(dir, dir) < 1e-9 ? vec2(1.0, 0.0) : normalize(dir);
+  vec2 normal = vec2(-dir.y, dir.x);
+  float halfWidth = max(a_geom.z * zoom, a_marked * u_markMin.y) * 0.5;
+  float pad = a_geom.w * 1.5 / u_dpr + 1.5;   // the glow's 3 sigma, and room to anti-alias
+  float ext = pair == 0 ? -pad : (pair == SEGS + 2 ? pad : 0.0);
+  vec2 pos = u_cam.xy + bez(a, c, b, t) * zoom + dir * ext + normal * side * (halfWidth + pad);
+  v_across = side * (halfWidth + pad);
+  v_arc = bezArc(a, c, b, t) + ext / zoom;
+  v_len = bezArc(a, c, b, 1.0);
+  v_halfWidth = halfWidth;
+  v_geom = a_geom;
+  v_color = a_color;
+  v_glow = a_glow;
+  v_dash = a_dash;
+  gl_Position = vec4(pos.x / u_viewport.x * 2.0 - 1.0, 1.0 - pos.y / u_viewport.y * 2.0, 0.0, 1.0);
+}
+`, wt = `${X}${Q}
+in float v_across;
+in float v_arc;
+flat in float v_len;
+flat in float v_halfWidth;
+flat in vec4 v_geom;
+flat in vec4 v_color;
+flat in vec4 v_glow;
+flat in vec2 v_dash;
+
+// How much of a blurred copy of the stroke's dashes (sigma sw, world units) is under arc
+float blurredDashes(float arc, float on, float off, float len, float sw) {
+  float whole = phi((arc - 0.0) / sw) - phi((arc - len) / sw);
+  if (on <= 0.0 || off <= 0.0) return whole;
+  float period = on + off;
+  float n = floor(arc / period);
+  float near = 0.0;
+  for (int j = -2; j <= 2; j++) {
+    float lo = (n + float(j)) * period;
+    float hi = min(lo + on, len);
+    lo = max(lo, 0.0);
+    if (hi > lo) near += phi((arc - lo) / sw) - phi((arc - hi) / sw);
+  }
+  // blurred wider than a few periods, the dashes are an even tint
+  return mix(min(near, 1.0), whole * on / period, smoothstep(0.5, 1.5, sw / period));
+}
+
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float dist = abs(v_across);
+  float halfWidth = v_halfWidth;
+  vec4 acc = vec4(0.0);
+
+  // Glow: Canvas 2D's shadowBlur of the stroke, dashes and all, under it (sigma = blur / 2 device px)
+  if (v_geom.w > 0.0 && v_glow.a > 0.0) {
+    float s = v_geom.w * 0.5 / u_dpr;
+    float across = phi((halfWidth - dist) / s) + phi((halfWidth + dist) / s) - 1.0;
+    float along = blurredDashes(v_arc, v_dash.x, v_dash.y, v_len, s / zoom);
+    over(acc, v_glow.rgb, v_glow.a * clamp(across, 0.0, 1.0) * clamp(along, 0.0, 1.0));
+  }
+
+  // The stroke: a band, with square ends and the dash pattern in world units
+  float cover = coverBand(dist, halfWidth, pix)
+    * coverEdge(-v_arc * zoom, pix)
+    * coverEdge((v_arc - v_len) * zoom, pix)
+    * coverDash(v_arc, v_dash.x, v_dash.y, pix / zoom);
+  over(acc, v_color.rgb, v_color.a * cover);
+  outColor = acc;
+}
+`, Tt = `${X}${Z}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_tip;     // x, y (world), direction x, y (unit)
+layout(location = 2) in vec4 a_color;
+layout(location = 3) in float a_kind;   // 1 = arrowhead (tip at x, y), 2 = strike (centred on x, y), 3 = chevron, 4 = bar, 5 = diamond (all with their tip at x, y), 6 = tick (centred on x, y)
+uniform vec4 u_tip;                     // arrow length, arrow spread (radians), strike half length, strike width (world)
+uniform vec4 u_end;                     // stroke width of the open marks, bar half length, diamond half length, diamond half width (world)
+out vec2 v_local;
+flat out vec4 v_color;
+flat out float v_kind;
+void main() {
+  float zoom = u_cam.z;
+  float ext = max(max(u_tip.x, 2.0 * u_end.z), max(u_tip.z, u_end.y)) * zoom + 3.0;
+  vec2 dir = a_tip.zw;
+  vec2 off = a_corner * ext;
+  v_local = vec2(dot(off, dir), dot(off, vec2(-dir.y, dir.x)));
+  v_color = a_color;
+  v_kind = a_kind;
+  gl_Position = toClip(u_cam.xy + a_tip.xy * zoom + off);
+}
+`, Et = `${X}${Q}
+in vec2 v_local;
+flat in vec4 v_color;
+flat in float v_kind;
+uniform vec4 u_tip;
+uniform vec4 u_end;                     // stroke width of the open marks, bar half length, diamond half length, diamond half width (world)
+uniform vec2 u_tick;                    // tick half length, tick width (world)
+// Distance to the segment a-b
+float sdSeg(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+// Distance to a rhombus with half diagonals b (iq's sdRhombus)
+float ndot(vec2 a, vec2 b) { return a.x * b.x - a.y * b.y; }
+float sdRhombus(vec2 p, vec2 b) {
+  p = abs(p);
+  float h = clamp(ndot(b - 2.0 * p, b) / dot(b, b), -1.0, 1.0);
+  float d = length(p - 0.5 * b * vec2(1.0 - h, 1.0 + h));
+  return d * sign(p.x * b.y + p.y * b.x - b.x * b.y);
+}
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float sd;
+  float L = u_tip.x * zoom;
+  float sn = sin(u_tip.y);
+  float cs = cos(u_tip.y);
+  float w = max(u_end.x * zoom, 1.2) * 0.5; // half the stroke of an open mark: at least 1.2 px thick so it stays visible zoomed out
+  if (v_kind < 1.5) {
+    // The triangle with its tip at the origin and two barbs L back, spread radians either side of the line
+    sd = max(max(sn * v_local.x + cs * v_local.y, sn * v_local.x - cs * v_local.y), -v_local.x - L * cs);
+  } else if (v_kind < 2.5) {
+    // A box across the edge, at least 1.5 px thick so it stays visible zoomed out
+    vec2 q = abs(v_local) - vec2(max(u_tip.w * zoom, 1.5) * 0.5, u_tip.z * zoom);
+    sd = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0);
+  } else if (v_kind < 3.5) {
+    // The chevron: the arrowhead's two barbs, open (a line each, from the tip back)
+    vec2 barb = vec2(-L * cs, L * sn);
+    sd = min(sdSeg(v_local, vec2(0.0), barb), sdSeg(v_local, vec2(0.0), vec2(barb.x, -barb.y))) - w;
+  } else if (v_kind < 4.5) {
+    // The bar: across the line at the target
+    vec2 q = abs(v_local - vec2(-w, 0.0)) - vec2(w, u_end.y * zoom);
+    sd = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0);
+  } else if (v_kind < 5.5) {
+    // The diamond: an outline, its front vertex at the tip
+    vec2 h = vec2(u_end.z, u_end.w) * zoom;
+    sd = abs(sdRhombus(v_local - vec2(-h.x, 0.0), h)) - w;
+  } else {
+    // The tick: a short box across the edge, centred, at least 1.5 px thick
+    vec2 q = abs(v_local) - vec2(max(u_tick.y * zoom, 1.5) * 0.5, u_tick.x * zoom);
+    sd = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0);
+  }
+  outColor = vec4(v_color.rgb * v_color.a, v_color.a) * coverEdge(sd, pix);
+}
+`, Dt = `${X}${Z}${xt}${St}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_ends;    // x1, y1, x2, y2 (world)
+layout(location = 2) in vec4 a_mot;     // control x, y (world), speed (trips per second), phase
+layout(location = 3) in vec4 a_color;   // the dot: straight rgb, alpha (edge alpha folded in)
+layout(location = 4) in vec4 a_glow;    // its glow: rgb, strength
+layout(location = 5) in vec2 a_size;    // radius (world), glow blur (px)
+uniform float u_time;                   // seconds
+out vec2 v_local;
+flat out vec4 v_size;
+flat out vec4 v_color;
+flat out vec4 v_glow;
+void main() {
+  float zoom = u_cam.z;
+  vec2 centre = u_cam.xy + packetPos(a_ends, a_mot, u_time) * zoom;
+  v_local = a_corner * (a_size.x * zoom + a_size.y * 1.5 / u_dpr + 2.0);
+  v_size = a_size.xyxy;
+  v_color = a_color;
+  v_glow = a_glow;
+  gl_Position = toClip(centre + v_local);
+}
+`, Ot = `${X}${Q}
+in vec2 v_local;
+flat in vec4 v_size;
+flat in vec4 v_color;
+flat in vec4 v_glow;
+void main() {
+  float zoom = u_cam.z;
+  float pix = 1.0 / u_dpr;
+  float len = length(v_local);
+  float R = v_size.x * zoom;
+  vec4 acc = vec4(0.0);
+  if (v_size.y > 0.0) over(acc, v_glow.rgb, v_glow.a * glowDisc(len, R, v_size.y * 0.5 / u_dpr));
+  over(acc, v_color.rgb, v_color.a * coverEdge(len - R, pix));
+  outColor = acc;
+}
+`, kt = `${X}${Z}
+layout(location = 0) in vec2 a_corner;
+layout(location = 1) in vec4 a_geom;    // x, y, side (world), alpha
+uniform float u_minR;                   // letters and glyphs: the least on-screen radius (px) of a node that shows them; 0 for a theme's icon
+uniform float u_sideRatio;              // the image's side as a multiple of the node's radius (LETTER_RATIO, GLYPH_RATIO), to read the radius back
+out vec2 v_uv;
+flat out float v_alpha;
+void main() {
+  if (u_minR > 0.0 && a_geom.z / u_sideRatio * u_cam.z < u_minR) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); v_uv = vec2(0.0); v_alpha = 0.0; return; } // too small on screen: outside the clip space, nothing drawn
+  vec2 centre = u_cam.xy + a_geom.xy * u_cam.z;
+  vec2 pos = centre + a_corner * (a_geom.z * 0.5 * u_cam.z);
+  v_uv = vec2(a_corner.x * 0.5 + 0.5, a_corner.y * 0.5 + 0.5); // screen y runs down and an image's first row is its top, so the corner below the centre reads the last row
+  v_alpha = a_geom.w;
+  gl_Position = toClip(pos);
+}
+`, At = `${X}
+uniform sampler2D u_tex;
+in vec2 v_uv;
+flat in float v_alpha;
+out vec4 outColor;
+void main() {
+  outColor = texture(u_tex, v_uv) * v_alpha; // the texture is uploaded premultiplied
+}
+`, jt = {
+	none: 0,
+	selected: 1,
+	match: 2,
+	child: 3
+}, Mt = {
+	arrow: 1,
+	strike: 2,
+	chevron: 3,
+	bar: 4,
+	diamond: 5,
+	tick: 6
+}, Nt = Object.freeze(Object.fromEntries(M.map((e, t) => [e, t]))), Pt = {
+	none: 0,
+	added: 1,
+	changed: 2,
+	removed: 3,
+	edit: 4
+}, $ = (e) => {
+	let [t, n, r, i] = L(e);
+	return [
+		t / 255,
+		n / 255,
+		r / 255,
+		i
+	];
+}, Ft = (e, t) => Object.hasOwn(e, t) ? e[t] : 0;
+function It(e) {
+	let { nodes: t } = e, n = new Float32Array(t.length * 12);
+	return t.forEach((e, t) => {
+		let [r, i, a, o] = $(e.color);
+		n.set([
+			e.x,
+			e.y,
+			e.r,
+			e.alpha,
+			r,
+			i,
+			a,
+			e.glow || 0,
+			Ft(jt, e.halo),
+			Ft(Pt, e.mark),
+			o,
+			Ft(Nt, e.shape) + (e.glyph && !e.icon && !e.letters ? 8 : 0)
+		], t * 12);
+	}), {
+		data: n,
+		count: t.length,
+		stride: 12
+	};
+}
+function Lt(e) {
+	let { grid: t, rings: n, lanes: r } = e.decor, i = new Float32Array(t ? 8 : 0);
+	t && i.set([
+		t.size,
+		t.width,
+		0,
+		0,
+		...$(t.color)
+	]);
+	let a = new Float32Array(n.length * 10);
+	n.forEach((e, t) => {
+		let [n, r] = e.dash && e.dash.length >= 2 ? e.dash : [0, 0];
+		a.set([
+			e.x,
+			e.y,
+			e.r,
+			e.width,
+			...$(e.color),
+			n,
+			r
+		], t * 10);
+	});
+	let o = new Float32Array(r.length * 14);
+	return r.forEach((e, t) => {
+		o.set([
+			e.x,
+			e.y,
+			e.w,
+			e.h,
+			...$(e.fill),
+			...$(e.stroke),
+			e.radius,
+			e.strokeWidth
+		], t * 14);
+	}), {
+		grid: {
+			data: i,
+			count: +!!t,
+			stride: 8
+		},
+		rings: {
+			data: a,
+			count: n.length,
+			stride: 10
+		},
+		lanes: {
+			data: o,
+			count: r.length,
+			stride: 14
+		}
+	};
+}
+function Rt(e) {
+	let t = {
+		straight: [],
+		curved: [],
+		tips: [],
+		packets: []
+	};
+	e.edges.forEach((e) => {
+		let [n, r, i, a] = $(e.color), o = e.alpha, s = a * o, [c, l] = e.dash && e.dash.length >= 2 ? e.dash : [0, 0], u = e.glow > 0 && !!e.glowColor, [d, f, p, h] = u ? $(e.glowColor) : [
+			0,
+			0,
+			0,
+			0
+		], g = e.curve ? e.curve.cx : (e.x1 + e.x2) / 2, _ = e.curve ? e.curve.cy : (e.y1 + e.y2) / 2, v = e.mark && e.mark !== "none" ? 1 : 0;
+		if (t[e.curve ? "curved" : "straight"].push([
+			e.x1,
+			e.y1,
+			e.x2,
+			e.y2,
+			g,
+			_,
+			e.width,
+			u ? e.glow : 0,
+			n,
+			r,
+			i,
+			s,
+			d,
+			f,
+			p,
+			h * s,
+			c,
+			l,
+			v
+		]), e.arrow) {
+			let a = Math.atan2(e.y2 - (e.curve ? e.curve.cy : e.y1), e.x2 - (e.curve ? e.curve.cx : e.x1)), o = e.end && e.end !== "triangle" && Ft(Mt, e.end) || Mt.arrow;
+			t.tips.push([
+				e.x2,
+				e.y2,
+				Math.cos(a),
+				Math.sin(a),
+				n,
+				r,
+				i,
+				s,
+				o
+			]);
+		}
+		if (e.ticks) {
+			let a = m(e, .5), o = Math.hypot(e.x2 - e.x1, e.y2 - e.y1), [c, l] = o > 0 ? [(e.x2 - e.x1) / o, (e.y2 - e.y1) / o] : [1, 0];
+			for (let o = 0; o < e.ticks; o++) {
+				let u = (o - (e.ticks - 1) / 2) * z.tickGap;
+				t.tips.push([
+					a.x + c * u,
+					a.y + l * u,
+					c,
+					l,
+					n,
+					r,
+					i,
+					s,
+					Mt.tick
+				]);
+			}
+		}
+		if (e.mark === "removed") {
+			let a = m(e, .5), o = Math.hypot(e.x2 - e.x1, e.y2 - e.y1), [c, l] = o > 0 ? [(e.x2 - e.x1) / o, (e.y2 - e.y1) / o] : [1, 0];
+			t.tips.push([
+				a.x,
+				a.y,
+				c,
+				l,
+				n,
+				r,
+				i,
+				s,
+				Mt.strike
+			]);
+		}
+		if (e.packet) {
+			let n = e.packet, [r, i, a, s] = $(n.color), [c, l, u, d] = $(n.glowColor);
+			t.packets.push([
+				e.x1,
+				e.y1,
+				e.x2,
+				e.y2,
+				g,
+				_,
+				n.speed,
+				n.phase,
+				r,
+				i,
+				a,
+				s * o,
+				c,
+				l,
+				u,
+				d * s * o,
+				n.radius,
+				n.glow
+			]);
+		}
+	});
+	let n = (e, t) => {
+		let n = new Float32Array(e.length * t);
+		return e.forEach((e, r) => n.set(e, r * t)), {
+			data: n,
+			count: e.length,
+			stride: t
+		};
+	};
+	return {
+		straight: n(t.straight, 19),
+		curved: n(t.curved, 19),
+		tips: n(t.tips, 9),
+		packets: n(t.packets, 18)
+	};
+}
+var zt = (e) => ({
+	...Lt(e),
+	nodes: It(e),
+	...Rt(e)
+});
+function Bt(e) {
+	let t = [];
+	e.nodes.forEach((e) => {
+		if (!e.stroke) return;
+		let [n, r, i, a] = $(e.stroke.color);
+		t.push([
+			e.x,
+			e.y,
+			Math.max(0, e.r - e.stroke.width / 2),
+			e.stroke.width,
+			n,
+			r,
+			i,
+			a * e.alpha,
+			0,
+			0
+		]);
+	});
+	let n = new Float32Array(t.length * 10);
+	return t.forEach((e, t) => n.set(e, t * 10)), {
+		data: n,
+		count: t.length,
+		stride: 10
+	};
+}
+function Vt(e, t, n = null) {
+	let r = /* @__PURE__ */ new Map();
+	e.nodes.forEach((e) => {
+		let i = e.icon && t(e.icon) ? e.icon : null, a = e.r * le;
+		if (!i && !e.icon && e.letters && t(pe(e.letters)) && (i = pe(e.letters), a = e.r * 1), !i && !e.icon && !e.letters && e.glyph) {
+			let r = y(e.glyph, D(e, n));
+			t(r) && (i = r, a = e.r * G);
+		}
+		if (!i) return;
+		r.has(i) || r.set(i, {
+			rows: [],
+			minR: Infinity,
+			maxR: 0
+		});
+		let o = r.get(i);
+		o.maxR = Math.max(o.maxR, e.r), o.rows.push([
+			e.x,
+			e.y,
+			a,
+			e.alpha
+		]), o.minR = Math.min(o.minR, e.r);
+	});
+	let i = [], a = [];
+	for (let [e, { rows: t, minR: n, maxR: o }] of r) i.push({
+		kind: e,
+		first: a.length,
+		count: t.length,
+		minR: n,
+		maxR: o
+	}), a.push(...t);
+	let o = new Float32Array(a.length * 4);
+	return a.forEach((e, t) => o.set(e, t * 4)), {
+		data: o,
+		count: a.length,
+		stride: 4,
+		groups: i
+	};
+}
+function Ht(e = "dark", t = null) {
+	let { halo: n, mark: r, core: s } = t ? a(i(e), t) : i(e), c = /* @__PURE__ */ new Float32Array(16), l = /* @__PURE__ */ new Float32Array(16), u = /* @__PURE__ */ new Float32Array(16);
+	Object.entries(jt).forEach(([e, t]) => {
+		let r = n[e];
+		t && r && (c.set($(r.fill), t * 4), l.set($(r.ring), t * 4), u.set([
+			r.fillR,
+			r.ringR,
+			r.ringWidth,
+			0
+		], t * 4));
+	});
+	let d = /* @__PURE__ */ new Float32Array(20), f = /* @__PURE__ */ new Float32Array(20);
+	return Object.entries(Pt).forEach(([e, t]) => {
+		if (!t) return;
+		let n = r[e];
+		d.set($(n.color), t * 4);
+		let [i, a] = n.ringDash || [0, 0];
+		f.set([
+			n.ringR,
+			n.ringWidth,
+			i,
+			a
+		], t * 4);
+	}), {
+		haloFill: c,
+		haloRing: l,
+		haloGeom: u,
+		markColor: d,
+		markGeom: f,
+		markMin: new Float32Array([
+			g.ring,
+			g.edge,
+			g.gap
+		]),
+		core: new Float32Array($(s)),
+		coreRatio: o
+	};
+}
+var Ut = [
+	{
+		name: "grid",
+		vert: pt,
+		frag: mt,
+		stride: 8,
+		attribs: [[
+			1,
+			4,
+			0
+		], [
+			2,
+			4,
+			4
+		]]
+	},
+	{
+		name: "lanes",
+		vert: ht,
+		frag: gt,
+		stride: 14,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				4,
+				8
+			],
+			[
+				4,
+				2,
+				12
+			]
+		]
+	},
+	{
+		name: "rings",
+		vert: _t,
+		frag: vt,
+		stride: 10,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				2,
+				8
+			]
+		]
+	},
+	{
+		name: "straight",
+		vert: Ct(1),
+		frag: wt,
+		stride: 19,
+		verts: 8,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				4,
+				8
+			],
+			[
+				4,
+				4,
+				12
+			],
+			[
+				5,
+				2,
+				16
+			],
+			[
+				6,
+				1,
+				18
+			]
+		],
+		constants: "edges"
+	},
+	{
+		name: "curved",
+		vert: Ct(24),
+		frag: wt,
+		stride: 19,
+		verts: 54,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				4,
+				8
+			],
+			[
+				4,
+				4,
+				12
+			],
+			[
+				5,
+				2,
+				16
+			],
+			[
+				6,
+				1,
+				18
+			]
+		],
+		constants: "edges"
+	},
+	{
+		name: "tips",
+		vert: Tt,
+		frag: Et,
+		stride: 9,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				1,
+				8
+			]
+		],
+		constants: "tips"
+	},
+	{
+		name: "packets",
+		vert: Dt,
+		frag: Ot,
+		stride: 18,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				4,
+				8
+			],
+			[
+				4,
+				4,
+				12
+			],
+			[
+				5,
+				2,
+				16
+			]
+		],
+		time: !0
+	},
+	{
+		name: "nodes",
+		vert: yt,
+		frag: bt,
+		stride: 12,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				4,
+				8
+			]
+		],
+		constants: "nodes"
+	}
+], Wt = {
+	nodes(e, t, n) {
+		e.uniform4fv(t("u_haloFill"), n.haloFill), e.uniform4fv(t("u_haloRing"), n.haloRing), e.uniform4fv(t("u_haloGeom"), n.haloGeom), e.uniform4fv(t("u_markColor"), n.markColor), e.uniform4fv(t("u_markGeom"), n.markGeom), e.uniform3fv(t("u_markMin"), n.markMin), e.uniform4fv(t("u_core"), n.core), e.uniform1f(t("u_coreRatio"), n.coreRatio), e.uniform4f(t("u_shape"), v.roundedHalf, v.roundedCorner, v.hexInradius, v.squareHalf), e.uniform2f(t("u_shape2"), v.squareCorner, v.diamondHalf), e.uniform1f(t("u_glyphMin"), 14);
+	},
+	edges(e, t, n) {
+		e.uniform3fv(t("u_markMin"), n.markMin);
+	},
+	tips(e, t) {
+		e.uniform4f(t("u_tip"), s.length, s.spread, _.halfLength, _.width), e.uniform4f(t("u_end"), z.strokeWidth, z.barHalf, z.diamondHalf, z.diamondAcross), e.uniform2f(t("u_tick"), z.tickHalf, z.tickWidth);
+	}
+}, Gt = {
+	alpha: !0,
+	premultipliedAlpha: !0,
+	antialias: !1,
+	depth: !1,
+	stencil: !1,
+	preserveDrawingBuffer: !1,
+	powerPreference: "high-performance"
+};
+function Kt(e, t, n, r) {
+	let i = e.createShader(t);
+	if (e.shaderSource(i, n), e.compileShader(i), !e.getShaderParameter(i, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(i);
+		throw e.deleteShader(i), Error(`${r} shader did not compile: ${t}`);
+	}
+	return i;
+}
+function qt(e, t, n, r) {
+	let i = Kt(e, e.VERTEX_SHADER, t, `${r} vertex`), a = Kt(e, e.FRAGMENT_SHADER, n, `${r} fragment`), o = e.createProgram();
+	if (e.attachShader(o, i), e.attachShader(o, a), e.linkProgram(o), e.deleteShader(i), e.deleteShader(a), !e.getProgramParameter(o, e.LINK_STATUS)) {
+		let t = e.getProgramInfoLog(o);
+		throw e.deleteProgram(o), Error(`${r} program did not link: ${t}`);
+	}
+	return o;
+}
+var Jt = (e) => !e || e.plain ? 0 : e.version;
+function Yt(e, t, n, r = null) {
+	let i = Ht(n, r);
+	t.passes.forEach((t) => {
+		t.spec.constants && (e.useProgram(t.program), Wt[t.spec.constants](e, t.at, i));
+	}), t.theme = n, t.styleKey = Jt(r);
+}
+function Xt(e, t, n) {
+	let r = qt(e, t.vert, t.frag, t.name), i = e.createVertexArray(), a = e.createBuffer();
+	e.bindVertexArray(i), t.verts || (e.bindBuffer(e.ARRAY_BUFFER, n), e.enableVertexAttribArray(0), e.vertexAttribPointer(0, 2, e.FLOAT, !1, 0, 0), e.vertexAttribDivisor(0, 0)), e.bindBuffer(e.ARRAY_BUFFER, a), t.attribs.forEach(([n, r, i]) => {
+		e.enableVertexAttribArray(n), e.vertexAttribPointer(n, r, e.FLOAT, !1, t.stride * 4, i * 4), e.vertexAttribDivisor(n, 1);
+	}), e.bindVertexArray(null);
+	let o = (t) => e.getUniformLocation(r, t);
+	return {
+		spec: t,
+		program: r,
+		vao: i,
+		buffer: a,
+		at: o,
+		count: 0,
+		uniforms: {
+			viewport: o("u_viewport"),
+			cam: o("u_cam"),
+			dpr: o("u_dpr"),
+			time: t.time ? o("u_time") : null
+		}
+	};
+}
+var Zt = {
+	strokes: {
+		name: "strokes",
+		vert: _t,
+		frag: vt,
+		stride: 10,
+		attribs: [
+			[
+				1,
+				4,
+				0
+			],
+			[
+				2,
+				4,
+				4
+			],
+			[
+				3,
+				2,
+				8
+			]
+		]
+	},
+	icons: {
+		name: "icons",
+		vert: kt,
+		frag: At,
+		stride: 4,
+		attribs: [[
+			1,
+			4,
+			0
+		]]
+	}
+};
+function Qt(e, t = "dark", n = null) {
+	let r = e.createBuffer();
+	e.bindBuffer(e.ARRAY_BUFFER, r), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		1,
+		1
+	]), e.STATIC_DRAW);
+	let i = {
+		corners: r,
+		passes: Ut.map((t) => Xt(e, t, r)),
+		theme: t,
+		styleKey: 0,
+		extras: {
+			strokes: null,
+			icons: null
+		},
+		textures: /* @__PURE__ */ new Map(),
+		iconStore: null
+	};
+	return Yt(e, i, t, n), i;
+}
+function $t(e, t) {
+	e.deleteBuffer(t.corners), t.textures.forEach(({ texture: t }) => e.deleteTexture(t)), [...t.passes, ...Object.values(t.extras).filter(Boolean)].forEach((t) => {
+		e.deleteProgram(t.program), e.deleteVertexArray(t.vao), e.deleteBuffer(t.buffer);
+	});
+}
+function en(e, t = {}) {
+	let n = t.gl || e.getContext("webgl2", Gt);
+	if (!n) throw Error("WebGL2 is not available");
+	let i = t.mapStyle || (() => x), a = {
+		uploads: 0,
+		draws: 0
+	}, o = Qt(n), s = !1, c = 0, l = 0, u = null, d = null, f, p = null;
+	function m(e) {
+		return o.extras[e] || (o.extras[e] = Xt(n, Zt[e], o.corners)), o.extras[e];
+	}
+	function h() {
+		o.passes.forEach((e) => {
+			let t = u[e.spec.name];
+			e.count = t.count, t.count && (n.bindBuffer(n.ARRAY_BUFFER, e.buffer), n.bufferData(n.ARRAY_BUFFER, t.data, n.DYNAMIC_DRAW));
+		});
+		for (let e of Object.keys(Zt)) {
+			let t = u[e];
+			if (!t.count && !o.extras[e]) continue;
+			let r = m(e);
+			r.count = t.count, t.count && (n.bindBuffer(n.ARRAY_BUFFER, r.buffer), n.bufferData(n.ARRAY_BUFFER, t.data, n.DYNAMIC_DRAW));
+		}
+		a.uploads++;
+	}
+	function g(e, t) {
+		n.bindTexture(n.TEXTURE_2D, e), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, t ? n.NEAREST : n.LINEAR_MIPMAP_LINEAR), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, t ? n.NEAREST : n.LINEAR);
+	}
+	function _(e, t, r) {
+		let i = o.textures.get(e);
+		if (!i || i.image !== t) {
+			i && n.deleteTexture(i.texture);
+			let r = n.createTexture();
+			n.bindTexture(n.TEXTURE_2D, r), n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !0), n.texImage2D(n.TEXTURE_2D, 0, n.RGBA, n.RGBA, n.UNSIGNED_BYTE, t), n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), n.generateMipmap(n.TEXTURE_2D), i = {
+				image: t,
+				texture: r,
+				pixelated: null
+			}, o.textures.set(e, i);
+		}
+		return i.pixelated !== r && (g(i.texture, r), i.pixelated = r), i.texture;
+	}
+	function v(t, m, g) {
+		if (p = [
+			t,
+			m,
+			g
+		], s || !o || !c || !l) return;
+		let v = i(), y = S(t, v), b = v.values ? v.values[A] : void 0;
+		(o.iconStore !== v.icons || o.glyphInk !== b) && (o.textures.forEach(({ texture: e }) => n.deleteTexture(e)), o.textures.clear(), o.iconStore = v.icons, o.glyphInk = b, d = null), (y !== d || y.version !== f) && (u = {
+			...zt(y),
+			strokes: Bt(y),
+			icons: Vt(y, (e) => me(e) ? !!ve(he(e), b) : oe(e) ? !!E(r(e).type, r(e).ink) : !!(v.icons && v.icons.get(e)), v)
+		}, d = y, f = y.version, h());
+		let x = y.theme || "dark";
+		(o.theme !== x || o.styleKey !== Jt(v)) && Yt(n, o, x, v), n.viewport(0, 0, e.width, e.height), n.clearColor(0, 0, 0, 0), n.clear(n.COLOR_BUFFER_BIT), n.enable(n.BLEND), n.blendFunc(n.ONE, n.ONE_MINUS_SRC_ALPHA), o.passes.forEach((t) => {
+			t.count && (n.useProgram(t.program), n.uniform2f(t.uniforms.viewport, c, l), n.uniform3f(t.uniforms.cam, m.x, m.y, m.zoom), n.uniform1f(t.uniforms.dpr, e.width / c), n.bindVertexArray(t.vao), t.uniforms.time && n.uniform1f(t.uniforms.time, (g || 0) / 1e3), n.drawArraysInstanced(n.TRIANGLE_STRIP, 0, t.spec.verts || 4, t.count), a.draws++);
+		});
+		let C = o.extras.strokes;
+		C && C.count && (n.useProgram(C.program), n.uniform2f(C.uniforms.viewport, c, l), n.uniform3f(C.uniforms.cam, m.x, m.y, m.zoom), n.uniform1f(C.uniforms.dpr, e.width / c), n.bindVertexArray(C.vao), n.drawArraysInstanced(n.TRIANGLE_STRIP, 0, 4, C.count), a.draws++);
+		let w = o.extras.icons;
+		if (w && w.count) {
+			n.useProgram(w.program), n.uniform2f(w.uniforms.viewport, c, l), n.uniform3f(w.uniforms.cam, m.x, m.y, m.zoom), n.uniform1f(w.uniforms.dpr, e.width / c), n.uniform1i(w.at("u_tex"), 0), n.activeTexture(n.TEXTURE0), n.bindVertexArray(w.vao), n.bindBuffer(n.ARRAY_BUFFER, w.buffer);
+			for (let e of u.icons.groups) {
+				let t = me(e.kind), i = oe(e.kind), o = t || i ? 14 : 0;
+				if (o && e.maxR * 2 * m.zoom < o) continue;
+				n.uniform1f(w.at("u_minR"), o / 2), n.uniform1f(w.at("u_sideRatio"), t ? 1 : i ? G : 1);
+				let s = t ? ve(he(e.kind), v.values && v.values["--corn-map-glyph"]) : i ? E(r(e.kind).type, r(e.kind).ink) : v.icons && v.icons.get(e.kind);
+				s && (n.bindTexture(n.TEXTURE_2D, _(e.kind, s, !!v.pixelated && !t && !i)), n.vertexAttribPointer(1, 4, n.FLOAT, !1, 16, e.first * 4 * 4), n.drawArraysInstanced(n.TRIANGLE_STRIP, 0, 4, e.count), a.draws++);
+			}
+		}
+		n.bindVertexArray(null);
+	}
+	let y = (e) => {
+		e.preventDefault(), s = !0, o = null;
+	}, b = () => {
+		try {
+			o = Qt(n, p && p[0].theme || "dark", i()), s = !1, u && h(), p && v(...p);
+		} catch (e) {
+			console.warn("WebGL2 context restored but the renderer could not be rebuilt:", e.message);
+		}
+	};
+	return e.addEventListener("webglcontextlost", y), e.addEventListener("webglcontextrestored", b), {
+		kind: "webgl2",
+		stats: a,
+		resize(t, n, r) {
+			c = t, l = n, e.width = Math.round(t * r), e.height = Math.round(n * r), p && v(...p);
+		},
+		draw: v,
+		destroy: C,
+		release() {
+			let e = s;
+			C();
+			try {
+				let t = !e && n.getExtension ? n.getExtension("WEBGL_lose_context") : null;
+				t && t.loseContext();
+			} catch {}
+		}
+	};
+	function C() {
+		e.removeEventListener("webglcontextlost", y), e.removeEventListener("webglcontextrestored", b), o && !s && $t(n, o), o = null, s = !0;
+	}
+}
+// ../explorer/renderer.js
+function tn(e) {
+	let t = e.ownerDocument.createElement("canvas");
+	return t.className = "hx-overlay", t.setAttribute("data-corn", "map-overlay"), t.setAttribute("part", "map-overlay"), t.setAttribute("aria-hidden", "true"), e.after(t), t;
+}
+function nn(e, t = {}) {
+	let n = t.prefer || null, r = t.mapStyle ? { mapStyle: t.mapStyle } : {};
+	if (n === "canvas2d") return Fe(e, r);
+	let i = null;
+	try {
+		i = e.getContext("webgl2", Gt);
+	} catch {}
+	if (!i) return Fe(e, r);
+	try {
+		return en(e, {
+			gl: i,
+			...r
+		});
+	} catch (n) {
+		console.warn(`WebGL2 renderer unavailable, drawing with Canvas 2D: ${n.message}`);
+		let i = (t.makeStandIn || tn)(e), a = Fe(i, r);
+		return {
+			...a,
+			destroy() {
+				a.destroy(), i.remove();
+			}
+		};
+	}
+}
+// ../explorer/cluster.js
+function rn(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let e of t) !e.kind && !e.dashed && e.from && e.to && (n.get(e.from) || n.set(e.from, []).get(e.from)).push(e.to);
+	let r = /* @__PURE__ */ new Set([e]), i = [e];
+	for (; i.length;) for (let e of n.get(i.pop()) || []) r.has(e) || (r.add(e), i.push(e));
+	return r;
+}
+// ../explorer/input.js
+function an(e) {
+	let { state: t } = e, { render: n, getSpatialIndex: r, queueFrameWork: i, screenToWorld: a, getMinZoom: o, setHoverNode: s, labelNodeAt: c, fitGraphToViewport: u, fitPadding: d } = e.map, f = (t) => e.emit("select", t), m = () => e.emit("background"), g = () => e.emit("grab"), _ = !1, v = null, y = {
+		x: 0,
+		y: 0
+	}, b = {
+		x: 0,
+		y: 0
+	}, x = !1, S = null, C = null, w = 0, E = null, D = !1, O = null, k = null, A = null, j = !1, M = "", N = () => t.isFreeform && t.view === "orbit";
+	function P(e) {
+		let n = t.canvas.getBoundingClientRect(), r = e.touches ? e.touches[0] : e, i = n.width && t.width ? t.width / n.width : 1, a = n.height && t.height ? t.height / n.height : 1;
+		return {
+			x: (r.clientX - n.left) * i,
+			y: (r.clientY - n.top) * a
+		};
+	}
+	let F = {
+		nodes: null,
+		size: -1,
+		map: null
+	};
+	function I(e) {
+		return (F.nodes !== t.nodes || F.size !== t.nodes.length) && (F = {
+			nodes: t.nodes,
+			size: t.nodes.length,
+			map: new Map(t.nodes.map((e) => [e.id, e]))
+		}), F.map.get(e) || null;
+	}
+	function ee(e, n, i) {
+		let a = Re(r(), t.camera, e, n, i);
+		return a ? I(a.id) : null;
+	}
+	let te = (e) => Math.hypot(e.touches[0].clientX - e.touches[1].clientX, e.touches[0].clientY - e.touches[1].clientY);
+	function ne(e) {
+		let n = t.canvas.getBoundingClientRect();
+		return {
+			x: (e.touches[0].clientX + e.touches[1].clientX) / 2 - n.left,
+			y: (e.touches[0].clientY + e.touches[1].clientY) / 2 - n.top
+		};
+	}
+	function L(e) {
+		if (D = !0, g(), s(null), e.touches && e.touches.length === 2) {
+			E = l(t.camera, te(e), ne(e)), O = null, _ = !1, v = null, S = null;
+			return;
+		}
+		let n = !!(e.touches && e.touches.length > 0), r = P(e);
+		b = {
+			x: r.x,
+			y: r.y
+		}, x = !1, O = null, S = ee(r.x, r.y, n), N() && S ? (v = S, e.cancelable && e.preventDefault()) : (_ = !0, y = r);
+	}
+	function R() {
+		k && E && Object.assign(t.camera, T(E, k.dist, k.mid, o())), k = null;
+		let n = O;
+		if (O = null, n) {
+			if (v && N()) {
+				let r = a(n.x, n.y);
+				v.x = r.x, v.y = r.y, t.freeformPositions[v.id] = {
+					x: r.x,
+					y: r.y
+				}, e.touchScene(), ue(e);
+			} else _ && (t.camera.x += n.x - y.x, t.camera.y += n.y - y.y, y = n);
+		}
+	}
+	function z() {
+		let e = A;
+		if (A = null, !e || _ || v) return;
+		let t = ee(e.x, e.y, !1);
+		B(!!t), s(t ? t.id : null);
+	}
+	function B(e) {
+		e !== j && t.canvas && (e && (M = t.canvas.style.cursor), j = e, t.canvas.style.cursor = e ? "pointer" : M);
+	}
+	function V(e) {
+		if (e.touches && e.touches.length === 2 && E) {
+			e.cancelable && e.preventDefault(), k = {
+				dist: te(e),
+				mid: ne(e)
+			}, i(R);
+			return;
+		}
+		let t = P(e);
+		Math.hypot(t.x - b.x, t.y - b.y) > 8 && (x = !0), v && N() || _ ? (e.cancelable && e.preventDefault(), O = t, i(R)) : e.touches || (A = t, i(z, { draw: !1 }));
+	}
+	function H(e) {
+		R();
+		let n = !!(e.changedTouches && e.changedTouches.length > 0), r = t.canvas.getBoundingClientRect(), i = n ? {
+			x: e.changedTouches[0].clientX - r.left,
+			y: e.changedTouches[0].clientY - r.top
+		} : P(e);
+		if (!x && D) {
+			if (S) {
+				let e = ee(i.x, i.y, n);
+				if (e && e.id === S.id) {
+					if (!N()) f(S);
+					else {
+						let e = Date.now();
+						C && C.id === S.id && e - w < 380 ? (f(S), C = null, w = 0) : (C = S, w = e);
+					}
+				}
+			} else {
+				let e = I(c(i.x, i.y));
+				e && h.includes(e.type) && e.id !== "root" ? u(d(), rn(e.id, t.edges)) : t.selectedNode && m();
+			}
+		}
+		_ = !1, v = null, S = null, E = null, k = null, D = !1;
+	}
+	let { canvas: U } = t, W = !(e.root && e.root.nodeType === 9), G = (r) => {
+		if (W && !r.ctrlKey && !r.metaKey && e.active() !== t.canvas) return;
+		r.preventDefault(), g();
+		let i = P(r);
+		Object.assign(t.camera, p(t.camera, r.deltaY < 0 ? 1.12 : .88, i.x, i.y, o())), n();
+	}, re = e.root || U, ie = [
+		e.listen(U, "mousedown", L),
+		e.listen(U, "mousemove", V),
+		e.listen(U, "mouseleave", () => {
+			A = null, B(!1), s(null);
+		}),
+		e.listen(re, "mouseup", H),
+		e.listen(U, "touchstart", L, { passive: !1 }),
+		e.listen(U, "touchmove", V, { passive: !1 }),
+		e.listen(re, "touchend", H, { passive: !1 }),
+		e.listen(re, "touchcancel", H, { passive: !1 }),
+		e.listen(U, "wheel", G, { passive: !1 })
+	];
+	return () => ie.forEach((e) => e());
+}
+// ../explorer/flow-build.js
+function on(e, t) {
+	let n = new Map(e.map((e) => [e.id, e])), r = /* @__PURE__ */ new Map();
+	t.forEach((e) => {
+		!e.kind && !e.dashed && n.get(e.from)?.type === "app" && n.get(e.to)?.type === "page" && r.set(e.to, e.from);
+	});
+	let i = e.filter((e) => e.type === "container" && e.selfHosted), a = /* @__PURE__ */ new Map();
+	t.forEach((e) => {
+		let t = n.get(e.from);
+		if (e.kind !== "delivers" || t?.type !== "container" || t.selfHosted || n.get(e.to)?.type !== "page") return;
+		let r = i.filter((e) => e.stack === t.stack);
+		r.length === 1 && a.set(t.id, r[0].id);
+	});
+	let o = (e) => n.get(e)?.type === "page" ? r.get(e) || e : a.get(e) || e, s = new Set([...r].filter(([e]) => Array.isArray(n.get(e)?.methods) && n.get(e).methods.length).map(([, e]) => e)), c = (e) => e.type === "store" && (e.tier === "browser" || e.id === "store-idb"), l = /* @__PURE__ */ new Set();
+	t.forEach((e) => {
+		if (e.kind === "reads" || e.kind === "writes") {
+			let t = e.kind === "reads" ? e.to : e.from;
+			n.get(t)?.type === "page" && l.add(o(t));
+		}
+	}), t.forEach((e) => {
+		e.kind === "flow" && e.flow === "api" && n.get(e.from)?.type === "app" && l.add(e.from);
+	});
+	let u = new Set(t.filter((e) => e.kind === "flow" && e.flow === "api").map((e) => `${o(e.from)}|${o(e.to)}`)), d = (t) => e.filter(t).sort((e, t) => String(e.label).localeCompare(String(t.label))), f = [
+		{
+			key: "browser",
+			title: "Browser",
+			note: "saved on the device first",
+			nodes: d(c)
+		},
+		{
+			key: "servers",
+			title: "App servers",
+			note: "pages, no-JS forms",
+			nodes: d((e) => e.type === "app" && !s.has(e.id) && l.has(e.id))
+		},
+		{
+			key: "api",
+			title: "API",
+			note: "where the endpoints are",
+			nodes: d((e) => s.has(e.id))
+		},
+		{
+			key: "tables",
+			title: "Tables",
+			note: "stores and tables",
+			nodes: [...d((e) => e.type === "store" && !c(e)), ...d((e) => e.type === "table")]
+		},
+		{
+			key: "services",
+			title: "Services",
+			note: "jobs, hooks, webhooks",
+			nodes: d((e) => e.type === "service")
+		},
+		{
+			key: "outside",
+			title: "Outside",
+			note: "systems the API reaches",
+			nodes: [...d((e) => e.type === "external"), ...d((e) => e.type === "container" && e.selfHosted)]
+		}
+	], p = new Set(f.flatMap((e) => e.nodes.map((e) => e.id))), m = [], h = /* @__PURE__ */ new Set(), g = (e, t, n) => {
+		if (t === n || !p.has(t) || !p.has(n)) return;
+		let r = `${t}|${n}|${e.kind}|${e.flow || ""}`;
+		h.has(r) || (h.add(r), m.push({
+			...e,
+			from: t,
+			to: n,
+			status: e.status || "live",
+			phase: void 0
+		}));
+	};
+	return t.forEach((e) => {
+		if (!(e.kind === "calls" && u.has(`${o(e.from)}|${o(e.to)}`)) && (e.kind !== "calls" || n.get(e.from)?.type !== "container")) {
+			if (e.kind === "flow" || [
+				"calls",
+				"triggers",
+				"delivers"
+			].includes(e.kind)) return g(e, o(e.from), o(e.to));
+			if (e.kind === "reads" || e.kind === "writes") {
+				let t = e.kind === "reads" ? e.to : e.from;
+				return n.get(t)?.type === "page" && !s.has(o(t)) ? void 0 : g(e, o(e.from), o(e.to));
+			}
+		}
+	}), {
+		tiers: f,
+		ids: p,
+		edges: m
+	};
+}
+// ../explorer/pieces/map.js
+var sn = "Arrow keys pan, plus and minus zoom, 0 fits the map. N and P select the next and the previous node, Home and End the first and the last. F frames the selected node and what it lights. Escape clears the selection.", cn = "<canvas id=\"graph-canvas\" data-corn=\"map-canvas\" tabindex=\"0\" role=\"application\" aria-roledescription=\"map\" aria-label=\"Topology map\" aria-describedby=\"map-keys-help\"></canvas>", ln = ({ keysHelp: e = sn } = {}) => ({ stage: `${cn}
+<p id="map-keys-help" class="hx-sr-only">${P(e)}</p>
+<p id="map-announcer" class="hx-sr-only" role="status" aria-live="polite"></p>
+<canvas id="label-canvas" data-corn="label-canvas" aria-hidden="true"></canvas>` });
+function un(e, t, n) {
+	let r = j(t, e, "<div data-corn=\"map-stage\"></div>", null, "stage"), i = n.mountStatus(r[0], t, { follow: !1 });
+	i.refuse("second-map"), t.emit("piece:refused", {
+		piece: "map",
+		reason: "second-map",
+		message: "A scope holds one map.",
+		host: e.nodeType === 11 ? e.host : e
+	});
+	let a = () => {};
+	return {
+		inst: t,
+		refused: !0,
+		update: a,
+		fit: a,
+		refresh: a,
+		focusNode: () => !1,
+		applyTheme: a,
+		destroy() {
+			i.destroy();
+			for (let e of r) e.remove();
+		}
+	};
+}
+function dn(e) {
+	let t = e.nodeType === 11 ? e.host : e;
+	return t && typeof t.getRootNode == "function" ? t.getRootNode() : null;
+}
+function fn(e, t, n = {}) {
+	return !t && n.src !== void 0 && n.src !== null && n.src !== "" ? pn(e, n) : mn(e, t, n, null);
+}
+function pn(e, t) {
+	let n = e.nodeType === 11 ? e.host : e, r = {}, i = null, a = !1;
+	return import("./scope-vxRGj-2V.js").then((e) => e.n).then(({ mountScope: o }) => {
+		if (a) return;
+		let s = o(n, {
+			src: t.src,
+			theme: t.theme,
+			useTheme: t.useTheme,
+			tokens: t.tokens,
+			version: t.version,
+			pageUrl: t.pageUrl,
+			onAuth: t.onAuth,
+			onError: t.onError
+		});
+		i = mn(e, s.instance, {
+			...t,
+			...r
+		}, s);
+	}, (e) => {
+		!a && t.onError && t.onError({
+			kind: "offline",
+			message: `the map's loader did not load: ${e && e.message ? e.message : e}`
+		});
+	}), {
+		get inst() {
+			return i ? i.inst : null;
+		},
+		get map() {
+			return i ? i.map : null;
+		},
+		update(e = {}) {
+			i ? i.update(e) : Object.assign(r, e);
+		},
+		fit() {
+			i && i.fit();
+		},
+		focusNode(e) {
+			return i ? i.focusNode(e) : !1;
+		},
+		refresh() {
+			i && i.refresh();
+		},
+		applyTheme(e) {
+			return i ? i.applyTheme(e) : null;
+		},
+		destroy() {
+			a || (a = !0, i && i.destroy(), i = null);
+		}
+	};
+}
+function mn(e, t, n, r) {
+	let i = !t;
+	i && (t = ee({
+		root: e,
+		base: n.base || "",
+		fetch: n.fetch,
+		strings: n.strings
+	}));
+	let a = U(t), o = () => {};
+	if (a) try {
+		o = t.attach(e);
+	} catch {
+		return r && r.destroy(), un(e, t, a);
+	}
+	let { state: s } = t, c = a ? a.source : null;
+	if (n.tokens) {
+		let t = dn(e);
+		t && ie(t.nodeType === 9 ? t : t.ownerDocument, n.tokens), t && t.nodeType === 11 && ie(t, n.tokens);
+	}
+	let l = B(t);
+	l.own(o), r && l.own(() => r.destroy());
+	let u = (e) => e === "canvas2d" ? "canvas2d" : "auto", d = (e) => e === "light" || e === "dark" ? e : "auto", f = {
+		renderer: u(n.renderer),
+		theme: d(n.theme),
+		topology: void 0
+	}, p = n.topology !== void 0 && n.topology !== null, m = !1, h = !1, g = ln({ keysHelp: n.keysHelp }).stage, _ = n.slots && n.slots.stage ? n.slots : null, v = j(t, e, _ ? g : `<div data-corn="map-stage">${g}</div>`, _, "stage"), y = (e) => v.map((t) => t.matches(e) ? t : t.querySelector(e)).find(Boolean);
+	l.own(() => {
+		for (let e of [...v, s.canvas]) e && e.remove();
+	});
+	let b = v.find((e) => e.matches("[data-corn=\"map-stage\"]")) || null;
+	if (c && b) {
+		let e = a.mountStatus(b, t, {
+			onRetry: () => c.load(),
+			focusMap: () => {
+				s.canvas && s.canvas.focus();
+			}
+		});
+		l.own(e.destroy);
+	}
+	s.canvas = y("[data-corn=\"map-canvas\"]"), s.labelCanvas = y("[data-corn=\"label-canvas\"]"), s.ctx = t.doc.createElement("canvas").getContext("2d");
+	let x = ft(t, n.measureCovered ? { measureCovered: n.measureCovered } : {}), S = ce(t);
+	l.own(S.watch()), l.own(S.onChange(() => x.render()));
+	let C = () => f.renderer === "canvas2d" ? "canvas2d" : null, w = () => x.setRenderer(nn(s.canvas, {
+		prefer: C(),
+		mapStyle: S.get
+	})), T = t.win && t.win.matchMedia ? t.win.matchMedia("(prefers-color-scheme: light)") : null;
+	function E() {
+		if (f.theme === "light" || f.theme === "dark") return f.theme;
+		if (a && (a.theme === "light" || a.theme === "dark")) return a.theme;
+		let e = t.doc && t.doc.documentElement, n = e ? e.getAttribute("data-theme") : null;
+		return n === "light" || n === "dark" ? n : re("system", !!(T && T.matches));
+	}
+	function D() {
+		if (m) return;
+		let e = E();
+		S.refresh(), s.theme !== e && (s.theme = e, t.touchScene()), x.render();
+	}
+	s.theme = E(), a && l.own(a.serverTheme.adopt(e)), a && (l.on("theme", () => D()), l.on("scope:theme", () => D())), T && T.addEventListener && (T.addEventListener("change", D), l.own(() => T.removeEventListener("change", D)));
+	let k = t.win && t.win.MutationObserver;
+	if (k && t.doc && t.doc.documentElement) {
+		let e = new k(D);
+		e.observe(t.doc.documentElement, {
+			attributes: !0,
+			attributeFilter: ["data-theme", "class"]
+		}), l.own(() => e.disconnect());
+	}
+	w();
+	function A() {
+		te(t), s.view === "dataflow" && s.flow ? (s.flow.tiers.forEach((e) => e.nodes.forEach((e) => {
+			e.r = Math.min(e.r, 13);
+		})), O(t, s.flow)) : se(t);
+	}
+	let M = !1, P = () => {
+		s.nodes.length && (M = !s.width || !s.height, M || x.fitGraphToViewport(x.fitPadding()));
+	}, F = (e) => s.nodes.find((t) => t.id === e) || null, L = null;
+	l.on("select", (e) => V(t, e, { source: "tap" })), l.on("background", () => W(t, { source: "tap" })), l.on("grab", () => ne(t)), l.on("selection", ({ node: e, edge: t, source: r }) => {
+		m || ((e || t) && (L = null), n.onSelect && (e ? n.onSelect({
+			id: e.id,
+			kind: "node",
+			source: r
+		}) : t ? n.onSelect({
+			id: `${t.from}->${t.to}`,
+			kind: "edge",
+			from: t.from,
+			to: t.to,
+			source: r
+		}) : n.onSelect({
+			id: null,
+			kind: null,
+			source: r
+		})));
+	});
+	function R(e) {
+		let n = F(String(e));
+		return !n || m ? !1 : (V(t, n, {
+			frame: !0,
+			source: "api"
+		}), !0);
+	}
+	let z = () => {}, H = !!t.root && t.root.nodeType === 9;
+	function G() {
+		let e = s.canvas, n = [an(t)];
+		H || n.push(t.listen(e, "pointerdown", (t) => {
+			if (t.pointerType === "mouse" && e.setPointerCapture) try {
+				e.setPointerCapture(t.pointerId);
+			} catch {}
+		})), I(t), N(t), n.push(() => I(t)), z = () => n.forEach((e) => e());
+	}
+	l.own(x.onPaint(() => {
+		M && s.width && s.height && P(), !h && s.nodes.length && (h = !0, n.onReady && n.onReady());
+	})), G(), l.own(() => z());
+	let ae = () => {
+		!p && c && c.topology && c.topology !== f.topology && (f.topology = c.topology, oe(c.topology));
+	};
+	c && l.on("source", (e) => {
+		e.state === "ready" && ae();
+	}), l.own(x.watchSize()), x.resize();
+	function oe(e) {
+		let n = e && Array.isArray(e.nodes) ? e.nodes.filter((e) => e && typeof e.id == "string") : [], r = e && Array.isArray(e.edges) ? e.edges.filter((e) => e && typeof e.from == "string" && typeof e.to == "string") : [], i = s.selectedNode ? s.selectedNode.id : null;
+		s.baseNodes = n, s.baseEdges = r, s.nodes = n.map((e) => ({ ...e })), s.edges = r.map((e) => ({ ...e })), s.mapNodes = s.nodes, s.mapEdges = s.edges, s.flow = on(s.nodes, s.edges);
+		let a = i ? F(i) : null;
+		a ? (s.selectedEdge = null, s.selectedNode = a) : (s.selectedNode || s.selectedEdge) && (s.selectedNode = null, s.selectedEdge = null), t.touchScene(), s.nodes.length && (A(), P());
+		let o = !a && L ? F(L) : null;
+		o && V(t, o, { source: "api" }), x.render(), x.ensureFlowLoop();
+	}
+	function le(e) {
+		let n = e === "dataflow" ? "dataflow" : "orbit";
+		s.view !== n && (s.view = n, t.touchScene(), s.nodes.length && (A(), P(), x.ensureFlowLoop()));
+	}
+	function ue() {
+		let e = x.getRenderer();
+		e.release ? e.release() : e.destroy(), z();
+		let n = t.doc.createElement("template");
+		n.innerHTML = cn;
+		let r = n.content.firstElementChild;
+		r.setAttribute("part", "map-canvas");
+		let i = t.active() === s.canvas;
+		s.canvas.replaceWith(r), s.canvas = r, G(), w(), x.resize(), i && r.focus();
+	}
+	function de(e = {}) {
+		if (!m) {
+			if ("renderer" in e) {
+				let t = u(e.renderer);
+				t !== f.renderer && (f.renderer = t, ue());
+			}
+			if ("theme" in e) {
+				let t = d(e.theme);
+				t !== f.theme && (f.theme = t, D());
+			}
+			if ("topology" in e && (p = e.topology !== void 0 && e.topology !== null, p && e.topology !== f.topology ? (f.topology = e.topology, oe(e.topology)) : !p && c && c.topology ? (f.topology = void 0, ae()) : !p && e.topology !== f.topology && (f.topology = e.topology, oe(e.topology))), "view" in e && le(e.view === "dataflow" ? "dataflow" : "orbit"), "node" in e) {
+				let n = e.node == null || e.node === "" ? null : String(e.node);
+				if (n === null) L = null, (s.selectedNode || s.selectedEdge) && W(t, { source: "api" });
+				else {
+					let e = F(n);
+					e ? s.selectedNode && s.selectedNode.id === n || V(t, e, { source: "api" }) : L = n;
+				}
+			}
+		}
+	}
+	function K() {
+		m || (m = !0, l.destroy(), x.destroy(), i && t.destroy());
+	}
+	let fe = {};
+	for (let e of [
+		"topology",
+		"view",
+		"node"
+	]) n[e] !== void 0 && (fe[e] = n[e]);
+	return de(fe), ae(), D(), {
+		inst: t,
+		map: x,
+		update: de,
+		destroy: K,
+		fit: P,
+		focusNode: R,
+		refresh: D,
+		applyTheme: (e) => S.applyTheme(e)
+	};
+}
+// \0stencil-css:/home/runner/work/CornField/CornField/explorer/pieces/map-stage?tag=corn-map&encapsulation=shadow&__ext=css
+var hn = () => "[data-corn=map-stage]{background:var(--corn-ground-image), var(--corn-ground);width:100%;height:100%;min-height:16rem;display:block;position:relative;overflow:hidden}[data-corn=map-canvas]{cursor:grab;touch-action:none;width:100%;height:100%;display:block;position:absolute;inset:0}[data-corn=map-canvas]:active{cursor:grabbing}[data-corn=map-canvas]:focus-visible{outline:var(--corn-focus-width) solid var(--corn-focus);outline-offset:calc(var(--corn-focus-width) * -1)}[data-corn=label-canvas]{pointer-events:none;width:100%;height:100%;position:absolute;inset:0}[data-corn=map-overlay]{pointer-events:none;width:100%;height:100%;position:absolute;top:0;left:0}.hx-sr-only{clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0;width:1px;height:1px;margin:0;padding:0;overflow:hidden;position:absolute!important}", gn = () => "[data-corn=source-status]{z-index:2;box-sizing:border-box;align-items:center;gap:var(--corn-space-3);width:min(26rem, calc(100% - var(--corn-space-6) * 2));padding:var(--corn-space-6);border:var(--corn-border) solid var(--corn-line);border-radius:var(--corn-radius-lg);background:var(--corn-surface-1);color:var(--corn-text-2);box-shadow:var(--corn-shadow);text-align:center;font-family:var(--corn-font);font-size:var(--corn-text-md);flex-direction:column;line-height:1.5;display:flex;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}[data-corn=source-status][hidden]{display:none}[data-corn=source-status]:focus-visible{outline:var(--corn-focus-width) solid var(--corn-focus);outline-offset:var(--corn-focus-offset)}[data-corn=source-status][data-corn-state=running]{box-shadow:none;color:var(--corn-text-3);background:0 0;border-color:#0000;padding:0}[data-corn=source-status][data-corn-state=running] [data-corn=source-title]{font-size:var(--corn-text-md);color:var(--corn-text-3);font-weight:400}[data-corn=source-status][data-corn-state=failure] [data-corn=source-title]{color:var(--corn-bad)}[data-corn=source-status][data-corn-state=waiting] [data-corn=source-title]{color:var(--corn-accent-text)}[data-corn=source-title],[data-corn=source-text]{margin:0}[data-corn=source-title]{font-size:var(--corn-text-lg);color:var(--corn-text);font-weight:600}[data-corn=source-text]{overflow-wrap:anywhere;user-select:text}[data-corn=source-origin]{font-family:var(--corn-mono);color:var(--corn-warn);overflow-wrap:anywhere;user-select:all}[data-corn=source-sign-in],[data-corn=source-retry]{box-sizing:border-box;min-height:max(var(--corn-control-height), 2.75rem);padding:0 var(--corn-space-6);border:var(--corn-border) solid var(--corn-line);border-radius:var(--corn-radius);background:var(--corn-surface-2);color:var(--corn-text);font-family:inherit;font-size:inherit;cursor:pointer;justify-content:center;align-items:center;text-decoration:none;display:inline-flex}[data-corn=source-sign-in]{border-color:var(--corn-accent);background:var(--corn-accent);color:var(--corn-text-on-accent);font-weight:600}[data-corn=source-sign-in]:hover{background:var(--corn-accent-hover)}[data-corn=source-retry]:hover{background:var(--corn-surface-3)}[data-corn=source-sign-in]:focus-visible,[data-corn=source-retry]:focus-visible{outline:var(--corn-focus-width) solid var(--corn-focus);outline-offset:var(--corn-focus-offset)}[data-corn=source-notice]{z-index:2;box-sizing:border-box;padding:var(--corn-space-3) var(--corn-space-6);background:var(--corn-surface-1);border-top:var(--corn-border) solid var(--corn-line-soft);color:var(--corn-text-2);font-family:var(--corn-font);font-size:var(--corn-text-sm);text-align:center;overflow-wrap:anywhere;margin:0;position:absolute;bottom:0;left:0;right:0}[data-corn=source-notice][hidden]{display:none}", _n = () => ":host{contain:layout;min-width:0;color:var(--corn-text);font-family:var(--corn-font);display:block;position:relative}:host([hidden]){display:none!important}", vn = class extends n {
+	constructor(t) {
+		super(), t !== !1 && this.__registerHost(), this.__attachShadow(), this.cornSelect = e(this, "cornSelect", 7), this.cornReady = e(this, "cornReady", 7), this.cornAuth = e(this, "cornAuth", 7), this.cornError = e(this, "cornError", 7);
+	}
+	get el() {
+		return this;
+	}
+	topology;
+	node;
+	view = "map";
+	theme;
+	renderer = "auto";
+	src;
+	useTheme = !1;
+	cornSelect;
+	cornReady;
+	cornAuth;
+	cornError;
+	piece = null;
+	scope = null;
+	loaded = !1;
+	changes = {};
+	connectedCallback() {
+		this.loaded && this.mountPiece();
+	}
+	componentDidLoad() {
+		this.loaded = !0, this.mountPiece();
+	}
+	disconnectedCallback() {
+		this.unmountPiece();
+	}
+	unmountPiece() {
+		this.piece && this.piece.destroy(), this.piece = null, this.scope && this.scope.leave(), this.scope = null;
+	}
+	remount() {
+		this.unmountPiece(), this.loaded && this.el.isConnected && this.mountPiece();
+	}
+	mountPiece() {
+		!this.piece && this.el.shadowRoot && (this.changes = {}, this.scope = k(this.el, () => this.remount()), this.piece = fn(this.el.shadowRoot, this.scope.inst, {
+			topology: this.topology,
+			view: this.view,
+			node: this.node,
+			theme: this.theme,
+			renderer: this.renderer,
+			tokens: ae,
+			src: this.src,
+			useTheme: this.useTheme,
+			version: "0.49.0",
+			pageUrl: () => typeof location > "u" ? "" : location.href,
+			onAuth: (e) => this.cornAuth.emit(e),
+			onError: (e) => this.cornError.emit(e),
+			onSelect: (e) => {
+				this.node = e.kind === "node" ? e.id : null, delete this.changes.node, this.cornSelect.emit(e);
+			},
+			onReady: () => this.cornReady.emit()
+		}));
+	}
+	componentDidRender() {
+		let e = this.changes;
+		this.changes = {}, this.piece && Object.keys(e).length && this.piece.update(e);
+	}
+	changed(e, t, n) {
+		this.changes[n] = e;
+	}
+	addressChanged() {
+		this.piece && this.scope && !this.scope.inst && this.remount();
+	}
+	async fit() {
+		this.piece && this.piece.fit();
+	}
+	async focusNode(e) {
+		this.piece && this.piece.focusNode(e);
+	}
+	async refresh() {
+		this.piece && this.piece.refresh();
+	}
+	static get watchers() {
+		return {
+			topology: [{ changed: 0 }],
+			view: [{ changed: 0 }],
+			node: [{ changed: 0 }],
+			theme: [{ changed: 0 }],
+			renderer: [{ changed: 0 }],
+			src: [{ addressChanged: 0 }],
+			useTheme: [{ addressChanged: 0 }]
+		};
+	}
+	static get style() {
+		return hn() + gn() + _n();
+	}
+};
+t(vn, [
+	513,
+	"corn-map",
+	{
+		topology: [16],
+		node: [1537],
+		view: [1],
+		theme: [513],
+		renderer: [1],
+		src: [1],
+		useTheme: [4, "use-theme"],
+		fit: [64],
+		focusNode: [64],
+		refresh: [64]
+	},
+	void 0,
+	{
+		topology: [{ changed: 0 }],
+		view: [{ changed: 0 }],
+		node: [{ changed: 0 }],
+		theme: [{ changed: 0 }],
+		renderer: [{ changed: 0 }],
+		src: [{ addressChanged: 0 }],
+		useTheme: [{ addressChanged: 0 }]
+	}
+]);
+export { vn as t };