@vscada/core 0.0.1

package/dist/index.js

@@ -0,0 +1,4549 @@
+import { t as e } from "./constants-DMdpoOyH.js";
+import { LitElement as t, css as n, html as r } from "lit";
+//#region src/scene/errors.ts
+var i = [
+	"MISSING_VERSION",
+	"UNSUPPORTED_VERSION",
+	"BAD_SHAPE",
+	"DUPLICATE_ID",
+	"UNKNOWN_TYPE",
+	"UNRESOLVED_PORT",
+	"UNRESOLVED_TOPOLOGY_REF",
+	"AMBIGUOUS_GROUP_PORT_MAP",
+	"UNRESOLVED_GROUP_PORT_MAP",
+	"AMBIGUOUS_GROUP_CHILD"
+];
+function a(e, t, n) {
+	return {
+		code: e,
+		message: t,
+		path: n
+	};
+}
+//#endregion
+//#region src/scene/structural-validator.ts
+var o = new Set(e), s = /* @__PURE__ */ new Set(["off-page", "svg-import"]);
+function c(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function l(e) {
+	return c(e) && typeof e.x == "number" && Number.isFinite(e.x) && typeof e.y == "number" && Number.isFinite(e.y) && typeof e.dir == "string" && [
+		"up",
+		"down",
+		"left",
+		"right"
+	].includes(e.dir);
+}
+function u(e, t) {
+	if (e === void 0) return null;
+	if (!c(e)) return a("BAD_SHAPE", `${t}.ports must be an object of named ports`, `${t}.ports`);
+	for (let [n, r] of Object.entries(e)) if (!l(r)) return a("BAD_SHAPE", `${t}.ports.${n} must be { x: number, y: number, dir: 'up'|'down'|'left'|'right' }`, `${t}.ports.${n}`);
+	return null;
+}
+function d(e, t) {
+	if (!c(e)) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene must be an object", "")
+	};
+	if (e.version === void 0 || e.version === null || e.version === "") return {
+		ok: !1,
+		error: a("MISSING_VERSION", "Scene is missing required \"version\" field", "version")
+	};
+	if (typeof e.version != "string" || !o.has(e.version)) return {
+		ok: !1,
+		error: a("UNSUPPORTED_VERSION", `Scene version "${String(e.version)}" is not supported`, "version")
+	};
+	if (e.id === void 0 || typeof e.id != "string" || e.id.length === 0) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene is missing required string \"id\"", "id")
+	};
+	if (!c(e.canvas) || typeof e.canvas.width != "number" || !Number.isFinite(e.canvas.width) || typeof e.canvas.height != "number" || !Number.isFinite(e.canvas.height)) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene \"canvas\" must be { width: number, height: number }", "canvas")
+	};
+	let n = e.elements ?? [];
+	if (!Array.isArray(n)) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene \"elements\" must be an array", "elements")
+	};
+	let r = e.groups ?? [];
+	if (!Array.isArray(r)) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene \"groups\" must be an array", "groups")
+	};
+	let i = e.connections ?? [];
+	if (!Array.isArray(i)) return {
+		ok: !1,
+		error: a("BAD_SHAPE", "Scene \"connections\" must be an array", "connections")
+	};
+	let l = [];
+	for (let e = 0; e < n.length; e++) {
+		let t = n[e], r = `elements[${e}]`;
+		if (!c(t) || typeof t.id != "string" || t.id.length === 0) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${r} must be an object with a non-empty string "id"`, `${r}.id`)
+		};
+		if (typeof t.type != "string" || t.type.length === 0) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${r} must declare a non-empty string "type"`, `${r}.type`)
+		};
+		let i = u(t.ports, r);
+		if (i) return {
+			ok: !1,
+			error: i
+		};
+		l.push({
+			id: t.id,
+			type: t.type,
+			ports: c(t.ports) ? t.ports : {}
+		});
+	}
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e], n = `groups[${e}]`;
+		if (!c(t) || typeof t.id != "string" || t.id.length === 0) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${n} must be an object with a non-empty string "id"`, `${n}.id`)
+		};
+		if (t.children !== void 0 && !Array.isArray(t.children)) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${n}.children must be an array of element ids`, `${n}.children`)
+		};
+		let i = u(t.ports, n);
+		if (i) return {
+			ok: !1,
+			error: i
+		};
+		l.push({
+			id: t.id,
+			type: "group",
+			ports: c(t.ports) ? t.ports : {}
+		});
+	}
+	let d = /* @__PURE__ */ new Map();
+	for (let e of l) {
+		if (d.get(e.id) !== void 0) return {
+			ok: !1,
+			error: a("DUPLICATE_ID", `Duplicate element/group id "${e.id}"`, `id:${e.id}`)
+		};
+		d.set(e.id, e.id);
+	}
+	let f = new Map(l.map((e) => [e.id, e])), p = /* @__PURE__ */ new Map();
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e], n = `groups[${e}]`, i = t.id, o = Array.isArray(t.children) ? t.children.filter((e) => typeof e == "string") : [], s = c(t.ports) ? t.ports : {}, l = c(t.portMap) ? t.portMap : {};
+		for (let e of o) {
+			let t = p.get(e);
+			if (t !== void 0) return {
+				ok: !1,
+				error: a("AMBIGUOUS_GROUP_CHILD", `Child id "${e}" is declared under more than one group ("${t}" and "${i}")`, `${n}.children`)
+			};
+			p.set(e, i);
+		}
+		let u = /* @__PURE__ */ new Map();
+		for (let [e, t] of Object.entries(l)) {
+			let r = `${n}.portMap.${e}`;
+			if (typeof t != "string") continue;
+			if (!(e in s)) return {
+				ok: !1,
+				error: a("UNRESOLVED_GROUP_PORT_MAP", `Group "${i}" portMap key "${e}" does not match any port declared on the group itself`, r)
+			};
+			let c = t.indexOf("."), l = c < 0 ? t : t.slice(0, c), d = c < 0 ? "" : t.slice(c + 1), p = l.length > 0 ? f.get(l) : void 0;
+			if (c < 0 || l.length === 0 || d.length === 0 || !o.includes(l) || !p || !(d in p.ports)) return {
+				ok: !1,
+				error: a("UNRESOLVED_GROUP_PORT_MAP", `Group "${i}" portMap["${e}"]="${t}" does not resolve to a real port on a child declared in this group's "children"`, r)
+			};
+			let m = `${l}.${d}`, h = u.get(m);
+			if (h !== void 0) return {
+				ok: !1,
+				error: a("AMBIGUOUS_GROUP_PORT_MAP", `Group "${i}" maps both "${h}" and "${e}" to the same interior port "${m}"`, r)
+			};
+			u.set(m, e);
+		}
+	}
+	for (let e = 0; e < n.length; e++) {
+		let r = n[e], i = r.type;
+		if (!s.has(i) && !t.has(i)) return {
+			ok: !1,
+			error: a("UNKNOWN_TYPE", `Element "${r.id}" has unknown type "${i}" — is its primitive group registered via registerPrimitives()?`, `elements[${e}].type`)
+		};
+		if (i === "off-page") {
+			let t = `elements[${e}]`, n = r.target;
+			if (!c(n) || typeof n.scene != "string" || typeof n.port != "string") return {
+				ok: !1,
+				error: a("BAD_SHAPE", `${t} (off-page) must declare "target": { scene: string, port: string }`, `${t}.target`)
+			};
+		}
+	}
+	for (let e = 0; e < i.length; e++) {
+		let t = i[e], n = `connections[${e}]`;
+		if (!c(t) || typeof t.id != "string" || t.id.length === 0) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${n} must be an object with a non-empty string "id"`, `${n}.id`)
+		};
+		for (let e of ["from", "to"]) {
+			let r = t[e], i = `${n}.${e}`;
+			if (typeof r != "string" || !r.includes(".")) return {
+				ok: !1,
+				error: a("BAD_SHAPE", `${i} must be an "ELEM.port" reference`, i)
+			};
+			let o = r.indexOf("."), s = r.slice(0, o), c = r.slice(o + 1);
+			if (s.length === 0 || c.length === 0) return {
+				ok: !1,
+				error: a("BAD_SHAPE", `${i} must be an "ELEM.port" reference`, i)
+			};
+			let l = f.get(s);
+			if (!l) return {
+				ok: !1,
+				error: a("UNRESOLVED_PORT", `Connection "${t.id}" ${e}="${r}" references element "${s}" but no such element or group exists`, i)
+			};
+			if (!(c in l.ports)) return {
+				ok: !1,
+				error: a("UNRESOLVED_PORT", `Connection "${t.id}" ${e}="${r}" references port "${c}" but "${s}" declares no such port`, i)
+			};
+		}
+	}
+	let m = c(e.topology) ? e.topology : {
+		nodes: [],
+		edges: []
+	}, h = Array.isArray(m.nodes) ? m.nodes : [], g = Array.isArray(m.edges) ? m.edges : [], _ = /* @__PURE__ */ new Set();
+	for (let e of i) c(e) && typeof e.id == "string" && _.add(e.id);
+	for (let e = 0; e < h.length; e++) {
+		let t = h[e], n = `topology.nodes[${e}]`;
+		if (typeof t != "string" || !f.has(t)) return {
+			ok: !1,
+			error: a("UNRESOLVED_TOPOLOGY_REF", `topology.nodes[${e}] references "${String(t)}" but no such element or group exists`, n)
+		};
+	}
+	for (let e = 0; e < g.length; e++) {
+		let t = g[e], n = `topology.edges[${e}]`;
+		if (!c(t) || typeof t.id != "string" || t.id.length === 0) return {
+			ok: !1,
+			error: a("BAD_SHAPE", `${n} must be an object with a non-empty string "id"`, `${n}.id`)
+		};
+		if (!_.has(t.id)) return {
+			ok: !1,
+			error: a("UNRESOLVED_TOPOLOGY_REF", `topology edge "${t.id}" does not reference any connection with that id`, `${n}.id`)
+		};
+		for (let e of ["from", "to"]) {
+			let r = t[e], i = `${n}.${e}`;
+			if (typeof r != "string" || !f.has(r)) return {
+				ok: !1,
+				error: a("UNRESOLVED_TOPOLOGY_REF", `topology edge "${t.id}" ${e}="${String(r)}" references an element/group that does not exist`, i)
+			};
+		}
+	}
+	if (m.sources !== void 0) {
+		if (!Array.isArray(m.sources)) return {
+			ok: !1,
+			error: a("BAD_SHAPE", "topology.sources must be an array of node ids", "topology.sources")
+		};
+		let e = new Set(h.filter((e) => typeof e == "string"));
+		for (let t = 0; t < m.sources.length; t++) {
+			let n = m.sources[t], r = `topology.sources[${t}]`;
+			if (typeof n != "string" || !e.has(n)) return {
+				ok: !1,
+				error: a("UNRESOLVED_TOPOLOGY_REF", `topology.sources[${t}] references "${String(n)}" but it is not declared in topology.nodes`, r)
+			};
+		}
+	}
+	let v = n.map((e) => {
+		let t = e;
+		return {
+			...t,
+			bindings: Array.isArray(t.bindings) ? t.bindings : [],
+			thresholds: Array.isArray(t.thresholds) ? t.thresholds : []
+		};
+	}), y = i.map((e) => {
+		let t = e;
+		return {
+			...t,
+			bindings: Array.isArray(t.bindings) ? t.bindings : []
+		};
+	});
+	return {
+		ok: !0,
+		scene: {
+			...e,
+			elements: v,
+			groups: r,
+			connections: y,
+			topology: e.topology ?? {
+				nodes: [],
+				edges: []
+			},
+			media: e.media ?? {},
+			inferFlow: e.inferFlow === !0
+		}
+	};
+}
+//#endregion
+//#region src/scene/dev-validate.ts
+async function f(e) {
+	return null;
+}
+//#endregion
+//#region src/registry/primitive-registry.ts
+var p = /* @__PURE__ */ new Map();
+function m(...e) {
+	for (let t of e) for (let [e, n] of Object.entries(t.primitives)) p.has(e) && p.get(e) !== n && console.warn(`registerPrimitives: element type "${e}" is already registered — the new registration will overwrite it.`), p.set(e, n);
+}
+function h(e) {
+	return p.get(e);
+}
+function g() {
+	return new Set(p.keys());
+}
+//#endregion
+//#region src/registry.ts
+function _() {
+	return g();
+}
+//#endregion
+//#region src/registry/connection-registry.ts
+var v;
+function y(e) {
+	v = e;
+}
+function ee() {
+	return v;
+}
+//#endregion
+//#region src/registry/theme-registry.ts
+var b = /* @__PURE__ */ new Map();
+function x(...e) {
+	for (let t of e) b.set(t.name, t);
+}
+function S(e) {
+	return b.get(e) ?? {
+		name: e,
+		palette: {}
+	};
+}
+//#endregion
+//#region src/contracts/time-source.ts
+var C = {
+	now: () => performance.now(),
+	onTick(e) {
+		let t = requestAnimationFrame(function n(r) {
+			e(r), t = requestAnimationFrame(n);
+		});
+		return () => cancelAnimationFrame(t);
+	}
+}, w = {
+	setTransform(e, t) {
+		e.style.transform = t;
+	},
+	setAttr(e, t, n) {
+		e.setAttribute(t, n);
+	},
+	setCssVar(e, t, n) {
+		e.style.setProperty(t, n);
+	},
+	setText(e, t) {
+		e.textContent = t;
+	},
+	animateTransform(e, t, n) {
+		let r = e.animate(t.map((e) => ({ transform: e })), {
+			duration: n,
+			iterations: Infinity,
+			easing: "linear"
+		});
+		return {
+			setPlaybackRate(e) {
+				r.playbackRate = e;
+			},
+			pause() {
+				r.pause();
+			},
+			resume() {
+				r.play();
+			},
+			seek(e) {
+				r.currentTime = e;
+			}
+		};
+	}
+}, T = {
+	up: {
+		x: 0,
+		y: -1
+	},
+	down: {
+		x: 0,
+		y: 1
+	},
+	left: {
+		x: -1,
+		y: 0
+	},
+	right: {
+		x: 1,
+		y: 0
+	}
+};
+function E(e) {
+	return T[e];
+}
+function D(e) {
+	return e === "left" || e === "right" ? "h" : "v";
+}
+function te(e, t, n, r) {
+	let i = {
+		x: e.x + E(t).x * 24,
+		y: e.y + E(t).y * 24
+	}, a = {
+		x: n.x + E(r).x * 24,
+		y: n.y + E(r).y * 24
+	}, o = ne(t, r, i, a);
+	for (let t of o) {
+		let r = ie([
+			e,
+			i,
+			...t,
+			a,
+			n
+		]);
+		if (!re(r)) return r;
+	}
+	return ie([
+		e,
+		i,
+		...o[o.length - 1] ?? [],
+		a,
+		n
+	]);
+}
+function ne(e, t, n, r) {
+	if (D(e) !== D(t)) return D(e) === "v" ? [[{
+		x: n.x,
+		y: r.y
+	}], [{
+		x: r.x,
+		y: n.y
+	}]] : [[{
+		x: r.x,
+		y: n.y
+	}], [{
+		x: n.x,
+		y: r.y
+	}]];
+	let i = D(e) === "v", a = (e) => i ? e.y : e.x, o = (e) => i ? e.x : e.y, s = (e, t) => i ? {
+		x: t,
+		y: e
+	} : {
+		x: e,
+		y: t
+	}, c = a(n) === a(r) ? [] : [s(a(n), o(n) + 24), s(a(r), o(n) + 24)];
+	return [[{
+		x: r.x,
+		y: n.y
+	}], c];
+}
+function re(e) {
+	for (let t = 0; t < e.length - 1; t++) for (let n = t + 1; n < e.length - 1; n++) {
+		let r = e[t], i = e[t + 1], a = e[n], o = e[n + 1], s = r.x === i.x;
+		if (s === (a.x === o.x)) if (s) {
+			if (r.x !== a.x) continue;
+			let e = Math.min(r.y, i.y), t = Math.max(r.y, i.y), n = Math.min(a.y, o.y);
+			if (e < Math.max(a.y, o.y) && n < t) return !0;
+		} else {
+			if (r.y !== a.y) continue;
+			let e = Math.min(r.x, i.x), t = Math.max(r.x, i.x), n = Math.min(a.x, o.x);
+			if (e < Math.max(a.x, o.x) && n < t) return !0;
+		}
+	}
+	return !1;
+}
+function ie(e) {
+	let t = e.slice(), n = !0;
+	for (; n;) {
+		n = !1;
+		for (let e = 1; e < t.length - 1; e++) {
+			let r = t[e - 1], i = t[e + 1], a = t[e];
+			if (a.x === r.x && a.y === r.y || a.x === i.x && a.y === i.y) {
+				t.splice(e, 1), n = !0;
+				break;
+			}
+		}
+		if (!n) for (let e = 1; e < t.length - 1; e++) {
+			let r = t[e - 1], i = t[e], a = t[e + 1], o = i.x - r.x, s = i.y - r.y, c = a.x - i.x, l = a.y - i.y, u = o * l - s * c, d = o * c + s * l, f = o * o + s * s + c * c + l * l || 1;
+			if (Math.abs(u) < 1e-9 * f && d > 0) {
+				t.splice(e, 1), n = !0;
+				break;
+			}
+		}
+	}
+	return t;
+}
+//#endregion
+//#region src/scene/lane-offset.ts
+var ae = 24, oe = 24 * 1.5;
+function se(e, t, n = 36) {
+	if (!t || e.length < 2) return e;
+	let r = e[0], i = e[e.length - 1], a = le(t * n, e);
+	if (a === 0) return e;
+	let o = e.length === 2 ? ce(r, i, a) : e;
+	if (o.length === 2) return e;
+	let s = fe(ue(o, a));
+	return s[0] = r, s[s.length - 1] = i, s;
+}
+function ce(e, t, n) {
+	let r = t.x - e.x, i = t.y - e.y, a = Math.hypot(r, i);
+	if (a < 1e-9) return [e, t];
+	let o = r / a, s = i / a, c = Math.min(Math.max(24, Math.abs(n)), a / 3);
+	return [
+		e,
+		{
+			x: e.x + o * c,
+			y: e.y + s * c
+		},
+		{
+			x: t.x - o * c,
+			y: t.y - s * c
+		},
+		t
+	];
+}
+function le(e, t) {
+	if (t.length < 3) return e;
+	let n = Infinity;
+	for (let e = 0; e < t.length - 1; e++) {
+		let r = Math.hypot(t[e + 1].x - t[e].x, t[e + 1].y - t[e].y);
+		r > 1e-9 && (n = Math.min(n, r));
+	}
+	if (!Number.isFinite(n)) return e;
+	let r = n / 2;
+	return Math.sign(e) * Math.min(Math.abs(e), r);
+}
+function ue(e, t) {
+	let n = [];
+	for (let t = 0; t < e.length - 1; t++) {
+		let r = e[t], i = e[t + 1], a = Math.hypot(i.x - r.x, i.y - r.y);
+		n.push(a > 1e-9 ? {
+			x: (i.x - r.x) / a,
+			y: (i.y - r.y) / a
+		} : null);
+	}
+	let r = de(n), i = [];
+	for (let n = 0; n < e.length - 1; n++) {
+		let a = e[n], o = e[n + 1], s = r[n], c = {
+			x: -s.y * t,
+			y: s.x * t
+		};
+		i.push({
+			from: {
+				x: a.x + c.x,
+				y: a.y + c.y
+			},
+			to: {
+				x: o.x + c.x,
+				y: o.y + c.y
+			},
+			dir: s
+		});
+	}
+	return i;
+}
+function de(e) {
+	let t = e.slice();
+	for (let e = 0; e < t.length; e++) {
+		if (t[e]) continue;
+		let n = null;
+		for (let r = e + 1; r < t.length && !n; r++) n = t[r];
+		if (!n) for (let r = e - 1; r >= 0 && !n; r--) n = t[r];
+		t[e] = n ?? {
+			x: 0,
+			y: 0
+		};
+	}
+	return t;
+}
+function fe(e) {
+	let t = [e[0].from];
+	for (let n = 0; n < e.length - 1; n++) {
+		let r = e[n], i = e[n + 1];
+		t.push(pe(r.from, r.dir, i.from, i.dir) ?? r.to);
+	}
+	return t.push(e[e.length - 1].to), t;
+}
+function pe(e, t, n, r) {
+	let i = t.x * r.y - t.y * r.x;
+	if (Math.abs(i) < 1e-9) return null;
+	let a = n.x - e.x, o = n.y - e.y, s = (a * r.y - o * r.x) / i;
+	return {
+		x: e.x + t.x * s,
+		y: e.y + t.y * s
+	};
+}
+//#endregion
+//#region src/media/registry.ts
+function me(e, t) {
+	if (e) {
+		if (t && e.styles[t]) return e.styles[t];
+		if (e.defaultMedium) return e.styles[e.defaultMedium];
+	}
+}
+var he = [
+	"animationSpeedFactor",
+	"opacity",
+	"waveAmplitude",
+	"wavePeriod",
+	"waveSpeed"
+], ge = ["meniscus"], _e = [
+	"sharp",
+	"diffuse",
+	"none"
+];
+function ve(e) {
+	let t = {};
+	for (let n of he) {
+		let r = e[n];
+		typeof r == "number" && (t[n] = r);
+	}
+	for (let n of ge) {
+		let r = e[n];
+		typeof r == "boolean" && (t[n] = r);
+	}
+	return typeof e.color == "string" && (t.color = e.color), typeof e.specular == "string" && _e.includes(e.specular) && (t.specular = e.specular), t;
+}
+function ye(e, t, n) {
+	let r = me(e, t);
+	if (!r) return r;
+	let i = t ? n?.[t] : void 0;
+	return i ? {
+		...r,
+		...ve(i)
+	} : r;
+}
+function be(e, t) {
+	return e.medium === void 0 ? t.edgeById.get(e.id)?.medium : e.medium;
+}
+//#endregion
+//#region src/scene/connection-geometry.ts
+function xe(e, t, n) {
+	let r = we(e.from, t), i = we(e.to, t);
+	if (!r || !i) return null;
+	let a = {
+		x: r.x,
+		y: r.y
+	}, o = {
+		x: i.x,
+		y: i.y
+	}, s = Ce(e.bindings ?? []), c = e.laneOffset, l = n ? be(e, n) : e.medium, u = e.routing ?? "orthogonal", d = !!e.waypoints && e.waypoints.length > 0;
+	if ((u === "manual" || u === "orthogonal") && d) {
+		let t = e.cornerRadius ?? 0;
+		return Se(se([
+			a,
+			...e.waypoints ?? [],
+			o
+		], c), t, l, s);
+	}
+	if (u === "orthogonal") {
+		let t = e.cornerRadius ?? 12;
+		return Se(se(te(a, r.dir, o, i.dir), c), t, l, s);
+	}
+	return {
+		segments: Te(se([a, o], c)),
+		corners: [],
+		medium: l,
+		flowBinding: s
+	};
+}
+function Se(e, t, n, r) {
+	return e.length <= 2 || t <= 0 ? {
+		segments: Te(e),
+		corners: [],
+		medium: n,
+		flowBinding: r
+	} : De(e, t, n, r);
+}
+function Ce(e) {
+	let t = e.find((e) => e.type === "flow");
+	return t ? {
+		tag: t.tag,
+		min: t.min,
+		max: t.max
+	} : void 0;
+}
+function we(e, t) {
+	let n = e.indexOf(".");
+	if (n < 0) return null;
+	let r = e.slice(0, n), i = e.slice(n + 1), a = t.elements.find((e) => e.id === r);
+	if (!a) return null;
+	let o = a.ports[i];
+	return o ? {
+		x: a.x + o.x,
+		y: a.y + o.y,
+		dir: o.dir
+	} : null;
+}
+function Te(e) {
+	let t = [];
+	for (let n = 0; n < e.length - 1; n++) t.push({
+		from: e[n],
+		to: e[n + 1]
+	});
+	return t;
+}
+function Ee(e, t) {
+	let n = [], r = [], i = e[0];
+	for (let a = 1; a < e.length - 1; a++) {
+		let o = e[a - 1], s = e[a], c = e[a + 1], l = Oe(s, o), u = Oe(c, s), d = je(l), f = je(u), p = Math.min(t, d / 2, f / 2), m = Ae(l, 1 / d), h = Ae(u, 1 / f), g = Oe(s, Ae(m, p)), _ = ke(s, Ae(h, p));
+		n.push({
+			from: i,
+			to: g
+		});
+		let v = m.x * h.y - m.y * h.x;
+		r.push({
+			from: g,
+			to: _,
+			radius: p,
+			sweepFlag: v > 0 ? 0 : 1
+		}), i = _;
+	}
+	return n.push({
+		from: i,
+		to: e[e.length - 1]
+	}), {
+		segments: n,
+		corners: r
+	};
+}
+function De(e, t, n, r) {
+	let { segments: i, corners: a } = Ee(e, t);
+	return {
+		segments: i,
+		corners: a,
+		medium: n,
+		flowBinding: r
+	};
+}
+function Oe(e, t) {
+	return {
+		x: e.x - t.x,
+		y: e.y - t.y
+	};
+}
+function ke(e, t) {
+	return {
+		x: e.x + t.x,
+		y: e.y + t.y
+	};
+}
+function Ae(e, t) {
+	return {
+		x: e.x * t,
+		y: e.y * t
+	};
+}
+function je(e) {
+	return Math.sqrt(e.x * e.x + e.y * e.y);
+}
+function Me(e) {
+	if (e.segments.length === 0) return "";
+	let t = e.segments[0].from, n = [`M ${t.x} ${t.y}`];
+	for (let t = 0; t < e.segments.length; t++) {
+		let r = e.segments[t];
+		n.push(`L ${r.to.x} ${r.to.y}`);
+		let i = e.corners[t];
+		i && n.push(`A ${i.radius} ${i.radius} 0 0 ${i.sweepFlag} ${i.to.x} ${i.to.y}`);
+	}
+	return n.join(" ");
+}
+function Ne(e) {
+	return Math.atan2(e.to.y - e.from.y, e.to.x - e.from.x);
+}
+//#endregion
+//#region src/topology/group-collapse.ts
+function Pe(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e.groups) if (t.has(r.id)) for (let e of r.children) n.set(e, r.id);
+	return n;
+}
+function Fe(e, t, n) {
+	return Pe(e, t).get(n) ?? n;
+}
+function Ie(e, t, n) {
+	if (n.size === 0) return e;
+	let r = Pe(t, n), i = (e) => r.get(e) ?? e, a = /* @__PURE__ */ new Set();
+	for (let t of e.nodes) a.add(i(t));
+	let o = [];
+	for (let t of e.edges) {
+		let e = i(t.from), n = i(t.to);
+		e !== n && o.push({
+			id: t.id,
+			from: e,
+			to: n,
+			medium: t.medium
+		});
+	}
+	let s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+	for (let e of o) {
+		l.set(e.id, e);
+		let t = s.get(e.from);
+		t ? t.push(e) : s.set(e.from, [e]);
+		let n = c.get(e.to);
+		n ? n.push(e) : c.set(e.to, [e]);
+	}
+	return {
+		nodes: a,
+		edges: o,
+		outgoing: s,
+		incoming: c,
+		edgeById: l
+	};
+}
+//#endregion
+//#region src/scheduler/quality.ts
+var Le = {
+	good: 0,
+	uncertain: 1,
+	stale: 2,
+	bad: 3
+};
+function Re(e, t) {
+	return Le[e] >= Le[t] ? e : t;
+}
+function ze(e, t, n) {
+	return e.quality === "bad" ? "bad" : t - (e.timestamp ?? e.arrivalTime) > n ? "stale" : e.quality === "uncertain" ? "uncertain" : "good";
+}
+function Be(e) {
+	return e.reduce((e, t) => Re(e, t), "good");
+}
+function Ve(e) {
+	let t = Math.floor(e / 1e3);
+	return t < 60 ? `${t}s` : `${Math.floor(t / 60)}m`;
+}
+//#endregion
+//#region src/scene/groups.ts
+var O = "http://www.w3.org/2000/svg";
+function He(e) {
+	return e.length === 0 ? "uncertain" : Be([...e]);
+}
+function Ue(e, t) {
+	let n = document.createElementNS(O, "g");
+	n.setAttribute("class", "vscada-group-summary"), n.setAttribute("data-group-id", e.id);
+	let r = t.tokens.panel;
+	if (!r) return {
+		svg: n,
+		setAlarmCondition: () => {},
+		setSummaryValue: () => {}
+	};
+	let i = document.createElementNS(O, "rect");
+	i.setAttribute("class", "vscada-group-face"), i.setAttribute("width", String(e.w)), i.setAttribute("height", String(e.h)), i.setAttribute("fill", r.raised.faceColor), n.appendChild(i);
+	let a = document.createElementNS(O, "path");
+	a.setAttribute("class", "vscada-group-bevel-highlight"), a.setAttribute("d", `M 0 ${e.h} L 0 0 L ${e.w} 0`), a.setAttribute("fill", "none"), a.setAttribute("stroke", r.raised.highlightColor), a.setAttribute("stroke-width", "2"), n.appendChild(a);
+	let o = document.createElementNS(O, "path");
+	o.setAttribute("class", "vscada-group-bevel-shadow"), o.setAttribute("d", `M ${e.w} 0 L ${e.w} ${e.h} L 0 ${e.h}`), o.setAttribute("fill", "none"), o.setAttribute("stroke", r.raised.shadowColor), o.setAttribute("stroke-width", "2"), n.appendChild(o);
+	let s = document.createElementNS(O, "text");
+	s.setAttribute("class", "vscada-group-label"), s.setAttribute("x", "6"), s.setAttribute("y", "14"), s.setAttribute("fill", r.labelColor), s.textContent = e.label ?? e.id, n.appendChild(s);
+	let c = /* @__PURE__ */ new Map();
+	e.summaryTags.forEach((e, t) => {
+		let i = document.createElementNS(O, "text");
+		i.setAttribute("class", "vscada-group-readout"), i.setAttribute("data-tag", e), i.setAttribute("x", "6"), i.setAttribute("y", String(28 + t * 14)), i.setAttribute("fill", r.readoutColor), n.appendChild(i), c.set(e, i);
+	});
+	let l = document.createElementNS(O, "circle");
+	l.setAttribute("class", "vscada-group-alarm"), l.setAttribute("cx", String(e.w - 8)), l.setAttribute("cy", "8"), l.setAttribute("r", "5"), l.setAttribute("fill", r.alarmIndicator.goodColor), n.appendChild(l);
+	let u = document.createElementNS(O, "text");
+	u.setAttribute("class", "vscada-group-alarm-label"), u.setAttribute("x", String(e.w - 8)), u.setAttribute("y", "20"), u.setAttribute("text-anchor", "middle"), u.setAttribute("font-size", "7"), u.setAttribute("fill", r.labelColor), u.textContent = "GOOD", n.appendChild(u);
+	let d = {
+		good: r.alarmIndicator.goodColor,
+		uncertain: r.alarmIndicator.uncertainColor,
+		stale: r.alarmIndicator.staleColor,
+		bad: r.alarmIndicator.badColor
+	};
+	function f(e, t) {
+		e.setAttr(l, "fill", d[t]), e.setText(u, t.toUpperCase());
+	}
+	function p(e, t, n) {
+		let r = c.get(t);
+		r && e.setText(r, n);
+	}
+	return {
+		svg: n,
+		setAlarmCondition: f,
+		setSummaryValue: p
+	};
+}
+function We(e, t) {
+	let n = document.createElementNS(O, "g");
+	n.setAttribute("class", "vscada-group-frame"), n.setAttribute("data-group-id", e.id);
+	let r = t.tokens.panel;
+	if (!r) return n;
+	let i = document.createElementNS(O, "rect");
+	i.setAttribute("class", "vscada-group-frame-outline"), i.setAttribute("width", String(e.w)), i.setAttribute("height", String(e.h)), i.setAttribute("fill", "none"), i.setAttribute("stroke", r.raised.highlightColor), i.setAttribute("stroke-dasharray", "4 3"), n.appendChild(i);
+	let a = document.createElementNS(O, "text");
+	return a.setAttribute("class", "vscada-group-frame-label"), a.setAttribute("x", "4"), a.setAttribute("y", "-4"), a.setAttribute("fill", r.labelColor), a.textContent = e.label ?? e.id, n.appendChild(a), n;
+}
+function Ge(e) {
+	return Object.entries(e.portMap).flatMap(([e, t]) => {
+		let n = t.indexOf(".");
+		return n < 0 ? [] : [{
+			groupPortName: e,
+			childElementId: t.slice(0, n),
+			childPortName: t.slice(n + 1)
+		}];
+	});
+}
+function Ke(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e.groups) if (t.has(r.id)) for (let e of Ge(r)) n.set(`${e.childElementId}.${e.childPortName}`, `${r.id}.${e.groupPortName}`);
+	return n;
+}
+function qe(e) {
+	let t = e.indexOf(".");
+	return t < 0 ? e : e.slice(0, t);
+}
+function Je(e, t, n) {
+	let r = Fe(t, n, qe(e.from));
+	return r === Fe(t, n, qe(e.to)) && n.has(r);
+}
+function Ye(e, t) {
+	if (t.size === 0) return e;
+	let n = Ke(e, t), r = e.groups.filter((e) => t.has(e.id)).map((e) => ({
+		id: e.id,
+		type: "group",
+		x: e.x,
+		y: e.y,
+		w: e.w,
+		h: e.h,
+		label: e.label,
+		ports: e.ports,
+		bindings: [],
+		thresholds: [],
+		transitions: {}
+	})), i = (e) => n.get(e) ?? e, a = e.connections.filter((n) => !Je(n, e, t)).map((e) => ({
+		...e,
+		from: i(e.from),
+		to: i(e.to)
+	}));
+	return {
+		...e,
+		elements: [...e.elements, ...r],
+		connections: a
+	};
+}
+function Xe(e, t, n, r) {
+	if (Je(e, t, n)) return null;
+	let i = Ye(t, n), a = Ke(t, n);
+	return xe({
+		...e,
+		from: a.get(e.from) ?? e.from,
+		to: a.get(e.to) ?? e.to
+	}, i, r);
+}
+//#endregion
+//#region src/store/value-store.ts
+var Ze = class {
+	constructor(e, t, n = "") {
+		this.timeSource = e, this.onWarning = t, this.buffer = /* @__PURE__ */ new Map(), this._tagPrefixVersion = 0, this._tagPrefix = n;
+	}
+	get tagPrefix() {
+		return this._tagPrefix;
+	}
+	set tagPrefix(e) {
+		e !== this._tagPrefix && (this._tagPrefix = e, this._tagPrefixVersion++);
+	}
+	get tagPrefixVersion() {
+		return this._tagPrefixVersion;
+	}
+	setValues(e) {
+		for (let t of e) this.ingestOne(t);
+	}
+	clearValues() {
+		this.buffer.clear();
+	}
+	get(e) {
+		return this.buffer.get(e);
+	}
+	resolve(e) {
+		return this.buffer.get(this._tagPrefix + e);
+	}
+	get size() {
+		return this.buffer.size;
+	}
+	tags() {
+		return this.buffer.keys();
+	}
+	ingestOne(e) {
+		let t = e.quality ?? "good", n = this.buffer.get(e.tag);
+		if (n && n.currentValue === e.value && n.quality === t && n.timestamp === e.timestamp) return;
+		this.checkTimestamp(e);
+		let r = this.timeSource.now();
+		this.buffer.set(e.tag, {
+			previousValue: n ? n.currentValue : e.value,
+			currentValue: e.value,
+			arrivalTime: r,
+			quality: t,
+			timestamp: e.timestamp
+		});
+	}
+	checkTimestamp(e) {}
+}, Qe = {
+	"state-lamp": 0,
+	flow: 1,
+	rotation: 2,
+	wave: 3
+}, $e = class {
+	constructor() {
+		this.entries = [];
+	}
+	register(e, t, n = "rotation") {
+		this.entries.push({
+			elementId: e,
+			handle: t,
+			paused: !1,
+			priority: n
+		});
+	}
+	registeredEntries() {
+		return this.entries.map((e) => ({
+			elementId: e.elementId,
+			priority: e.priority
+		}));
+	}
+	unregisterElement(e) {
+		this.entries = this.entries.filter((t) => t.elementId !== e);
+	}
+	pauseAll(e) {
+		for (let t of this.entries) t.elementId === e && !t.paused && (t.handle.pause(), t.paused = !0);
+	}
+	resumeAll(e) {
+		for (let t of this.entries) t.elementId === e && t.paused && (t.handle.resume(), t.paused = !1);
+	}
+	pauseScene() {
+		for (let e of this.entries) e.paused || (e.handle.pause(), e.paused = !0);
+	}
+	resumeScene() {
+		for (let e of this.entries) e.paused && (e.handle.resume(), e.paused = !1);
+	}
+	isPaused(e) {
+		return this.entries.filter((t) => t.elementId === e).map((e) => e.paused);
+	}
+	seekAll(e) {
+		for (let t of this.entries) t.handle.seek(e);
+	}
+};
+//#endregion
+//#region src/scheduler/visual-state-resolver.ts
+function et(e) {
+	return e.quality === "good" ? e.explicit === void 0 ? e.inferred === void 0 ? {
+		tier: "default",
+		value: e.defaultValue
+	} : {
+		tier: "inferred",
+		value: e.inferred
+	} : {
+		tier: "explicit",
+		value: e.explicit
+	} : {
+		tier: "quality",
+		value: e.quality
+	};
+}
+//#endregion
+//#region src/scheduler/lod.ts
+var tt = .5, nt = .1;
+function rt(e, t, n = tt, r = nt) {
+	let i = n * r;
+	return t ? e < n + i : e < n - i;
+}
+var it = 1e4, at = 1e3, ot = 100, st = 2e3, ct = 1e3, lt = 1e3, ut = 1e3 / 60, dt = 1.5;
+function k(e) {
+	return e === "stale" || e === "bad";
+}
+var ft = class {
+	constructor(e, t, n, r, i = {}) {
+		this.timeSource = e, this.store = t, this.renderer = n, this.animationRegistry = r, this.registrations = [], this.tickables = [], this.overlays = /* @__PURE__ */ new Map(), this.elementQuality = /* @__PURE__ */ new Map(), this.stopTick = null, this.wasSceneFrozen = !1, this.flowFrozen = /* @__PURE__ */ new Map(), this.flowIsolatedOverlay = /* @__PURE__ */ new Map(), this.lodFrozen = /* @__PURE__ */ new Map(), this.lodActiveValue = !1, this.lodMaxActiveAnimations = 50, this.visibilityPaused = !1, this.offscreenTimerId = null, this.debugEnabled = !1, this.statsFrameCount = 0, this.statsDroppedFrames = 0, this.statsWindowStart = 0, this.lastTickTime = null, this.statsCallback = null, this.conditionCallback = null, this.stalenessTimeout = it, this.connectionState = "connected", this._mode = "live", this._animateEnabled = !0, this.snapThreshold = i.snapThreshold ?? 50, this.lastSeenTagPrefixVersion = t.tagPrefixVersion;
+	}
+	registerHandle(e, t, n) {
+		if (n.kind !== "animation") {
+			if (n.kind === "tween") {
+				this.tickables.push({
+					elementId: e,
+					handle: n
+				});
+				return;
+			}
+			this.registrations.push({
+				elementId: e,
+				tag: t,
+				handle: n,
+				lastWritten: void 0,
+				lastArrivalTimeSeen: void 0,
+				tweenDurationMs: ot
+			});
+		}
+	}
+	registerQualityOverlay(e, t) {
+		this.overlays.set(e, t);
+	}
+	registerFlowInference(e, t) {
+		this.flowInference = {
+			cache: e,
+			ids: [...t]
+		};
+	}
+	unregisterElement(e) {
+		this.registrations = this.registrations.filter((t) => t.elementId !== e), this.tickables = this.tickables.filter((t) => t.elementId !== e), this.overlays.delete(e), this.elementQuality.delete(e), this.flowFrozen.delete(e), this.flowIsolatedOverlay.delete(e), this.lodFrozen.delete(e);
+	}
+	get registrationCount() {
+		return this.registrations.length;
+	}
+	get mode() {
+		return this._mode;
+	}
+	set mode(e) {
+		if (e === this._mode) return;
+		let t = this._mode === "live";
+		this._mode = e, e === "static" ? (t && this.snapToTargets(), this.stop()) : this.start();
+	}
+	get animate() {
+		return this._animateEnabled;
+	}
+	set animate(e) {
+		if (e === this._animateEnabled) return;
+		if (this._animateEnabled = e, !e) {
+			this.animationRegistry.pauseScene();
+			return;
+		}
+		let t = new Set(this.animationRegistry.registeredEntries().map((e) => e.elementId));
+		for (let e of t) this.visibilityPaused || this.isElementFrozen(e) || this.flowFrozen.get(e) || this.lodFrozen.get(e) || this.animationRegistry.resumeAll(e);
+	}
+	start() {
+		this.stopTick || this._mode !== "static" && (this.stopTick = this.timeSource.onTick((e) => this.tick(e)));
+	}
+	stop() {
+		this.stopTick?.(), this.stopTick = null, this.offscreenTimerId !== null && (clearInterval(this.offscreenTimerId), this.offscreenTimerId = null);
+	}
+	get isRunning() {
+		return this.stopTick !== null;
+	}
+	get lodActive() {
+		return this.lodActiveValue;
+	}
+	set lodActive(e) {
+		this.lodActiveValue = e;
+	}
+	get debug() {
+		return this.debugEnabled;
+	}
+	set debug(e) {
+		let t = e && !this.debugEnabled;
+		this.debugEnabled = e, t && (this.statsFrameCount = 0, this.statsDroppedFrames = 0, this.lastTickTime = null, this.statsWindowStart = this.timeSource.now());
+	}
+	onRenderStats(e) {
+		return this.statsCallback = e, () => {
+			this.statsCallback === e && (this.statsCallback = null);
+		};
+	}
+	onConditionTransition(e) {
+		return this.conditionCallback = e, () => {
+			this.conditionCallback === e && (this.conditionCallback = null);
+		};
+	}
+	get isPausedForOffscreen() {
+		return this.visibilityPaused;
+	}
+	pauseForOffscreen() {
+		this.visibilityPaused || (this.visibilityPaused = !0, this.stop(), this.animationRegistry.pauseScene(), this.offscreenTimerId = setInterval(() => this.offscreenTick(), ct));
+	}
+	resumeFromOffscreen() {
+		if (!this.visibilityPaused) return;
+		this.visibilityPaused = !1, this.offscreenTimerId !== null && (clearInterval(this.offscreenTimerId), this.offscreenTimerId = null);
+		let e = new Set(this.animationRegistry.registeredEntries().map((e) => e.elementId));
+		for (let t of e) this.isElementFrozen(t) || this.flowFrozen.get(t) || this.lodFrozen.get(t) || this.animationRegistry.resumeAll(t);
+		this.start();
+	}
+	offscreenTick() {
+		let e = this.timeSource.now(), t = this.connectionState === "disconnected";
+		this.evaluateQuality(e, t), this.applyFlowInference();
+	}
+	snapToTargets() {
+		this.syncTagPrefixIfChanged();
+		let e = this.timeSource.now();
+		for (let t of this.tickables) t.handle.snap(this.renderer, e);
+		for (let t of this.registrations) {
+			let n = this.store.resolve(t.tag);
+			n && (t.tweenDurationMs = Math.max(e - n.arrivalTime, 1), t.lastArrivalTimeSeen = n.arrivalTime, !Object.is(n.currentValue, t.lastWritten) && (t.lastWritten = n.currentValue, mt(t.handle, this.renderer, n.currentValue, e)));
+		}
+	}
+	tick(e) {
+		this.debugEnabled && this.accountFrame(e), this.syncTagPrefixIfChanged();
+		let t = this.connectionState === "disconnected";
+		t && !this.wasSceneFrozen && this.animationRegistry.pauseScene(), this.wasSceneFrozen = t, this.evaluateQuality(e, t), this.applyFlowInference();
+		for (let n of this.tickables) t || this.isElementFrozen(n.elementId) || n.handle.tick(this.renderer, e);
+		for (let n of this.registrations) {
+			if (t || this.isElementFrozen(n.elementId)) continue;
+			let r = this.store.resolve(n.tag);
+			if (!r) continue;
+			if (r.arrivalTime !== n.lastArrivalTimeSeen) {
+				let e = n.lastArrivalTimeSeen === void 0 ? ot : r.arrivalTime - n.lastArrivalTimeSeen;
+				n.tweenDurationMs = Math.min(Math.max(e, ot), st), n.lastArrivalTimeSeen = r.arrivalTime;
+			}
+			let i = n.handle.kind === "state" ? r.currentValue : pt(r, e, n.tweenDurationMs, this.snapThreshold);
+			Object.is(i, n.lastWritten) || (n.lastWritten = i, mt(n.handle, this.renderer, i, e));
+		}
+		this.applyLod();
+	}
+	applyLod() {
+		if (!this.lodActiveValue && this.lodFrozen.size === 0) return;
+		if (!this.lodActiveValue) {
+			for (let [e, t] of [...this.lodFrozen]) {
+				if (!t) {
+					this.lodFrozen.delete(e);
+					continue;
+				}
+				this.isElementFrozen(e) || this.flowFrozen.get(e) || (this.animationRegistry.resumeAll(e), this.lodFrozen.delete(e));
+			}
+			return;
+		}
+		let e = this.animationRegistry.registeredEntries(), t = [...e].sort((e, t) => Qe[e.priority] - Qe[t.priority]), n = new Set(t.slice(0, this.lodMaxActiveAnimations).map((e) => e.elementId));
+		for (let { elementId: t } of e) {
+			let e = !n.has(t), r = this.lodFrozen.get(t) ?? !1;
+			if (e && !r) this.animationRegistry.pauseAll(t), this.lodFrozen.set(t, !0);
+			else if (!e && r) {
+				if (this.isElementFrozen(t) || this.flowFrozen.get(t)) continue;
+				this.animationRegistry.resumeAll(t), this.lodFrozen.set(t, !1);
+			}
+		}
+	}
+	accountFrame(e) {
+		this.lastTickTime !== null && e - this.lastTickTime > ut * dt && this.statsDroppedFrames++, this.lastTickTime = e, this.statsFrameCount++;
+		let t = e - this.statsWindowStart;
+		if (t < lt) return;
+		let n = t / 1e3, r = n > 0 ? this.statsFrameCount / n : 0;
+		this.statsCallback?.({
+			fps: Math.round(r),
+			elementCount: this.countDistinctElements(),
+			droppedFrames: this.statsDroppedFrames
+		}), this.statsFrameCount = 0, this.statsDroppedFrames = 0, this.statsWindowStart = e;
+	}
+	countDistinctElements() {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of this.registrations) e.add(t.elementId);
+		for (let t of this.tickables) e.add(t.elementId);
+		for (let t of this.overlays.keys()) e.add(t);
+		for (let t of this.animationRegistry.registeredEntries()) e.add(t.elementId);
+		return e.size;
+	}
+	syncTagPrefixIfChanged() {
+		let e = this.store.tagPrefixVersion;
+		if (e !== this.lastSeenTagPrefixVersion) {
+			this.lastSeenTagPrefixVersion = e;
+			for (let e of this.registrations) e.lastWritten = void 0, e.lastArrivalTimeSeen = void 0, e.tweenDurationMs = ot;
+		}
+	}
+	isElementFrozen(e) {
+		let t = this.elementQuality.get(e);
+		return t !== void 0 && k(t.condition);
+	}
+	evaluateQuality(e, t) {
+		let n = /* @__PURE__ */ new Map();
+		for (let e of this.registrations) {
+			let t = n.get(e.elementId) ?? [];
+			t.push(e.tag), n.set(e.elementId, t);
+		}
+		let r = /* @__PURE__ */ new Set([...n.keys(), ...this.overlays.keys()]);
+		for (let i of r) {
+			let r = n.get(i) ?? [], a = "good", o = 0;
+			for (let t of r) {
+				let n = this.store.resolve(t);
+				n && (a = Be([a, ze(n, e, this.stalenessTimeout)]), o = Math.max(o, e - (n.timestamp ?? n.arrivalTime)));
+			}
+			t && (a = Be([a, "stale"]));
+			let s = this.elementQuality.get(i), c = s?.condition ?? "good", l = this.overlays.get(i);
+			a !== c && (l?.setCondition(this.renderer, a), this.handleConditionTransition(i, c, a, e), this.conditionCallback?.(i, c, a));
+			let u = s?.lastBadgeUpdate ?? -Infinity;
+			l && (a === "stale" && e - u >= at ? (l.setAgeBadge(this.renderer, Ve(o)), u = e) : a !== "stale" && l.setAgeBadge(this.renderer, null)), this.elementQuality.set(i, {
+				condition: a,
+				lastBadgeUpdate: u
+			});
+		}
+	}
+	applyFlowInference() {
+		if (!this.flowInference) return;
+		let { cache: e, ids: t } = this.flowInference;
+		for (let n of t) {
+			let t = e.getState(n), r = this.elementQuality.get(n)?.condition ?? "good", i = et({
+				quality: r,
+				inferred: t,
+				defaultValue: "flowing"
+			}), a = i.tier === "quality", o = !a && (i.value === "no-flow" || i.value === "isolated");
+			o ? this.animationRegistry.pauseAll(n) : a || this.flowFrozen.get(n) && this.animationRegistry.resumeAll(n), this.flowFrozen.set(n, o);
+			let s = this.overlays.get(n), c = i.tier === "inferred" && i.value === "isolated", l = this.flowIsolatedOverlay.get(n) ?? !1;
+			s && r === "good" && c !== l && s.setCondition(this.renderer, c ? "stale" : "good"), this.flowIsolatedOverlay.set(n, c);
+		}
+	}
+	handleConditionTransition(e, t, n, r) {
+		let i = k(n) && !k(t), a = k(t) && !k(n);
+		if (i) {
+			if (this.animationRegistry.pauseAll(e), n === "bad") for (let t of this.registrations) t.elementId === e && t.handle.kind === "text" && (t.handle.write(this.renderer, "----", r), t.lastWritten = "----");
+		} else a && this.animationRegistry.resumeAll(e);
+	}
+};
+function pt(e, t, n, r) {
+	let { previousValue: i, currentValue: a, arrivalTime: o } = e;
+	if (typeof i != "number" || typeof a != "number" || i === a || Math.abs(a - i) > r) return a;
+	let s = Math.min(Math.max((t - o) / n, 0), 1);
+	return i + (a - i) * s;
+}
+function mt(e, t, n, r) {
+	if (e.kind === "numeric") {
+		typeof n == "number" && e.write(t, n, r);
+		return;
+	}
+	(e.kind === "text" || e.kind === "state") && e.write(t, n, r);
+}
+//#endregion
+//#region src/scheduler/quality-overlay.ts
+var A = "http://www.w3.org/2000/svg", ht = "vscada-quality-hatch";
+function gt(e, t, n) {
+	let r = n.tokens.quality, i = document.createElementNS(A, "g");
+	if (i.setAttribute("class", "vscada-quality-overlay"), i.setAttribute("display", "none"), !r) return {
+		group: i,
+		setCondition: () => {},
+		setAgeBadge: () => {}
+	};
+	let a = document.createElementNS(A, "rect");
+	if (a.setAttribute("class", "vscada-quality-dash"), a.setAttribute("width", String(e)), a.setAttribute("height", String(t)), a.setAttribute("fill", "none"), a.setAttribute("stroke", r.uncertainDashColor), a.setAttribute("stroke-dasharray", "4 3"), a.setAttribute("display", "none"), i.appendChild(a), !n.defs.querySelector(`#${ht}`)) {
+		let e = document.createElementNS(A, "pattern");
+		e.setAttribute("id", ht), e.setAttribute("width", "8"), e.setAttribute("height", "8"), e.setAttribute("patternUnits", "userSpaceOnUse"), e.setAttribute("patternTransform", "rotate(45)");
+		let t = document.createElementNS(A, "line");
+		t.setAttribute("x1", "0"), t.setAttribute("y1", "0"), t.setAttribute("x2", "0"), t.setAttribute("y2", "8"), t.setAttribute("stroke", r.badHatchColor), t.setAttribute("stroke-width", "4"), e.appendChild(t), n.defs.appendChild(e);
+	}
+	let o = document.createElementNS(A, "rect");
+	o.setAttribute("class", "vscada-quality-hatch"), o.setAttribute("width", String(e)), o.setAttribute("height", String(t)), o.setAttribute("fill", `url(#${ht})`), o.setAttribute("opacity", String(r.badHatchOpacity)), o.setAttribute("display", "none"), i.appendChild(o);
+	let s = document.createElementNS(A, "rect");
+	s.setAttribute("class", "vscada-quality-stale"), s.setAttribute("width", String(e)), s.setAttribute("height", String(t)), s.setAttribute("fill", r.staleOverlayColor), s.setAttribute("opacity", String(r.staleOverlayOpacity)), s.setAttribute("display", "none"), i.appendChild(s);
+	let c = document.createElementNS(A, "g");
+	c.setAttribute("class", "vscada-quality-badge"), c.setAttribute("display", "none");
+	let l = document.createElementNS(A, "rect");
+	l.setAttribute("x", String(e - 24)), l.setAttribute("y", "-14"), l.setAttribute("width", "24"), l.setAttribute("height", "12"), l.setAttribute("fill", r.badgeBackgroundColor), c.appendChild(l);
+	let u = document.createElementNS(A, "text");
+	u.setAttribute("class", "vscada-quality-badge-text"), u.setAttribute("x", String(e - 12)), u.setAttribute("y", "-5"), u.setAttribute("font-size", "8"), u.setAttribute("text-anchor", "middle"), u.setAttribute("fill", r.badgeTextColor), c.appendChild(u), i.appendChild(c);
+	function d(e, t) {
+		e.setAttr(i, "display", t === "good" ? "none" : "inline"), e.setAttr(a, "display", t === "uncertain" ? "inline" : "none"), e.setAttr(o, "display", t === "bad" ? "inline" : "none"), e.setAttr(s, "display", t === "stale" ? "inline" : "none"), e.setAttr(c, "display", t === "stale" ? "inline" : "none");
+	}
+	function f(e, t) {
+		e.setText(u, t ?? "");
+	}
+	return {
+		group: i,
+		setCondition: d,
+		setAgeBadge: f
+	};
+}
+//#endregion
+//#region src/bindings/transforms.ts
+function _t(e) {
+	return Number.isNaN(e) ? 0 : Math.min(Math.max(e, 0), 1);
+}
+function vt(e, t, n) {
+	return Math.min(Math.max(e, t), n);
+}
+function j(e, t, n) {
+	let r = t - e;
+	return r === 0 ? 0 : _t((n - e) / r);
+}
+function yt(e, t) {
+	return j(e.min, e.max, t);
+}
+function bt(e, t) {
+	return j(e.min, e.max, t);
+}
+var xt = 4;
+function St(e, t) {
+	return vt(t, 0, e.max ?? 4);
+}
+var Ct = {
+	minAngleDeg: -135,
+	maxAngleDeg: 135
+};
+function wt(e, t, n = Ct) {
+	let r = j(e.min, e.max, t);
+	return n.minAngleDeg + r * (n.maxAngleDeg - n.minAngleDeg);
+}
+function Tt(e, t) {
+	if (typeof t != "number") return String(t);
+	let n = t.toFixed(e.decimals);
+	return e.unit.length > 0 ? `${n} ${e.unit}` : n;
+}
+function Et(e, t) {
+	if (e.map) {
+		let n = e.map[String(t)];
+		if (n !== void 0) return n;
+	}
+	return !!t;
+}
+function Dt(e, t) {
+	let n = String(t), r = e.map[n];
+	return r === void 0 ? {
+		ok: !1,
+		fault: {
+			code: "UNMAPPED_STATE_VALUE",
+			message: `Tag "${e.tag}": value "${n}" has no entry in this binding's state map`,
+			tag: e.tag
+		}
+	} : {
+		ok: !0,
+		state: r
+	};
+}
+//#endregion
+//#region src/bindings/color-ramp.ts
+function Ot(e) {
+	return Math.min(Math.max(e, 0), 1);
+}
+function kt(e) {
+	let t = /^#([0-9a-fA-F]{3})$/.exec(e);
+	if (t) {
+		let [e, n, r] = t[1].split("").map((e) => parseInt(e + e, 16));
+		return [
+			e,
+			n,
+			r
+		];
+	}
+	let n = /^#([0-9a-fA-F]{6})$/.exec(e);
+	if (n) {
+		let e = n[1];
+		return [
+			parseInt(e.slice(0, 2), 16),
+			parseInt(e.slice(2, 4), 16),
+			parseInt(e.slice(4, 6), 16)
+		];
+	}
+}
+function At(e) {
+	return Math.round(Ot(e / 255) * 255).toString(16).padStart(2, "0").toUpperCase();
+}
+function jt(e, t, n) {
+	let r = kt(e), i = kt(t);
+	if (!r || !i) return e;
+	let a = Ot(n), o = r[0] + (i[0] - r[0]) * a, s = r[1] + (i[1] - r[1]) * a, c = r[2] + (i[2] - r[2]) * a;
+	return `#${At(o)}${At(s)}${At(c)}`;
+}
+function Mt(e, t) {
+	let n = [...e].sort((e, t) => e.offset - t.offset);
+	if (n.length === 0) return "#000000";
+	if (n.length === 1) return n[0].color;
+	let r = Ot(t);
+	if (r <= n[0].offset) return n[0].color;
+	if (r >= n[n.length - 1].offset) return n[n.length - 1].color;
+	for (let e = 0; e < n.length - 1; e++) {
+		let t = n[e], i = n[e + 1];
+		if (r >= t.offset && r <= i.offset) {
+			let e = i.offset - t.offset, n = e === 0 ? 0 : (r - t.offset) / e;
+			return jt(t.color, i.color, n);
+		}
+	}
+	return n[n.length - 1].color;
+}
+function Nt(e, t) {
+	let n = e.colors;
+	if (!n || n.length === 0) return t.default;
+	let r = [];
+	for (let e = 0; e < n.length; e++) {
+		let i = t.stops[n[e]];
+		if (!i) continue;
+		let a = n.length === 1 ? 0 : e / (n.length - 1);
+		r.push({
+			offset: a,
+			color: i
+		});
+	}
+	return r.length >= 2 ? r : t.default;
+}
+function Pt(e, t, n) {
+	if (n) return Mt(Nt(e, n), j(e.min, e.max, t));
+}
+//#endregion
+//#region src/import/svg-source-registry.ts
+var Ft = /* @__PURE__ */ new Map();
+function It(e) {
+	for (let [t, n] of Object.entries(e)) Ft.set(t, n);
+}
+function Lt(e) {
+	return Ft.get(e);
+}
+//#endregion
+//#region src/import/load-svg-import.ts
+var Rt = "http://www.w3.org/2000/svg", zt = /* @__PURE__ */ new Set([
+	"readout",
+	"state",
+	"visibility",
+	"blink",
+	"color-ramp"
+]), Bt = [
+	"scale(1)",
+	"scale(0.3)",
+	"scale(1)"
+], Vt = 800;
+function Ht(e, t, n, r) {
+	let i = document.createElementNS(Rt, "g");
+	i.setAttribute("class", "vscada-svg-import"), i.setAttribute("data-element-id", e.id);
+	let a = gt(e.w, e.h, t);
+	i.appendChild(a.group);
+	let o = {}, s = /* @__PURE__ */ new Set();
+	function c(e, t) {
+		s.add(e), a.setCondition(n, "bad");
+	}
+	function l(e) {
+		s.has(e) && (s.delete(e), s.size === 0 && a.setCondition(n, "good"));
+	}
+	let u = Lt(e.svgRef);
+	if (u === void 0) return c(`svgRef:${e.svgRef}`, {
+		code: "MISSING_SVG_SOURCE",
+		message: `svg-import "${e.id}" references svgRef "${e.svgRef}" but no source is registered — call registerSvgSources() before assigning the scene`,
+		tag: e.svgRef
+	}), {
+		svg: i,
+		handles: o
+	};
+	let d = new DOMParser().parseFromString(u, "image/svg+xml"), f = d.documentElement;
+	if (d.querySelector("parsererror") || f.nodeName.toLowerCase() !== "svg") return c(`svgRef:${e.svgRef}`, {
+		code: "INVALID_SVG_SOURCE",
+		message: `svg-import "${e.id}"'s svgRef "${e.svgRef}" did not parse as SVG`,
+		tag: e.svgRef
+	}), {
+		svg: i,
+		handles: o
+	};
+	let p = document.createElementNS(Rt, "svg"), m = f.getAttribute("viewBox");
+	for (m && p.setAttribute("viewBox", m), p.setAttribute("width", String(e.w)), p.setAttribute("height", String(e.h)), p.setAttribute("preserveAspectRatio", "xMidYMid meet"); f.firstChild;) p.appendChild(document.adoptNode(f.firstChild));
+	i.appendChild(p);
+	for (let r of e.bindings) {
+		if (!zt.has(r.type)) {
+			c(`type:${r.tag}`, {
+				code: "UNSUPPORTED_IMPORT_BINDING_TYPE",
+				message: `svg-import "${e.id}" binding for tag "${r.tag}" has unsupported type "${r.type}" — imported art supports readout/state/visibility/blink/color-ramp only`,
+				tag: r.tag
+			});
+			continue;
+		}
+		let i = p.querySelector(`#${CSS.escape(r.svgId)}`);
+		if (!i) {
+			c(`id:${r.svgId}`, {
+				code: "MISSING_SVG_ID",
+				message: `svg-import "${e.id}" binding for tag "${r.tag}" references svgId "${r.svgId}" but no matching element exists in the imported SVG`,
+				tag: r.tag
+			});
+			continue;
+		}
+		switch (r.type) {
+			case "readout":
+				o[r.tag] = {
+					kind: "text",
+					write(e, t) {
+						e.setText(i, Tt(r, t));
+					}
+				};
+				break;
+			case "state": {
+				let e = `state:${r.tag}`;
+				o[r.tag] = {
+					kind: "state",
+					write(t, n) {
+						let a = Dt(r, n);
+						if (a.ok) {
+							l(e), t.setAttr(i, "class", a.state);
+							return;
+						}
+						c(e, a.fault);
+					}
+				};
+				break;
+			}
+			case "visibility":
+				o[r.tag] = {
+					kind: "state",
+					write(e, t) {
+						e.setAttr(i, "display", Et(r, t) ? "inline" : "none");
+					}
+				};
+				break;
+			case "color-ramp":
+				o[r.tag] = {
+					kind: "numeric",
+					write(e, n) {
+						if (typeof n != "number") return;
+						let a = Pt(r, n, t.tokens.colorRamp);
+						a !== void 0 && e.setAttr(i, "fill", a);
+					}
+				};
+				break;
+			case "blink": {
+				let t = n.animateTransform(i, Bt, Vt), a = {
+					kind: "animation",
+					pause: () => t.pause(),
+					resume: () => t.resume(),
+					seek: (e) => t.seek(e)
+				};
+				o[`__svg-import-blink-animation-${e.id}-${r.tag}`] = a, o[r.tag] = {
+					kind: "numeric",
+					write(e, n) {
+						typeof n == "number" && t.setPlaybackRate(St(r, n));
+					}
+				};
+				break;
+			}
+		}
+	}
+	return {
+		svg: i,
+		handles: o
+	};
+}
+//#endregion
+//#region src/topology/graph.ts
+function Ut(e) {
+	let t = new Set(e.topology.nodes), n = e.topology.edges.map((e) => ({
+		id: e.id,
+		from: e.from,
+		to: e.to,
+		medium: e.medium
+	})), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		a.set(e.id, e);
+		let t = r.get(e.from);
+		t ? t.push(e) : r.set(e.from, [e]);
+		let n = i.get(e.to);
+		n ? n.push(e) : i.set(e.to, [e]);
+	}
+	return {
+		nodes: t,
+		edges: n,
+		outgoing: r,
+		incoming: i,
+		edgeById: a
+	};
+}
+//#endregion
+//#region src/topology/traversal.ts
+function Wt(e, t, n) {
+	let r = n === "downstream" ? e.outgoing : e.incoming, i = (e) => n === "downstream" ? e.to : e.from, a = /* @__PURE__ */ new Set([t]), o = [t], s = e.nodes.size + 1, c = 0;
+	for (; o.length > 0;) {
+		if (c += 1, c > s) throw Error("reachableSet exceeded its node-count iteration bound — cycle guard invariant violated");
+		let e = o.shift(), t = r.get(e) ?? [];
+		for (let e of t) {
+			let t = i(e);
+			a.has(t) || (a.add(t), o.push(t));
+		}
+	}
+	return a;
+}
+function Gt(e, t) {
+	return Wt(e, t, "upstream");
+}
+function Kt(e, t) {
+	return Wt(e, t, "downstream");
+}
+//#endregion
+//#region src/topology/inference.ts
+function qt(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e.nodes) n.set(r, t.has(r) ? [] : e.outgoing.get(r) ?? []);
+	return {
+		...e,
+		outgoing: n
+	};
+}
+function Jt(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of t) for (let t of Kt(e, r)) n.add(t);
+	return n;
+}
+function Yt(e) {
+	let { graph: t, sourceNodeIds: n, stoppedSourceNodeIds: r, closedNodeIds: i } = e, a = qt(t, i), o = [...n].filter((e) => !r.has(e)), s = Jt(t, n), c = Jt(a, n), l = Jt(a, o), u = /* @__PURE__ */ new Map();
+	for (let e of t.nodes) if (s.has(e)) {
+		if (!c.has(e)) {
+			u.set(e, "isolated");
+			continue;
+		}
+		u.set(e, l.has(e) ? "flowing" : "no-flow");
+	}
+	let d = /* @__PURE__ */ new Map();
+	for (let e of t.edges) if (s.has(e.from)) {
+		if (!c.has(e.from)) {
+			d.set(e.id, "isolated");
+			continue;
+		}
+		if (i.has(e.from)) {
+			d.set(e.id, c.has(e.to) ? "no-flow" : "isolated");
+			continue;
+		}
+		d.set(e.id, l.has(e.from) ? "flowing" : "no-flow");
+	}
+	return {
+		edgeStates: d,
+		nodeStates: u
+	};
+}
+function Xt(e, t) {
+	return JSON.stringify([[...e].sort(), [...t].sort()]);
+}
+var Zt = class {
+	constructor(e, t) {
+		this.graph = e, this.sourceNodeIds = t, this.result = {
+			edgeStates: /* @__PURE__ */ new Map(),
+			nodeStates: /* @__PURE__ */ new Map()
+		};
+	}
+	update(e, t) {
+		let n = Xt(e, t);
+		return n !== this.lastSignature && (this.result = Yt({
+			graph: this.graph,
+			sourceNodeIds: this.sourceNodeIds,
+			stoppedSourceNodeIds: e,
+			closedNodeIds: t
+		}), this.lastSignature = n), this.result;
+	}
+	getEdgeState(e) {
+		return this.result.edgeStates.get(e);
+	}
+	getNodeState(e) {
+		return this.result.nodeStates.get(e);
+	}
+	getState(e) {
+		return this.result.edgeStates.get(e) ?? this.result.nodeStates.get(e);
+	}
+	reset() {
+		this.result = {
+			edgeStates: /* @__PURE__ */ new Map(),
+			nodeStates: /* @__PURE__ */ new Map()
+		}, this.lastSignature = void 0;
+	}
+};
+//#endregion
+//#region src/topology/upstream-highlight.ts
+function Qt(e, t) {
+	let n = e.edgeById.get(t);
+	if (!n) return;
+	let r = /* @__PURE__ */ new Set([n.to]), i = /* @__PURE__ */ new Set([n.id]), a = [n];
+	for (; a.length > 0;) {
+		let t = a.shift();
+		r.add(t.from);
+		let o = e.incoming.get(t.from) ?? [];
+		for (let e of o) e.medium === n.medium && (i.has(e.id) || (i.add(e.id), a.push(e)));
+	}
+	return {
+		nodes: r,
+		edges: i
+	};
+}
+function $t(e) {
+	return e === "mouse";
+}
+var en = "data-vscada-highlight";
+function tn(e, t, n) {
+	let r = n.highlightAttr ?? en, i;
+	function a(e, n) {
+		e && t.setAttr(e, r, n ? "true" : "false");
+	}
+	function o() {
+		if (i) {
+			for (let e of i.nodes) a(n.getNodeElement(e), !1);
+			for (let e of i.edges) a(n.getEdgeElement(e), !1);
+			i = void 0;
+		}
+	}
+	return {
+		onPointerEnter(t, r) {
+			if (!$t(r.pointerType)) return;
+			let s = Qt(e, t);
+			if (s) {
+				o(), i = s;
+				for (let e of s.nodes) a(n.getNodeElement(e), !0);
+				for (let e of s.edges) a(n.getEdgeElement(e), !0);
+			}
+		},
+		onPointerLeave() {
+			o();
+		}
+	};
+}
+//#endregion
+//#region src/view/group-view-state.ts
+var nn = class {
+	constructor(e, t) {
+		this.animationRegistry = t, this.collapsed = /* @__PURE__ */ new Map(), this.scene = e, this.seedFromScene(e);
+	}
+	seedFromScene(e) {
+		this.collapsed = new Map(e.groups.map((e) => [e.id, e.collapsed]));
+	}
+	reset(e) {
+		this.scene = e, this.seedFromScene(e);
+	}
+	isCollapsed(e) {
+		return this.collapsed.get(e) ?? !1;
+	}
+	collapsedGroupIds() {
+		let e = /* @__PURE__ */ new Set();
+		for (let [t, n] of this.collapsed) n && e.add(t);
+		return e;
+	}
+	toggleGroup(e) {
+		return this.setCollapsed(e, !this.isCollapsed(e));
+	}
+	setCollapsed(e, t) {
+		let n = this.scene.groups.find((t) => t.id === e);
+		if (!n) return this.isCollapsed(e);
+		let r = this.isCollapsed(e);
+		return this.collapsed.set(e, t), t && !r && this.deregisterChildren(n), t;
+	}
+	deregisterChildren(e) {
+		if (this.animationRegistry) for (let t of e.children) this.animationRegistry.pauseAll(t), this.animationRegistry.unregisterElement(t);
+	}
+};
+function rn(e, t) {
+	return new nn(e, t);
+}
+//#endregion
+//#region src/fsm/fsm.ts
+var an = "unknown", on = class {
+	constructor(e, t, n, r) {
+		this.map = e, this.transitions = t, this.defaultTransition = n, this.onWarning = r;
+	}
+	resolve(e, t) {
+		let n = String(e), r = this.map[n], i = this.currentState;
+		if (r === void 0) {
+			this.onWarning?.({
+				code: "UNMAPPED_STATE_VALUE",
+				message: `Tag "${t}": value "${n}" has no entry in this binding's state map`,
+				tag: t
+			});
+			let e = i ?? "unknown";
+			return {
+				state: e,
+				previousState: i,
+				transition: this.resolveDefault(i, e),
+				changed: !1
+			};
+		}
+		if (this.currentState = r, i === void 0 || i === r) return {
+			state: r,
+			previousState: i,
+			transition: this.resolveDefault(i, r),
+			changed: !1
+		};
+		let a = `${i}→${r}`;
+		return {
+			state: r,
+			previousState: i,
+			transition: this.transitions[a] ?? this.resolveDefault(i, r),
+			changed: !0
+		};
+	}
+	resolveDefault(e, t) {
+		return typeof this.defaultTransition == "function" ? this.defaultTransition(e, t) : this.defaultTransition;
+	}
+};
+function sn(e, t, n, r = 44) {
+	let i = r / n, a = Math.max(e, i), o = Math.max(t, i);
+	return {
+		x: (e - a) / 2,
+		y: (t - o) / 2,
+		w: a,
+		h: o
+	};
+}
+var cn = "http://www.w3.org/2000/svg";
+function ln(e, t, n, r = {
+	x: 0,
+	y: 0
+}) {
+	let i = sn(e, t, n), a = document.createElementNS(cn, "rect");
+	return a.setAttribute("x", String(i.x + r.x)), a.setAttribute("y", String(i.y + r.y)), a.setAttribute("width", String(i.w)), a.setAttribute("height", String(i.h)), a.setAttribute("fill", "transparent"), a.setAttribute("class", "vscada-hit-area"), a.style.pointerEvents = "all", a.style.cursor = "pointer", a.setAttribute("tabindex", "0"), a.setAttribute("role", "button"), a;
+}
+function un(e, t, n, r, i = {
+	x: 0,
+	y: 0
+}) {
+	let a = sn(t, n, r);
+	e.setAttribute("x", String(a.x + i.x)), e.setAttribute("y", String(a.y + i.y)), e.setAttribute("width", String(a.w)), e.setAttribute("height", String(a.h));
+}
+function dn(e = 10) {
+	let t = /* @__PURE__ */ new Map();
+	return {
+		onPointerDown(e, n, r) {
+			t.set(e, {
+				x: n,
+				y: r
+			});
+		},
+		onPointerUp(n, r, i) {
+			let a = t.get(n);
+			return t.delete(n), a && Math.hypot(r - a.x, i - a.y) <= e ? "tap" : "drag";
+		},
+		onPointerCancel(e) {
+			t.delete(e);
+		}
+	};
+}
+//#endregion
+//#region src/interaction/pointer-pipeline.ts
+function fn(e, t) {
+	let { elementId: n, elementType: r, tags: i, arbiter: a, isInteractive: o, onClick: s, onHoverChange: c } = t;
+	e.addEventListener("pointerdown", (e) => {
+		let t = e;
+		a.onPointerDown(t.pointerId, t.clientX, t.clientY);
+	}), e.addEventListener("pointerup", (e) => {
+		let t = e;
+		a.onPointerUp(t.pointerId, t.clientX, t.clientY) !== "tap" || !o() || s({
+			elementId: n,
+			tags: i,
+			elementType: r
+		});
+	}), e.addEventListener("pointercancel", (e) => {
+		a.onPointerCancel(e.pointerId);
+	}), e.addEventListener("keydown", (e) => {
+		let t = e;
+		t.key !== "Enter" && t.key !== " " || o() && (t.preventDefault(), s({
+			elementId: n,
+			tags: i,
+			elementType: r
+		}));
+	}), c && (e.addEventListener("pointerenter", (e) => {
+		e.pointerType === "mouse" && c(!0);
+	}), e.addEventListener("pointerleave", (e) => {
+		e.pointerType === "mouse" && c(!1);
+	}));
+}
+//#endregion
+//#region src/interaction/pan-zoom-gestures.ts
+var pn = .0015;
+function mn(e, t) {
+	return Math.hypot(e.x - t.x, e.y - t.y);
+}
+function hn(e, t) {
+	return {
+		x: (e.x + t.x) / 2,
+		y: (e.y + t.y) / 2
+	};
+}
+function gn(e, t = 10) {
+	let n = /* @__PURE__ */ new Map(), r = null, i = null;
+	function a() {
+		if (n.size < 2) return null;
+		let e = [...n.values()];
+		return [e[0], e[1]];
+	}
+	return {
+		onPointerDown(e, t, o) {
+			if (n.set(e, {
+				originX: t,
+				originY: o,
+				x: t,
+				y: o
+			}), n.size >= 2) {
+				r = null;
+				let e = a();
+				i = e ? mn(e[0], e[1]) : null;
+			}
+		},
+		onPointerMove(o, s, c) {
+			let l = n.get(o);
+			if (!l) return;
+			if (l.x = s, l.y = c, n.size >= 2) {
+				let t = a();
+				if (!t || i === null || i < 1) return;
+				let n = mn(t[0], t[1]), r = n / i;
+				i = n;
+				let o = hn(t[0], t[1]);
+				e.onZoomAboutPoint(e.getZoom() * r, o.x, o.y);
+				return;
+			}
+			if (r === null) {
+				if (Math.hypot(s - l.originX, c - l.originY) <= t) return;
+				r = o, l.originX = s, l.originY = c;
+				return;
+			}
+			if (o !== r) return;
+			let u = s - l.originX, d = c - l.originY;
+			l.originX = s, l.originY = c, e.onPan(u, d);
+		},
+		onPointerUp(e) {
+			n.delete(e), r === e && (r = null), n.size < 2 && (i = null);
+		},
+		onPointerCancel(e) {
+			n.delete(e), r === e && (r = null), n.size < 2 && (i = null);
+		},
+		onWheel(t, n, r) {
+			let i = Math.exp(-t * pn);
+			e.onZoomAboutPoint(e.getZoom() * i, n, r);
+		}
+	};
+}
+//#endregion
+//#region src/fsm/tween.ts
+var _n = .6, vn = 10;
+function yn(e) {
+	if (e >= 1) return 1;
+	let t = 10 * Math.sqrt(1 - _n * _n), n = Math.exp(-.6 * 10 * e), r = _n * 10 / t;
+	return 1 - n * (Math.cos(t * e) + r * Math.sin(t * e));
+}
+var bn = {
+	linear: (e) => e,
+	"ease-in": (e) => e * e,
+	"ease-out": (e) => 1 - (1 - e) * (1 - e),
+	"critically-damped-overshoot": yn
+};
+function xn(e) {
+	return bn[e] ?? bn.linear;
+}
+var Sn = class {
+	constructor(e) {
+		this.startTime = 0, this.durationMs = 1, this.easing = bn.linear, this.startValue = e, this.targetValue = e;
+	}
+	retarget(e, t, n, r) {
+		this.startValue = this.valueAt(e), this.targetValue = t, this.startTime = e, this.durationMs = Math.max(n, 1), this.easing = xn(r);
+	}
+	valueAt(e) {
+		let t = Math.min(Math.max((e - this.startTime) / this.durationMs, 0), 1);
+		return this.startValue + (this.targetValue - this.startValue) * this.easing(t);
+	}
+	isSettled(e) {
+		return e - this.startTime >= this.durationMs;
+	}
+	snap(e) {
+		this.startValue = this.targetValue, this.startTime = e, this.durationMs = 1;
+	}
+};
+function Cn(e, t, n) {
+	return Math.min(Math.max(e, t), n);
+}
+function wn(e, t, n, r) {
+	let i = t - r - t * n, a = r;
+	return i > a ? (i + a) / 2 : Cn(e, i, a);
+}
+var Tn = class {
+	constructor(e, t, n = {}) {
+		this.timeSource = e, this.onFrame = t, this.canvasWidth = 0, this.canvasHeight = 0, this.zoomValue = 1, this.panXValue = 0, this.panYValue = 0, this.tween = null, this.stopTick = null, this.minZoom = n.minZoom ?? .25, this.maxZoom = n.maxZoom ?? 4, this.panMarginPx = n.panMarginPx ?? 100, this.zoomTweenDurationMs = n.zoomTweenDurationMs ?? 300;
+	}
+	get zoom() {
+		return this.zoomValue;
+	}
+	get pan() {
+		return {
+			x: this.panXValue,
+			y: this.panYValue
+		};
+	}
+	reset(e, t) {
+		this.canvasWidth = e, this.canvasHeight = t, this.tween = null, this.stopTick?.(), this.stopTick = null, this.zoomValue = 1, this.panXValue = 0, this.panYValue = 0, this.onFrame(this.currentTransform());
+	}
+	currentTransform() {
+		return {
+			zoom: this.zoomValue,
+			panX: this.panXValue,
+			panY: this.panYValue
+		};
+	}
+	clampZoom(e) {
+		return Cn(e, this.minZoom, this.maxZoom);
+	}
+	applyPanClamp() {
+		this.panXValue = wn(this.panXValue, this.canvasWidth, this.zoomValue, this.panMarginPx), this.panYValue = wn(this.panYValue, this.canvasHeight, this.zoomValue, this.panMarginPx);
+	}
+	setZoomImmediate(e) {
+		this.tween = null, this.stopTick?.(), this.stopTick = null, this.zoomValue = this.clampZoom(e), this.applyPanClamp(), this.onFrame(this.currentTransform());
+	}
+	setZoomAnimated(e, t = this.zoomTweenDurationMs) {
+		let n = this.clampZoom(e), r = this.timeSource.now(), i = new Sn(this.zoomValue);
+		i.retarget(r, n, t, "ease-out"), this.tween = i, this.ensureAnimating();
+	}
+	panBy(e, t) {
+		this.panXValue += e, this.panYValue += t, this.applyPanClamp(), this.onFrame(this.currentTransform());
+	}
+	zoomAboutPoint(e, t, n) {
+		this.tween = null, this.stopTick?.(), this.stopTick = null;
+		let r = this.zoomValue, i = this.clampZoom(e), a = i / r;
+		this.panXValue = t - (t - this.panXValue) * a, this.panYValue = n - (n - this.panYValue) * a, this.zoomValue = i, this.applyPanClamp(), this.onFrame(this.currentTransform());
+	}
+	ensureAnimating() {
+		this.stopTick || (this.stopTick = this.timeSource.onTick((e) => this.tickTween(e)));
+	}
+	tickTween(e) {
+		let t = this.tween;
+		if (!t) {
+			this.stopTick?.(), this.stopTick = null;
+			return;
+		}
+		this.zoomValue = t.valueAt(e), this.applyPanClamp(), this.onFrame(this.currentTransform()), t.isSettled(e) && (this.tween = null, this.stopTick?.(), this.stopTick = null);
+	}
+	snap() {
+		if (!this.tween) return;
+		let e = this.timeSource.now();
+		this.tween.snap(e), this.zoomValue = this.tween.valueAt(e), this.tween = null, this.stopTick?.(), this.stopTick = null, this.applyPanClamp(), this.onFrame(this.currentTransform());
+	}
+	destroy() {
+		this.stopTick?.(), this.stopTick = null, this.tween = null;
+	}
+};
+function En(e, t, n) {
+	return new Tn(e, t, n);
+}
+//#endregion
+//#region src/license/format.ts
+var Dn = "VSCADA";
+function On(e) {
+	try {
+		let t = e.replace(/-/g, "+").replace(/_/g, "/"), n = t + "=".repeat((4 - t.length % 4) % 4), r = atob(n), i = new Uint8Array(r.length);
+		for (let e = 0; e < r.length; e++) i[e] = r.charCodeAt(e);
+		return i;
+	} catch {
+		return null;
+	}
+}
+function kn(e) {
+	return typeof e == "object" && !!e && typeof e.company == "string" && typeof e.expiry == "string" && typeof e.tier == "string" && typeof e.keyId == "string";
+}
+function An(e) {
+	let t = e.split(".");
+	if (t.length !== 4 || t[0] !== Dn) return null;
+	let [, n, r, i] = t, a = On(r);
+	if (!a) return null;
+	let o;
+	try {
+		o = JSON.parse(new TextDecoder().decode(a));
+	} catch {
+		return null;
+	}
+	if (!kn(o)) return null;
+	let s = On(i);
+	return s ? {
+		version: n,
+		encodedPayload: r,
+		payload: o,
+		signature: s
+	} : null;
+}
+function jn(e, t) {
+	return new TextEncoder().encode(`${e}.${t}`);
+}
+//#endregion
+//#region src/license/vendor-keys.ts
+var Mn = {};
+//#endregion
+//#region src/license/verify-webcrypto.ts
+function Nn() {
+	return globalThis.crypto?.subtle !== void 0;
+}
+async function Pn(e, t, n) {
+	let r = globalThis.crypto?.subtle;
+	if (!r) return !1;
+	try {
+		let i = await r.importKey("jwk", n, {
+			name: "ECDSA",
+			namedCurve: "P-256"
+		}, !1, ["verify"]);
+		return await r.verify({
+			name: "ECDSA",
+			hash: "SHA-256"
+		}, i, t, e);
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js
+function Fn(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in e && e.BYTES_PER_ELEMENT === 1;
+}
+function M(e, t = "") {
+	if (typeof e != "number") {
+		let n = t && `"${t}" `;
+		throw TypeError(`${n}expected number, got ${typeof e}`);
+	}
+	if (!Number.isSafeInteger(e) || e < 0) {
+		let n = t && `"${t}" `;
+		throw RangeError(`${n}expected integer >= 0, got ${e}`);
+	}
+}
+function N(e, t, n = "") {
+	let r = Fn(e), i = e?.length, a = t !== void 0;
+	if (!r || a && i !== t) {
+		let o = n && `"${n}" `, s = a ? ` of length ${t}` : "", c = r ? `length=${i}` : `type=${typeof e}`, l = o + "expected Uint8Array" + s + ", got " + c;
+		throw r ? RangeError(l) : TypeError(l);
+	}
+	return e;
+}
+function In(e) {
+	if (typeof e != "function" || typeof e.create != "function") throw TypeError("Hash must wrapped by utils.createHasher");
+	if (M(e.outputLen), M(e.blockLen), e.outputLen < 1) throw Error("\"outputLen\" must be >= 1");
+	if (e.blockLen < 1) throw Error("\"blockLen\" must be >= 1");
+}
+function Ln(e, t = !0) {
+	if (e.destroyed) throw Error("Hash instance has been destroyed");
+	if (t && e.finished) throw Error("Hash#digest() has already been called");
+}
+function Rn(e, t) {
+	N(e, void 0, "digestInto() output");
+	let n = t.outputLen;
+	if (e.length < n) throw RangeError("\"digestInto() output\" expected to be of length >=" + n);
+}
+function zn(...e) {
+	for (let t = 0; t < e.length; t++) e[t].fill(0);
+}
+function Bn(e) {
+	return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function P(e, t) {
+	return e << 32 - t | e >>> t;
+}
+var Vn = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Hn = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function Un(e) {
+	if (N(e), Vn) return e.toHex();
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += Hn[e[n]];
+	return t;
+}
+var F = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function Wn(e) {
+	if (e >= F._0 && e <= F._9) return e - F._0;
+	if (e >= F.A && e <= F.F) return e - (F.A - 10);
+	if (e >= F.a && e <= F.f) return e - (F.a - 10);
+}
+function Gn(e) {
+	if (typeof e != "string") throw TypeError("hex string expected, got " + typeof e);
+	if (Vn) try {
+		return Uint8Array.fromHex(e);
+	} catch (e) {
+		throw e instanceof SyntaxError ? RangeError(e.message) : e;
+	}
+	let t = e.length, n = t / 2;
+	if (t % 2) throw RangeError("hex string expected, got unpadded hex of length " + t);
+	let r = new Uint8Array(n);
+	for (let t = 0, i = 0; t < n; t++, i += 2) {
+		let n = Wn(e.charCodeAt(i)), a = Wn(e.charCodeAt(i + 1));
+		if (n === void 0 || a === void 0) {
+			let t = e[i] + e[i + 1];
+			throw RangeError("hex string expected, got non-hex character \"" + t + "\" at index " + i);
+		}
+		r[t] = n * 16 + a;
+	}
+	return r;
+}
+function Kn(...e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		N(r), t += r.length;
+	}
+	let n = new Uint8Array(t);
+	for (let t = 0, r = 0; t < e.length; t++) {
+		let i = e[t];
+		n.set(i, r), r += i.length;
+	}
+	return n;
+}
+function qn(e, t = {}) {
+	let n = (t, n) => e(n).update(t).digest(), r = e(void 0);
+	return n.outputLen = r.outputLen, n.blockLen = r.blockLen, n.canXOF = r.canXOF, n.create = (t) => e(t), Object.assign(n, t), Object.freeze(n);
+}
+function Jn(e = 32) {
+	M(e, "bytesLength");
+	let t = typeof globalThis == "object" ? globalThis.crypto : null;
+	if (typeof t?.getRandomValues != "function") throw Error("crypto.getRandomValues must be defined");
+	if (e > 65536) throw RangeError(`"bytesLength" expected <= 65536, got ${e}`);
+	return t.getRandomValues(new Uint8Array(e));
+}
+var Yn = (e) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	e
+]) });
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/typeof.js
+function I(e) {
+	"@babel/helpers - typeof";
+	return I = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+		return typeof e;
+	} : function(e) {
+		return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+	}, I(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPrimitive.js
+function Xn(e, t) {
+	if (I(e) != "object" || !e) return e;
+	var n = e[Symbol.toPrimitive];
+	if (n !== void 0) {
+		var r = n.call(e, t || "default");
+		if (I(r) != "object") return r;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (t === "string" ? String : Number)(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/toPropertyKey.js
+function Zn(e) {
+	var t = Xn(e, "string");
+	return I(t) == "symbol" ? t : t + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/defineProperty.js
+function L(e, t, n) {
+	return (t = Zn(t)) in e ? Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[t] = n, e;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/_md.js
+function Qn(e, t, n) {
+	return e & t ^ ~e & n;
+}
+function $n(e, t, n) {
+	return e & t ^ e & n ^ t & n;
+}
+var er = class {
+	constructor(e, t, n, r) {
+		L(this, "blockLen", void 0), L(this, "outputLen", void 0), L(this, "canXOF", !1), L(this, "padOffset", void 0), L(this, "isLE", void 0), L(this, "buffer", void 0), L(this, "view", void 0), L(this, "finished", !1), L(this, "length", 0), L(this, "pos", 0), L(this, "destroyed", !1), this.blockLen = e, this.outputLen = t, this.padOffset = n, this.isLE = r, this.buffer = new Uint8Array(e), this.view = Bn(this.buffer);
+	}
+	update(e) {
+		Ln(this), N(e);
+		let { view: t, buffer: n, blockLen: r } = this, i = e.length;
+		for (let a = 0; a < i;) {
+			let o = Math.min(r - this.pos, i - a);
+			if (o === r) {
+				let t = Bn(e);
+				for (; r <= i - a; a += r) this.process(t, a);
+				continue;
+			}
+			n.set(e.subarray(a, a + o), this.pos), this.pos += o, a += o, this.pos === r && (this.process(t, 0), this.pos = 0);
+		}
+		return this.length += e.length, this.roundClean(), this;
+	}
+	digestInto(e) {
+		Ln(this), Rn(e, this), this.finished = !0;
+		let { buffer: t, view: n, blockLen: r, isLE: i } = this, { pos: a } = this;
+		t[a++] = 128, zn(this.buffer.subarray(a)), this.padOffset > r - a && (this.process(n, 0), a = 0);
+		for (let e = a; e < r; e++) t[e] = 0;
+		n.setBigUint64(r - 8, BigInt(this.length * 8), i), this.process(n, 0);
+		let o = Bn(e), s = this.outputLen;
+		if (s % 4) throw Error("_sha2: outputLen must be aligned to 32bit");
+		let c = s / 4, l = this.get();
+		if (c > l.length) throw Error("_sha2: outputLen bigger than state");
+		for (let e = 0; e < c; e++) o.setUint32(4 * e, l[e], i);
+	}
+	digest() {
+		let { buffer: e, outputLen: t } = this;
+		this.digestInto(e);
+		let n = e.slice(0, t);
+		return this.destroy(), n;
+	}
+	_cloneInto(e) {
+		e || (e = new this.constructor()), e.set(...this.get());
+		let { blockLen: t, buffer: n, length: r, finished: i, destroyed: a, pos: o } = this;
+		return e.destroyed = a, e.finished = i, e.length = r, e.pos = o, r % t && e.buffer.set(n), e;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+}, R = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]), tr = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]), z = /* @__PURE__ */ new Uint32Array(64), nr = class extends er {
+	constructor(e) {
+		super(64, e, 8, !1);
+	}
+	get() {
+		let { A: e, B: t, C: n, D: r, E: i, F: a, G: o, H: s } = this;
+		return [
+			e,
+			t,
+			n,
+			r,
+			i,
+			a,
+			o,
+			s
+		];
+	}
+	set(e, t, n, r, i, a, o, s) {
+		this.A = e | 0, this.B = t | 0, this.C = n | 0, this.D = r | 0, this.E = i | 0, this.F = a | 0, this.G = o | 0, this.H = s | 0;
+	}
+	process(e, t) {
+		for (let n = 0; n < 16; n++, t += 4) z[n] = e.getUint32(t, !1);
+		for (let e = 16; e < 64; e++) {
+			let t = z[e - 15], n = z[e - 2], r = P(t, 7) ^ P(t, 18) ^ t >>> 3;
+			z[e] = (P(n, 17) ^ P(n, 19) ^ n >>> 10) + z[e - 7] + r + z[e - 16] | 0;
+		}
+		let { A: n, B: r, C: i, D: a, E: o, F: s, G: c, H: l } = this;
+		for (let e = 0; e < 64; e++) {
+			let t = P(o, 6) ^ P(o, 11) ^ P(o, 25), u = l + t + Qn(o, s, c) + tr[e] + z[e] | 0, d = (P(n, 2) ^ P(n, 13) ^ P(n, 22)) + $n(n, r, i) | 0;
+			l = c, c = s, s = o, o = a + u | 0, a = i, i = r, r = n, n = u + d | 0;
+		}
+		n = n + this.A | 0, r = r + this.B | 0, i = i + this.C | 0, a = a + this.D | 0, o = o + this.E | 0, s = s + this.F | 0, c = c + this.G | 0, l = l + this.H | 0, this.set(n, r, i, a, o, s, c, l);
+	}
+	roundClean() {
+		zn(z);
+	}
+	destroy() {
+		this.destroyed = !0, this.set(0, 0, 0, 0, 0, 0, 0, 0), zn(this.buffer);
+	}
+}, rr = class extends nr {
+	constructor() {
+		super(32), L(this, "A", R[0] | 0), L(this, "B", R[1] | 0), L(this, "C", R[2] | 0), L(this, "D", R[3] | 0), L(this, "E", R[4] | 0), L(this, "F", R[5] | 0), L(this, "G", R[6] | 0), L(this, "H", R[7] | 0);
+	}
+}, ir = /* @__PURE__ */ qn(() => new rr(), /* @__PURE__ */ Yn(1)), B = (e, t, n) => N(e, t, n), ar = M, or = Un, V = (...e) => Kn(...e), sr = (e) => Gn(e), cr = Fn, lr = (e) => Jn(e), ur = /* @__PURE__ */ BigInt(0), dr = /* @__PURE__ */ BigInt(1);
+function H(e, t = "") {
+	if (typeof e != "boolean") {
+		let n = t && `"${t}" `;
+		throw TypeError(n + "expected boolean, got type=" + typeof e);
+	}
+	return e;
+}
+function fr(e) {
+	if (typeof e == "bigint") {
+		if (!xr(e)) throw RangeError("positive bigint expected, got " + e);
+	} else ar(e);
+	return e;
+}
+function pr(e, t = "") {
+	if (typeof e != "number") {
+		let n = t && `"${t}" `;
+		throw TypeError(n + "expected number, got type=" + typeof e);
+	}
+	if (!Number.isSafeInteger(e)) {
+		let n = t && `"${t}" `;
+		throw RangeError(n + "expected safe integer, got " + e);
+	}
+}
+function mr(e) {
+	let t = fr(e).toString(16);
+	return t.length & 1 ? "0" + t : t;
+}
+function hr(e) {
+	if (typeof e != "string") throw TypeError("hex string expected, got " + typeof e);
+	return e === "" ? ur : BigInt("0x" + e);
+}
+function gr(e) {
+	return hr(Un(e));
+}
+function _r(e) {
+	return hr(Un(br(N(e)).reverse()));
+}
+function vr(e, t) {
+	if (M(t), t === 0) throw RangeError("zero length");
+	e = fr(e);
+	let n = e.toString(16);
+	if (n.length > t * 2) throw RangeError("number too large");
+	return Gn(n.padStart(t * 2, "0"));
+}
+function yr(e, t) {
+	return vr(e, t).reverse();
+}
+function br(e) {
+	return Uint8Array.from(B(e));
+}
+var xr = (e) => typeof e == "bigint" && ur <= e;
+function Sr(e, t, n) {
+	return xr(e) && xr(t) && xr(n) && t <= e && e < n;
+}
+function Cr(e, t, n, r) {
+	if (!Sr(t, n, r)) throw RangeError("expected valid " + e + ": " + n + " <= n < " + r + ", got " + t);
+}
+function wr(e) {
+	if (e < ur) throw Error("expected non-negative bigint, got " + e);
+	let t;
+	for (t = 0; e > ur; e >>= dr, t += 1);
+	return t;
+}
+var Tr = (e) => (dr << BigInt(e)) - dr;
+function Er(e, t, n) {
+	if (M(e, "hashLen"), M(t, "qByteLen"), typeof n != "function") throw TypeError("hmacFn must be a function");
+	let r = (e) => new Uint8Array(e), i = Uint8Array.of(), a = Uint8Array.of(0), o = Uint8Array.of(1), s = r(e), c = r(e), l = 0, u = () => {
+		s.fill(1), c.fill(0), l = 0;
+	}, d = (...e) => n(c, V(s, ...e)), f = (e = i) => {
+		c = d(a, e), s = d(), e.length !== 0 && (c = d(o, e), s = d());
+	}, p = () => {
+		if (l++ >= 1e3) throw Error("drbg: tried max amount of iterations");
+		let e = 0, n = [];
+		for (; e < t;) {
+			s = d();
+			let t = s.slice();
+			n.push(t), e += s.length;
+		}
+		return V(...n);
+	};
+	return (e, t) => {
+		u(), f(e);
+		let n;
+		for (; (n = t(p())) === void 0;) f();
+		return u(), n;
+	};
+}
+function Dr(e, t = {}, n = {}) {
+	if (Object.prototype.toString.call(e) !== "[object Object]") throw TypeError("expected valid options object");
+	function r(t, n, r) {
+		if (!r && n !== "function" && !Object.hasOwn(e, t)) throw TypeError(`param "${t}" is invalid: expected own property`);
+		let i = e[t];
+		if (r && i === void 0) return;
+		let a = typeof i;
+		if (a !== n || i === null) throw TypeError(`param "${t}" is invalid: expected ${n}, got ${a}`);
+	}
+	let i = (e, t) => Object.entries(e).forEach(([e, n]) => r(e, n, t));
+	i(t, !1), i(n, !0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/modular.js
+var U = /* @__PURE__ */ BigInt(0), W = /* @__PURE__ */ BigInt(1), G = /* @__PURE__ */ BigInt(2), Or = /* @__PURE__ */ BigInt(3), kr = /* @__PURE__ */ BigInt(4), Ar = /* @__PURE__ */ BigInt(5), jr = /* @__PURE__ */ BigInt(7), Mr = /* @__PURE__ */ BigInt(8), Nr = /* @__PURE__ */ BigInt(9), Pr = /* @__PURE__ */ BigInt(16);
+function K(e, t) {
+	if (t <= U) throw Error("mod: expected positive modulus, got " + t);
+	let n = e % t;
+	return n >= U ? n : t + n;
+}
+function Fr(e, t) {
+	if (e === U) throw Error("invert: expected non-zero number");
+	if (t <= U) throw Error("invert: expected positive modulus, got " + t);
+	let n = K(e, t), r = t, i = U, a = W, o = W, s = U;
+	for (; n !== U;) {
+		let e = r / n, t = r - n * e, c = i - o * e, l = a - s * e;
+		r = n, n = t, i = o, a = s, o = c, s = l;
+	}
+	if (r !== W) throw Error("invert: does not exist");
+	return K(i, t);
+}
+function Ir(e, t, n) {
+	let r = e;
+	if (!r.eql(r.sqr(t), n)) throw Error("Cannot find square root");
+}
+function Lr(e, t) {
+	let n = e, r = (n.ORDER + W) / kr, i = n.pow(t, r);
+	return Ir(n, i, t), i;
+}
+function Rr(e, t) {
+	let n = e, r = (n.ORDER - Ar) / Mr, i = n.mul(t, G), a = n.pow(i, r), o = n.mul(t, a), s = n.mul(n.mul(o, G), a), c = n.mul(o, n.sub(s, n.ONE));
+	return Ir(n, c, t), c;
+}
+function zr(e) {
+	let t = Xr(e), n = Br(e), r = n(t, t.neg(t.ONE)), i = n(t, r), a = n(t, t.neg(r)), o = (e + jr) / Pr;
+	return ((e, t) => {
+		let n = e, s = n.pow(t, o), c = n.mul(s, r), l = n.mul(s, i), u = n.mul(s, a), d = n.eql(n.sqr(c), t), f = n.eql(n.sqr(l), t);
+		s = n.cmov(s, c, d), c = n.cmov(u, l, f);
+		let p = n.eql(n.sqr(c), t), m = n.cmov(s, c, p);
+		return Ir(n, m, t), m;
+	});
+}
+function Br(e) {
+	if (e < Or) throw Error("sqrt is not defined for small field");
+	let t = e - W, n = 0;
+	for (; t % G === U;) t /= G, n++;
+	let r = G, i = Xr(e);
+	for (; Kr(i, r) === 1;) if (r++ > 1e3) throw Error("Cannot find square root: probably non-prime P");
+	if (n === 1) return Lr;
+	let a = i.pow(r, t), o = (t + W) / G;
+	return function(e, r) {
+		let i = e;
+		if (i.is0(r)) return r;
+		if (Kr(i, r) !== 1) throw Error("Cannot find square root");
+		let s = n, c = i.mul(i.ONE, a), l = i.pow(r, t), u = i.pow(r, o);
+		for (; !i.eql(l, i.ONE);) {
+			if (i.is0(l)) return i.ZERO;
+			let e = 1, t = i.sqr(l);
+			for (; !i.eql(t, i.ONE);) if (e++, t = i.sqr(t), e === s) throw Error("Cannot find square root");
+			let n = W << BigInt(s - e - 1), r = i.pow(c, n);
+			s = e, c = i.sqr(r), l = i.mul(l, c), u = i.mul(u, r);
+		}
+		return u;
+	};
+}
+function Vr(e) {
+	return e % kr === Or ? Lr : e % Mr === Ar ? Rr : e % Pr === Nr ? zr(e) : Br(e);
+}
+var Hr = [
+	"create",
+	"isValid",
+	"is0",
+	"neg",
+	"inv",
+	"sqrt",
+	"sqr",
+	"eql",
+	"add",
+	"sub",
+	"mul",
+	"pow",
+	"div",
+	"addN",
+	"subN",
+	"mulN",
+	"sqrN"
+];
+function Ur(e) {
+	if (Dr(e, Hr.reduce((e, t) => (e[t] = "function", e), {
+		ORDER: "bigint",
+		BYTES: "number",
+		BITS: "number"
+	})), pr(e.BYTES, "BYTES"), pr(e.BITS, "BITS"), e.BYTES < 1 || e.BITS < 1) throw Error("invalid field: expected BYTES/BITS > 0");
+	if (e.ORDER <= W) throw Error("invalid field: expected ORDER > 1, got " + e.ORDER);
+	return e;
+}
+function Wr(e, t, n) {
+	let r = e;
+	if (n < U) throw Error("invalid exponent, negatives unsupported");
+	if (n === U) return r.ONE;
+	if (n === W) return t;
+	let i = r.ONE, a = t;
+	for (; n > U;) n & W && (i = r.mul(i, a)), a = r.sqr(a), n >>= W;
+	return i;
+}
+function Gr(e, t, n = !1) {
+	let r = e, i = Array(t.length).fill(n ? r.ZERO : void 0), a = t.reduce((e, t, n) => r.is0(t) ? e : (i[n] = e, r.mul(e, t)), r.ONE), o = r.inv(a);
+	return t.reduceRight((e, t, n) => r.is0(t) ? e : (i[n] = r.mul(e, i[n]), r.mul(e, t)), o), i;
+}
+function Kr(e, t) {
+	let n = e, r = (n.ORDER - W) / G, i = n.pow(t, r), a = n.eql(i, n.ONE), o = n.eql(i, n.ZERO), s = n.eql(i, n.neg(n.ONE));
+	if (!a && !o && !s) throw Error("invalid Legendre symbol result");
+	return a ? 1 : o ? 0 : -1;
+}
+function qr(e, t) {
+	if (t !== void 0 && ar(t), e <= U) throw Error("invalid n length: expected positive n, got " + e);
+	if (t !== void 0 && t < 1) throw Error("invalid n length: expected positive bit length, got " + t);
+	let n = wr(e);
+	if (t !== void 0 && t < n) throw Error(`invalid n length: expected bit length (${n}) >= n.length (${t})`);
+	let r = t === void 0 ? n : t;
+	return {
+		nBitLength: r,
+		nByteLength: Math.ceil(r / 8)
+	};
+}
+var Jr = /* @__PURE__ */ new WeakMap(), Yr = class {
+	constructor(e, t = {}) {
+		if (L(this, "ORDER", void 0), L(this, "BITS", void 0), L(this, "BYTES", void 0), L(this, "isLE", void 0), L(this, "ZERO", U), L(this, "ONE", W), L(this, "_lengths", void 0), L(this, "_mod", void 0), e <= W) throw Error("invalid field: expected ORDER > 1, got " + e);
+		let n;
+		this.isLE = !1, typeof t == "object" && t && (typeof t.BITS == "number" && (n = t.BITS), typeof t.sqrt == "function" && Object.defineProperty(this, "sqrt", {
+			value: t.sqrt,
+			enumerable: !0
+		}), typeof t.isLE == "boolean" && (this.isLE = t.isLE), t.allowedLengths && (this._lengths = Object.freeze(t.allowedLengths.slice())), typeof t.modFromBytes == "boolean" && (this._mod = t.modFromBytes));
+		let { nBitLength: r, nByteLength: i } = qr(e, n);
+		if (i > 2048) throw Error("invalid field: expected ORDER of <= 2048 bytes");
+		this.ORDER = e, this.BITS = r, this.BYTES = i, Object.freeze(this);
+	}
+	create(e) {
+		return K(e, this.ORDER);
+	}
+	isValid(e) {
+		if (typeof e != "bigint") throw TypeError("invalid field element: expected bigint, got " + typeof e);
+		return U <= e && e < this.ORDER;
+	}
+	is0(e) {
+		return e === U;
+	}
+	isValidNot0(e) {
+		return !this.is0(e) && this.isValid(e);
+	}
+	isOdd(e) {
+		return (e & W) === W;
+	}
+	neg(e) {
+		return K(-e, this.ORDER);
+	}
+	eql(e, t) {
+		return e === t;
+	}
+	sqr(e) {
+		return K(e * e, this.ORDER);
+	}
+	add(e, t) {
+		return K(e + t, this.ORDER);
+	}
+	sub(e, t) {
+		return K(e - t, this.ORDER);
+	}
+	mul(e, t) {
+		return K(e * t, this.ORDER);
+	}
+	pow(e, t) {
+		return Wr(this, e, t);
+	}
+	div(e, t) {
+		return K(e * Fr(t, this.ORDER), this.ORDER);
+	}
+	sqrN(e) {
+		return e * e;
+	}
+	addN(e, t) {
+		return e + t;
+	}
+	subN(e, t) {
+		return e - t;
+	}
+	mulN(e, t) {
+		return e * t;
+	}
+	inv(e) {
+		return Fr(e, this.ORDER);
+	}
+	sqrt(e) {
+		let t = Jr.get(this);
+		return t || Jr.set(this, t = Vr(this.ORDER)), t(this, e);
+	}
+	toBytes(e) {
+		return this.isLE ? yr(e, this.BYTES) : vr(e, this.BYTES);
+	}
+	fromBytes(e, t = !1) {
+		B(e);
+		let { _lengths: n, BYTES: r, isLE: i, ORDER: a, _mod: o } = this;
+		if (n) {
+			if (e.length < 1 || !n.includes(e.length) || e.length > r) throw Error("Field.fromBytes: expected " + n + " bytes, got " + e.length);
+			let t = new Uint8Array(r);
+			t.set(e, i ? 0 : t.length - e.length), e = t;
+		}
+		if (e.length !== r) throw Error("Field.fromBytes: expected " + r + " bytes, got " + e.length);
+		let s = i ? _r(e) : gr(e);
+		if (o && (s = K(s, a)), !t && !this.isValid(s)) throw Error("invalid field element: outside of range 0..ORDER");
+		return s;
+	}
+	invertBatch(e) {
+		return Gr(this, e);
+	}
+	cmov(e, t, n) {
+		return H(n, "condition"), n ? t : e;
+	}
+};
+Object.freeze(Yr.prototype);
+function Xr(e, t = {}) {
+	return new Yr(e, t);
+}
+function Zr(e) {
+	if (typeof e != "bigint") throw Error("field order must be bigint");
+	if (e <= W) throw Error("field order must be greater than 1");
+	let t = wr(e - W);
+	return Math.ceil(t / 8);
+}
+function Qr(e) {
+	let t = Zr(e);
+	return t + Math.ceil(t / 2);
+}
+function $r(e, t, n = !1) {
+	B(e);
+	let r = e.length, i = Zr(t), a = Math.max(Qr(t), 16);
+	if (r < a || r > 1024) throw Error("expected " + a + "-1024 bytes of input, got " + r);
+	let o = K(n ? _r(e) : gr(e), t - W) + W;
+	return n ? yr(o, i) : vr(o, i);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/curve.js
+var q = /* @__PURE__ */ BigInt(0), J = /* @__PURE__ */ BigInt(1);
+function ei(e, t) {
+	let n = t.negate();
+	return e ? n : t;
+}
+function ti(e, t) {
+	let n = Gr(e.Fp, t.map((e) => e.Z));
+	return t.map((t, r) => e.fromAffine(t.toAffine(n[r])));
+}
+function ni(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0 || e > t) throw Error("invalid window size, expected [1.." + t + "], got W=" + e);
+}
+function ri(e, t) {
+	ni(e, t);
+	let n = Math.ceil(t / e) + 1, r = 2 ** (e - 1), i = 2 ** e;
+	return {
+		windows: n,
+		windowSize: r,
+		mask: Tr(e),
+		maxNumber: i,
+		shiftBy: BigInt(e)
+	};
+}
+function ii(e, t, n) {
+	let { windowSize: r, mask: i, maxNumber: a, shiftBy: o } = n, s = Number(e & i), c = e >> o;
+	s > r && (s -= a, c += J);
+	let l = t * r, u = l + Math.abs(s) - 1, d = s === 0, f = s < 0, p = t % 2 != 0;
+	return {
+		nextN: c,
+		offset: u,
+		isZero: d,
+		isNeg: f,
+		isNegF: p,
+		offsetF: l
+	};
+}
+var ai = /* @__PURE__ */ new WeakMap(), oi = /* @__PURE__ */ new WeakMap();
+function si(e) {
+	return oi.get(e) || 1;
+}
+function ci(e) {
+	if (e !== q) throw Error("invalid wNAF");
+}
+var li = class {
+	constructor(e, t) {
+		L(this, "BASE", void 0), L(this, "ZERO", void 0), L(this, "Fn", void 0), L(this, "bits", void 0), this.BASE = e.BASE, this.ZERO = e.ZERO, this.Fn = e.Fn, this.bits = t;
+	}
+	_unsafeLadder(e, t, n = this.ZERO) {
+		let r = e;
+		for (; t > q;) t & J && (n = n.add(r)), r = r.double(), t >>= J;
+		return n;
+	}
+	precomputeWindow(e, t) {
+		let { windows: n, windowSize: r } = ri(t, this.bits), i = [], a = e, o = a;
+		for (let e = 0; e < n; e++) {
+			o = a, i.push(o);
+			for (let e = 1; e < r; e++) o = o.add(a), i.push(o);
+			a = o.double();
+		}
+		return i;
+	}
+	wNAF(e, t, n) {
+		if (!this.Fn.isValid(n)) throw Error("invalid scalar");
+		let r = this.ZERO, i = this.BASE, a = ri(e, this.bits);
+		for (let e = 0; e < a.windows; e++) {
+			let { nextN: o, offset: s, isZero: c, isNeg: l, isNegF: u, offsetF: d } = ii(n, e, a);
+			n = o, c ? i = i.add(ei(u, t[d])) : r = r.add(ei(l, t[s]));
+		}
+		return ci(n), {
+			p: r,
+			f: i
+		};
+	}
+	wNAFUnsafe(e, t, n, r = this.ZERO) {
+		let i = ri(e, this.bits);
+		for (let e = 0; e < i.windows && n !== q; e++) {
+			let { nextN: a, offset: o, isZero: s, isNeg: c } = ii(n, e, i);
+			if (n = a, !s) {
+				let e = t[o];
+				r = r.add(c ? e.negate() : e);
+			}
+		}
+		return ci(n), r;
+	}
+	getPrecomputes(e, t, n) {
+		let r = ai.get(t);
+		return r || (r = this.precomputeWindow(t, e), e !== 1 && (typeof n == "function" && (r = n(r)), ai.set(t, r))), r;
+	}
+	cached(e, t, n) {
+		let r = si(e);
+		return this.wNAF(r, this.getPrecomputes(r, e, n), t);
+	}
+	unsafe(e, t, n, r) {
+		let i = si(e);
+		return i === 1 ? this._unsafeLadder(e, t, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, e, n), t, r);
+	}
+	createCache(e, t) {
+		ni(t, this.bits), oi.set(e, t), ai.delete(e);
+	}
+	hasCache(e) {
+		return si(e) !== 1;
+	}
+};
+function ui(e, t, n, r) {
+	let i = t, a = e.ZERO, o = e.ZERO;
+	for (; n > q || r > q;) n & J && (a = a.add(i)), r & J && (o = o.add(i)), i = i.double(), n >>= J, r >>= J;
+	return {
+		p1: a,
+		p2: o
+	};
+}
+function di(e, t, n) {
+	if (t) {
+		if (t.ORDER !== e) throw Error("Field.ORDER must match order: Fp == p, Fn == n");
+		return Ur(t), t;
+	} else return Xr(e, { isLE: n });
+}
+function fi(e, t, n = {}, r) {
+	if (r === void 0 && (r = e === "edwards"), !t || typeof t != "object") throw Error(`expected valid ${e} CURVE object`);
+	for (let e of [
+		"p",
+		"n",
+		"h"
+	]) {
+		let n = t[e];
+		if (!(typeof n == "bigint" && n > q)) throw Error(`CURVE.${e} must be positive bigint`);
+	}
+	let i = di(t.p, n.Fp, r), a = di(t.n, n.Fn, r), o = [
+		"Gx",
+		"Gy",
+		"a",
+		e === "weierstrass" ? "b" : "d"
+	];
+	for (let e of o) if (!i.isValid(t[e])) throw Error(`CURVE.${e} must be valid field element of CURVE.Fp`);
+	return t = Object.freeze(Object.assign({}, t)), {
+		CURVE: t,
+		Fp: i,
+		Fn: a
+	};
+}
+function pi(e, t) {
+	return function(n) {
+		let r = e(n);
+		return {
+			secretKey: r,
+			publicKey: t(r)
+		};
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/hmac.js
+var mi = class {
+	constructor(e, t) {
+		if (L(this, "oHash", void 0), L(this, "iHash", void 0), L(this, "blockLen", void 0), L(this, "outputLen", void 0), L(this, "canXOF", !1), L(this, "finished", !1), L(this, "destroyed", !1), In(e), N(t, void 0, "key"), this.iHash = e.create(), typeof this.iHash.update != "function") throw Error("Expected instance of class which extends utils.Hash");
+		this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+		let n = this.blockLen, r = new Uint8Array(n);
+		r.set(t.length > n ? e.create().update(t).digest() : t);
+		for (let e = 0; e < r.length; e++) r[e] ^= 54;
+		this.iHash.update(r), this.oHash = e.create();
+		for (let e = 0; e < r.length; e++) r[e] ^= 106;
+		this.oHash.update(r), zn(r);
+	}
+	update(e) {
+		return Ln(this), this.iHash.update(e), this;
+	}
+	digestInto(e) {
+		Ln(this), Rn(e, this), this.finished = !0;
+		let t = e.subarray(0, this.outputLen);
+		this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+	}
+	digest() {
+		let e = new Uint8Array(this.oHash.outputLen);
+		return this.digestInto(e), e;
+	}
+	_cloneInto(e) {
+		e || (e = Object.create(Object.getPrototypeOf(this), {}));
+		let { oHash: t, iHash: n, finished: r, destroyed: i, blockLen: a, outputLen: o } = this;
+		return e = e, e.finished = r, e.destroyed = i, e.blockLen = a, e.outputLen = o, e.oHash = t._cloneInto(e.oHash), e.iHash = n._cloneInto(e.iHash), e;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	destroy() {
+		this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+	}
+}, hi = /* @__PURE__ */ (() => {
+	let e = ((e, t, n) => new mi(e, t).update(n).digest());
+	return e.create = (e, t) => new mi(e, t), e;
+})(), gi = (e, t) => (e + (e >= 0 ? t : -t) / bi) / t;
+function _i(e, t, n) {
+	Cr("scalar", e, X, n);
+	let [[r, i], [a, o]] = t, s = gi(o * e, n), c = gi(-i * e, n), l = e - s * r - c * a, u = -s * i - c * o, d = l < X, f = u < X;
+	d && (l = -l), f && (u = -u);
+	let p = Tr(Math.ceil(wr(n) / 2)) + Z;
+	if (l < X || l >= p || u < X || u >= p) throw Error("splitScalar (endomorphism): failed for k");
+	return {
+		k1neg: d,
+		k1: l,
+		k2neg: f,
+		k2: u
+	};
+}
+function vi(e) {
+	if (![
+		"compact",
+		"recovered",
+		"der"
+	].includes(e)) throw Error("Signature format must be \"compact\", \"recovered\", or \"der\"");
+	return e;
+}
+function yi(e, t) {
+	Dr(e);
+	let n = {};
+	for (let r of Object.keys(t)) n[r] = e[r] === void 0 ? t[r] : e[r];
+	return H(n.lowS, "lowS"), H(n.prehash, "prehash"), n.format !== void 0 && vi(n.format), n;
+}
+var Y = {
+	Err: class extends Error {
+		constructor(e = "") {
+			super(e);
+		}
+	},
+	_tlv: {
+		encode: (e, t) => {
+			let { Err: n } = Y;
+			if (pr(e, "tag"), e < 0 || e > 255) throw new n("tlv.encode: wrong tag");
+			if (typeof t != "string") throw TypeError("\"data\" expected string, got type=" + typeof t);
+			if (t.length & 1) throw new n("tlv.encode: unpadded data");
+			let r = t.length / 2, i = mr(r);
+			if (i.length / 2 & 128) throw new n("tlv.encode: long form length too big");
+			let a = r > 127 ? mr(i.length / 2 | 128) : "";
+			return mr(e) + a + i + t;
+		},
+		decode(e, t) {
+			let { Err: n } = Y;
+			t = B(t, void 0, "DER data");
+			let r = 0;
+			if (e < 0 || e > 255) throw new n("tlv.encode: wrong tag");
+			if (t.length < 2 || t[r++] !== e) throw new n("tlv.decode: wrong tlv");
+			let i = t[r++], a = !!(i & 128), o = 0;
+			if (!a) o = i;
+			else {
+				let e = i & 127;
+				if (!e) throw new n("tlv.decode(long): indefinite length not supported");
+				if (e > 4) throw new n("tlv.decode(long): byte length is too big");
+				let a = t.subarray(r, r + e);
+				if (a.length !== e) throw new n("tlv.decode: length bytes not complete");
+				if (a[0] === 0) throw new n("tlv.decode(long): zero leftmost byte");
+				for (let e of a) o = o << 8 | e;
+				if (r += e, o < 128) throw new n("tlv.decode(long): not minimal encoding");
+			}
+			let s = t.subarray(r, r + o);
+			if (s.length !== o) throw new n("tlv.decode: wrong value length");
+			return {
+				v: s,
+				l: t.subarray(r + o)
+			};
+		}
+	},
+	_int: {
+		encode(e) {
+			let { Err: t } = Y;
+			if (fr(e), e < X) throw new t("integer: negative integers are not allowed");
+			let n = mr(e);
+			if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1) throw new t("unexpected DER parsing assertion: unpadded hex");
+			return n;
+		},
+		decode(e) {
+			let { Err: t } = Y;
+			if (e.length < 1) throw new t("invalid signature integer: empty");
+			if (e[0] & 128) throw new t("invalid signature integer: negative");
+			if (e.length > 1 && e[0] === 0 && !(e[1] & 128)) throw new t("invalid signature integer: unnecessary leading zero");
+			return gr(e);
+		}
+	},
+	toSig(e) {
+		let { Err: t, _int: n, _tlv: r } = Y, i = B(e, void 0, "signature"), { v: a, l: o } = r.decode(48, i);
+		if (o.length) throw new t("invalid signature: left bytes after parsing");
+		let { v: s, l: c } = r.decode(2, a), { v: l, l: u } = r.decode(2, c);
+		if (u.length) throw new t("invalid signature: left bytes after parsing");
+		return {
+			r: n.decode(s),
+			s: n.decode(l)
+		};
+	},
+	hexFromSig(e) {
+		let { _tlv: t, _int: n } = Y, r = t.encode(2, n.encode(e.r)) + t.encode(2, n.encode(e.s));
+		return t.encode(48, r);
+	}
+};
+Object.freeze(Y._tlv), Object.freeze(Y._int), Object.freeze(Y);
+var X = /* @__PURE__ */ BigInt(0), Z = /* @__PURE__ */ BigInt(1), bi = /* @__PURE__ */ BigInt(2), xi = /* @__PURE__ */ BigInt(3), Si = /* @__PURE__ */ BigInt(4);
+function Ci(e, t = {}) {
+	var n;
+	let r = fi("weierstrass", e, t), i = r.Fp, a = r.Fn, o = r.CURVE, { h: s, n: c } = o;
+	Dr(t, {}, {
+		allowInfinityPoint: "boolean",
+		clearCofactor: "function",
+		isTorsionFree: "function",
+		fromBytes: "function",
+		toBytes: "function",
+		endo: "object"
+	});
+	let { endo: l, allowInfinityPoint: u } = t;
+	if (l && (!i.is0(o.a) || typeof l.beta != "bigint" || !Array.isArray(l.basises))) throw Error("invalid endo: expected \"beta\": bigint and \"basises\": array");
+	let d = Ti(i, a);
+	function f() {
+		if (!i.isOdd) throw Error("compression is not supported: Field does not have .isOdd()");
+	}
+	function p(e, t, n) {
+		if (u && t.is0()) return Uint8Array.of(0);
+		let { x: r, y: a } = t.toAffine(), o = i.toBytes(r);
+		return H(n, "isCompressed"), n ? (f(), V(wi(!i.isOdd(a)), o)) : V(Uint8Array.of(4), o, i.toBytes(a));
+	}
+	function m(e) {
+		B(e, void 0, "Point");
+		let { publicKey: t, publicKeyUncompressed: n } = d, r = e.length, a = e[0], o = e.subarray(1);
+		if (u && r === 1 && a === 0) return {
+			x: i.ZERO,
+			y: i.ZERO
+		};
+		if (r === t && (a === 2 || a === 3)) {
+			let e = i.fromBytes(o);
+			if (!i.isValid(e)) throw Error("bad point: is not on curve, wrong x");
+			let t = _(e), n;
+			try {
+				n = i.sqrt(t);
+			} catch (e) {
+				let t = e instanceof Error ? ": " + e.message : "";
+				throw Error("bad point: is not on curve, sqrt error" + t);
+			}
+			f();
+			let r = i.isOdd(n);
+			return (a & 1) == 1 !== r && (n = i.neg(n)), {
+				x: e,
+				y: n
+			};
+		} else if (r === n && a === 4) {
+			let e = i.BYTES, t = i.fromBytes(o.subarray(0, e)), n = i.fromBytes(o.subarray(e, e * 2));
+			if (!v(t, n)) throw Error("bad point: is not on curve");
+			return {
+				x: t,
+				y: n
+			};
+		} else throw Error(`bad point: got length ${r}, expected compressed=${t} or uncompressed=${n}`);
+	}
+	let h = t.toBytes === void 0 ? p : t.toBytes, g = t.fromBytes === void 0 ? m : t.fromBytes;
+	function _(e) {
+		let t = i.sqr(e), n = i.mul(t, e);
+		return i.add(i.add(n, i.mul(e, o.a)), o.b);
+	}
+	function v(e, t) {
+		let n = i.sqr(t), r = _(e);
+		return i.eql(n, r);
+	}
+	if (!v(o.Gx, o.Gy)) throw Error("bad curve params: generator point");
+	let y = i.mul(i.pow(o.a, xi), Si), ee = i.mul(i.sqr(o.b), BigInt(27));
+	if (i.is0(i.add(y, ee))) throw Error("bad curve params: a or b");
+	function b(e, t, n = !1) {
+		if (!i.isValid(t) || n && i.is0(t)) throw Error(`bad point coordinate ${e}`);
+		return t;
+	}
+	function x(e) {
+		if (!(e instanceof w)) throw Error("Weierstrass Point expected");
+	}
+	function S(e) {
+		if (!l || !l.basises) throw Error("no endo");
+		return _i(e, l.basises, a.ORDER);
+	}
+	function C(e, t, n, r, a) {
+		return n = new w(i.mul(n.X, e), n.Y, n.Z), t = ei(r, t), n = ei(a, n), t.add(n);
+	}
+	class w {
+		constructor(e, t, n) {
+			L(this, "X", void 0), L(this, "Y", void 0), L(this, "Z", void 0), this.X = b("x", e), this.Y = b("y", t, !0), this.Z = b("z", n), Object.freeze(this);
+		}
+		static CURVE() {
+			return o;
+		}
+		static fromAffine(e) {
+			let { x: t, y: n } = e || {};
+			if (!e || !i.isValid(t) || !i.isValid(n)) throw Error("invalid affine point");
+			if (e instanceof w) throw Error("projective point not allowed");
+			return i.is0(t) && i.is0(n) ? w.ZERO : new w(t, n, i.ONE);
+		}
+		static fromBytes(e) {
+			let t = w.fromAffine(g(B(e, void 0, "point")));
+			return t.assertValidity(), t;
+		}
+		static fromHex(e) {
+			return w.fromBytes(sr(e));
+		}
+		get x() {
+			return this.toAffine().x;
+		}
+		get y() {
+			return this.toAffine().y;
+		}
+		precompute(e = 8, t = !0) {
+			return E.createCache(this, e), t || this.multiply(xi), this;
+		}
+		assertValidity() {
+			let e = this;
+			if (e.is0()) {
+				if (t.allowInfinityPoint && i.is0(e.X) && i.eql(e.Y, i.ONE) && i.is0(e.Z)) return;
+				throw Error("bad point: ZERO");
+			}
+			let { x: n, y: r } = e.toAffine();
+			if (!i.isValid(n) || !i.isValid(r)) throw Error("bad point: x or y not field elements");
+			if (!v(n, r)) throw Error("bad point: equation left != right");
+			if (!e.isTorsionFree()) throw Error("bad point: not in prime-order subgroup");
+		}
+		hasEvenY() {
+			let { y: e } = this.toAffine();
+			if (!i.isOdd) throw Error("Field doesn't support isOdd");
+			return !i.isOdd(e);
+		}
+		equals(e) {
+			x(e);
+			let { X: t, Y: n, Z: r } = this, { X: a, Y: o, Z: s } = e, c = i.eql(i.mul(t, s), i.mul(a, r)), l = i.eql(i.mul(n, s), i.mul(o, r));
+			return c && l;
+		}
+		negate() {
+			return new w(this.X, i.neg(this.Y), this.Z);
+		}
+		double() {
+			let { a: e, b: t } = o, n = i.mul(t, xi), { X: r, Y: a, Z: s } = this, c = i.ZERO, l = i.ZERO, u = i.ZERO, d = i.mul(r, r), f = i.mul(a, a), p = i.mul(s, s), m = i.mul(r, a);
+			return m = i.add(m, m), u = i.mul(r, s), u = i.add(u, u), c = i.mul(e, u), l = i.mul(n, p), l = i.add(c, l), c = i.sub(f, l), l = i.add(f, l), l = i.mul(c, l), c = i.mul(m, c), u = i.mul(n, u), p = i.mul(e, p), m = i.sub(d, p), m = i.mul(e, m), m = i.add(m, u), u = i.add(d, d), d = i.add(u, d), d = i.add(d, p), d = i.mul(d, m), l = i.add(l, d), p = i.mul(a, s), p = i.add(p, p), d = i.mul(p, m), c = i.sub(c, d), u = i.mul(p, f), u = i.add(u, u), u = i.add(u, u), new w(c, l, u);
+		}
+		add(e) {
+			x(e);
+			let { X: t, Y: n, Z: r } = this, { X: a, Y: s, Z: c } = e, l = i.ZERO, u = i.ZERO, d = i.ZERO, f = o.a, p = i.mul(o.b, xi), m = i.mul(t, a), h = i.mul(n, s), g = i.mul(r, c), _ = i.add(t, n), v = i.add(a, s);
+			_ = i.mul(_, v), v = i.add(m, h), _ = i.sub(_, v), v = i.add(t, r);
+			let y = i.add(a, c);
+			return v = i.mul(v, y), y = i.add(m, g), v = i.sub(v, y), y = i.add(n, r), l = i.add(s, c), y = i.mul(y, l), l = i.add(h, g), y = i.sub(y, l), d = i.mul(f, v), l = i.mul(p, g), d = i.add(l, d), l = i.sub(h, d), d = i.add(h, d), u = i.mul(l, d), h = i.add(m, m), h = i.add(h, m), g = i.mul(f, g), v = i.mul(p, v), h = i.add(h, g), g = i.sub(m, g), g = i.mul(f, g), v = i.add(v, g), m = i.mul(h, v), u = i.add(u, m), m = i.mul(y, v), l = i.mul(_, l), l = i.sub(l, m), m = i.mul(_, h), d = i.mul(y, d), d = i.add(d, m), new w(l, u, d);
+		}
+		subtract(e) {
+			return x(e), this.add(e.negate());
+		}
+		is0() {
+			return this.equals(w.ZERO);
+		}
+		multiply(e) {
+			let { endo: n } = t;
+			if (!a.isValidNot0(e)) throw RangeError("invalid scalar: out of range");
+			let r, i, o = (e) => E.cached(this, e, (e) => ti(w, e));
+			if (n) {
+				let { k1neg: t, k1: a, k2neg: s, k2: c } = S(e), { p: l, f: u } = o(a), { p: d, f } = o(c);
+				i = u.add(f), r = C(n.beta, l, d, t, s);
+			} else {
+				let { p: t, f: n } = o(e);
+				r = t, i = n;
+			}
+			return ti(w, [r, i])[0];
+		}
+		multiplyUnsafe(e) {
+			let { endo: n } = t, r = this, i = e;
+			if (!a.isValid(i)) throw RangeError("invalid scalar: out of range");
+			if (i === X || r.is0()) return w.ZERO;
+			if (i === Z) return r;
+			if (E.hasCache(this)) return this.multiply(i);
+			if (n) {
+				let { k1neg: e, k1: t, k2neg: a, k2: o } = S(i), { p1: s, p2: c } = ui(w, r, t, o);
+				return C(n.beta, s, c, e, a);
+			} else return E.unsafe(r, i);
+		}
+		toAffine(e) {
+			let t = this, n = e, { X: r, Y: a, Z: o } = t;
+			if (i.eql(o, i.ONE)) return {
+				x: r,
+				y: a
+			};
+			let s = t.is0();
+			n ?? (n = s ? i.ONE : i.inv(o));
+			let c = i.mul(r, n), l = i.mul(a, n), u = i.mul(o, n);
+			if (s) return {
+				x: i.ZERO,
+				y: i.ZERO
+			};
+			if (!i.eql(u, i.ONE)) throw Error("invZ was invalid");
+			return {
+				x: c,
+				y: l
+			};
+		}
+		isTorsionFree() {
+			let { isTorsionFree: e } = t;
+			return s === Z ? !0 : e ? e(w, this) : E.unsafe(this, c).is0();
+		}
+		clearCofactor() {
+			let { clearCofactor: e } = t;
+			return s === Z ? this : e ? e(w, this) : this.multiplyUnsafe(s);
+		}
+		isSmallOrder() {
+			return s === Z ? this.is0() : this.clearCofactor().is0();
+		}
+		toBytes(e = !0) {
+			return H(e, "isCompressed"), this.assertValidity(), h(w, this, e);
+		}
+		toHex(e = !0) {
+			return or(this.toBytes(e));
+		}
+		toString() {
+			return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+		}
+	}
+	n = w, L(w, "BASE", new n(o.Gx, o.Gy, i.ONE)), L(w, "ZERO", new n(i.ZERO, i.ONE, i.ZERO)), L(w, "Fp", i), L(w, "Fn", a);
+	let T = a.BITS, E = new li(w, t.endo ? Math.ceil(T / 2) : T);
+	return T >= 8 && w.BASE.precompute(8), Object.freeze(w.prototype), Object.freeze(w), w;
+}
+function wi(e) {
+	return Uint8Array.of(e ? 2 : 3);
+}
+function Ti(e, t) {
+	return {
+		secretKey: t.BYTES,
+		publicKey: 1 + e.BYTES,
+		publicKeyUncompressed: 1 + 2 * e.BYTES,
+		publicKeyHasPrefix: !0,
+		signature: 2 * t.BYTES
+	};
+}
+function Ei(e, t = {}) {
+	let { Fn: n } = e, r = t.randomBytes === void 0 ? lr : t.randomBytes, i = Object.assign(Ti(e.Fp, n), { seed: Math.max(Qr(n.ORDER), 16) });
+	function a(e) {
+		try {
+			let t = n.fromBytes(e);
+			return n.isValidNot0(t);
+		} catch {
+			return !1;
+		}
+	}
+	function o(t, n) {
+		let { publicKey: r, publicKeyUncompressed: a } = i;
+		try {
+			let i = t.length;
+			return n === !0 && i !== r || n === !1 && i !== a ? !1 : !!e.fromBytes(t);
+		} catch {
+			return !1;
+		}
+	}
+	function s(e) {
+		return e = e === void 0 ? r(i.seed) : e, $r(B(e, i.seed, "seed"), n.ORDER);
+	}
+	function c(t, r = !0) {
+		return e.BASE.multiply(n.fromBytes(t)).toBytes(r);
+	}
+	function l(e) {
+		let { secretKey: t, publicKey: r, publicKeyUncompressed: a } = i, o = n._lengths;
+		if (!cr(e)) return;
+		let s = B(e, void 0, "key").length, c = s === r || s === a, l = s === t || !!o?.includes(s);
+		if (!(c && l)) return c;
+	}
+	function u(t, r, i = !0) {
+		if (l(t) === !0) throw Error("first arg must be private key");
+		if (l(r) === !1) throw Error("second arg must be public key");
+		let a = n.fromBytes(t);
+		return e.fromBytes(r).multiply(a).toBytes(i);
+	}
+	let d = {
+		isValidSecretKey: a,
+		isValidPublicKey: o,
+		randomSecretKey: s
+	}, f = pi(s, c);
+	return Object.freeze(d), Object.freeze(i), Object.freeze({
+		getPublicKey: c,
+		getSharedSecret: u,
+		keygen: f,
+		Point: e,
+		utils: d,
+		lengths: i
+	});
+}
+function Di(e, t, n = {}) {
+	let r = t;
+	In(r), Dr(n, {}, {
+		hmac: "function",
+		lowS: "boolean",
+		randomBytes: "function",
+		bits2int: "function",
+		bits2int_modN: "function"
+	}), n = Object.assign({}, n);
+	let i = n.randomBytes === void 0 ? lr : n.randomBytes, a = n.hmac === void 0 ? (e, t) => hi(r, e, t) : n.hmac, { Fp: o, Fn: s } = e, { ORDER: c, BITS: l } = s, { keygen: u, getPublicKey: d, getSharedSecret: f, utils: p, lengths: m } = Ei(e, n), h = {
+		prehash: !0,
+		lowS: typeof n.lowS != "boolean" || n.lowS,
+		format: "compact",
+		extraEntropy: !1
+	}, g = c * bi + Z < o.ORDER;
+	function _(e) {
+		return e > c >> Z;
+	}
+	function v(e, t) {
+		if (!s.isValidNot0(t)) throw Error(`invalid signature ${e}: out of range 1..Point.Fn.ORDER`);
+		return t;
+	}
+	function y() {
+		if (g) throw Error("\"recovered\" sig type is not supported for cofactor >2 curves");
+	}
+	function ee(e, t) {
+		vi(t);
+		let n = m.signature;
+		return B(e, t === "compact" ? n : t === "recovered" ? n + 1 : void 0);
+	}
+	class b {
+		constructor(e, t, n) {
+			if (L(this, "r", void 0), L(this, "s", void 0), L(this, "recovery", void 0), this.r = v("r", e), this.s = v("s", t), n != null) {
+				if (y(), ![
+					0,
+					1,
+					2,
+					3
+				].includes(n)) throw Error("invalid recovery id");
+				this.recovery = n;
+			}
+			Object.freeze(this);
+		}
+		static fromBytes(e, t = h.format) {
+			ee(e, t);
+			let n;
+			if (t === "der") {
+				let { r: t, s: n } = Y.toSig(B(e));
+				return new b(t, n);
+			}
+			t === "recovered" && (n = e[0], t = "compact", e = e.subarray(1));
+			let r = m.signature / 2, i = e.subarray(0, r), a = e.subarray(r, r * 2);
+			return new b(s.fromBytes(i), s.fromBytes(a), n);
+		}
+		static fromHex(e, t) {
+			return this.fromBytes(sr(e), t);
+		}
+		assertRecovery() {
+			let { recovery: e } = this;
+			if (e == null) throw Error("invalid recovery id: must be present");
+			return e;
+		}
+		addRecoveryBit(e) {
+			return new b(this.r, this.s, e);
+		}
+		recoverPublicKey(t) {
+			let { r: n, s: r } = this, i = this.assertRecovery(), a = i === 2 || i === 3 ? n + c : n;
+			if (!o.isValid(a)) throw Error("invalid recovery id: sig.r+curve.n != R.x");
+			let l = o.toBytes(a), u = e.fromBytes(V(wi((i & 1) == 0), l)), d = s.inv(a), f = S(B(t, void 0, "msgHash")), p = s.create(-f * d), m = s.create(r * d), h = e.BASE.multiplyUnsafe(p).add(u.multiplyUnsafe(m));
+			if (h.is0()) throw Error("invalid recovery: point at infinify");
+			return h.assertValidity(), h;
+		}
+		hasHighS() {
+			return _(this.s);
+		}
+		toBytes(e = h.format) {
+			if (vi(e), e === "der") return sr(Y.hexFromSig(this));
+			let { r: t, s: n } = this, r = s.toBytes(t), i = s.toBytes(n);
+			return e === "recovered" ? (y(), V(Uint8Array.of(this.assertRecovery()), r, i)) : V(r, i);
+		}
+		toHex(e) {
+			return or(this.toBytes(e));
+		}
+	}
+	Object.freeze(b.prototype), Object.freeze(b);
+	let x = n.bits2int === void 0 ? function(e) {
+		if (e.length > 8192) throw Error("input is too large");
+		let t = gr(e), n = e.length * 8 - l;
+		return n > 0 ? t >> BigInt(n) : t;
+	} : n.bits2int, S = n.bits2int_modN === void 0 ? function(e) {
+		return s.create(x(e));
+	} : n.bits2int_modN, C = Tr(l);
+	function w(e) {
+		return Cr("num < 2^" + l, e, X, C), s.toBytes(e);
+	}
+	function T(e, t) {
+		return B(e, void 0, "message"), t ? B(r(e), void 0, "prehashed message") : e;
+	}
+	function E(t, n, r) {
+		let { lowS: a, prehash: o, extraEntropy: c } = yi(r, h);
+		t = T(t, o);
+		let l = S(t), u = s.fromBytes(n);
+		if (!s.isValidNot0(u)) throw Error("invalid private key");
+		let d = [w(u), w(l)];
+		if (c != null && c !== !1) {
+			let e = c === !0 ? i(m.secretKey) : c;
+			d.push(B(e, void 0, "extraEntropy"));
+		}
+		let f = V(...d), p = l;
+		function v(t) {
+			let n = x(t);
+			if (!s.isValidNot0(n)) return;
+			let r = s.inv(n), i = e.BASE.multiply(n).toAffine(), o = s.create(i.x);
+			if (o === X) return;
+			let c = s.create(r * s.create(p + o * u));
+			if (c === X) return;
+			let l = (i.x === o ? 0 : 2) | Number(i.y & Z), d = c;
+			return a && _(c) && (d = s.neg(c), l ^= 1), new b(o, d, g ? void 0 : l);
+		}
+		return {
+			seed: f,
+			k2sig: v
+		};
+	}
+	function D(e, t, n = {}) {
+		let { seed: i, k2sig: o } = E(e, t, n);
+		return Er(r.outputLen, s.BYTES, a)(i, o).toBytes(n.format);
+	}
+	function te(t, n, r, i = {}) {
+		let { lowS: a, prehash: o, format: c } = yi(i, h);
+		if (r = B(r, void 0, "publicKey"), n = T(n, o), !cr(t)) {
+			let e = t instanceof b ? ", use sig.toBytes()" : "";
+			throw Error("verify expects Uint8Array signature" + e);
+		}
+		ee(t, c);
+		try {
+			let i = b.fromBytes(t, c), o = e.fromBytes(r);
+			if (a && i.hasHighS()) return !1;
+			let { r: l, s: u } = i, d = S(n), f = s.inv(u), p = s.create(d * f), m = s.create(l * f), h = e.BASE.multiplyUnsafe(p).add(o.multiplyUnsafe(m));
+			return !h.is0() && s.create(h.x) === l;
+		} catch {
+			return !1;
+		}
+	}
+	function ne(e, t, n = {}) {
+		let { prehash: r } = yi(n, h);
+		return t = T(t, r), b.fromBytes(e, "recovered").recoverPublicKey(t).toBytes();
+	}
+	return Object.freeze({
+		keygen: u,
+		getPublicKey: d,
+		getSharedSecret: f,
+		utils: p,
+		lengths: m,
+		Point: e,
+		sign: D,
+		verify: te,
+		recoverPublicKey: ne,
+		Signature: b,
+		hash: r
+	});
+}
+var Oi = /* @__PURE__ */ Di(/* @__PURE__ */ Ci({
+	p: BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff"),
+	n: BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"),
+	h: BigInt(1),
+	a: BigInt("0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc"),
+	b: BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b"),
+	Gx: BigInt("0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
+	Gy: BigInt("0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5")
+}), ir);
+//#endregion
+//#region src/license/verify-fallback.ts
+function ki(e, t, n) {
+	let r = Ai(n);
+	if (!r) return !1;
+	try {
+		return Oi.verify(t, e, r, { lowS: !1 });
+	} catch {
+		return !1;
+	}
+}
+function Ai(e) {
+	if (e.kty !== "EC" || e.crv !== "P-256" || !e.x || !e.y) return null;
+	let t = On(e.x), n = On(e.y);
+	if (!t || !n || t.length !== 32 || n.length !== 32) return null;
+	let r = /* @__PURE__ */ new Uint8Array(65);
+	return r[0] = 4, r.set(t, 1), r.set(n, 33), r;
+}
+//#endregion
+//#region src/license/state.ts
+var ji = { status: "unlicensed" }, Mi = { status: "pending" };
+function Ni(e, t, n) {
+	let r = Date.parse(e);
+	return Number.isNaN(r) ? !1 : r >= t || !Number.isNaN(n) && r >= n;
+}
+async function Pi(e, t, n, r) {
+	let i = An(e);
+	if (!i) return ji;
+	let a = t[i.payload.keyId];
+	if (!a) return {
+		status: "unlicensed",
+		payload: i.payload
+	};
+	let o = jn(i.version, i.encodedPayload);
+	if (!(Nn() ? await Pn(o, i.signature, a) : ki(o, i.signature, a))) return {
+		status: "unlicensed",
+		payload: i.payload
+	};
+	let s = Date.parse(r);
+	return Ni(i.payload.expiry, n, s) ? {
+		status: "licensed",
+		payload: i.payload
+	} : {
+		status: "unlicensed",
+		payload: i.payload
+	};
+}
+var Fi = null, Ii = ji, Li = /* @__PURE__ */ new Map(), Ri = /* @__PURE__ */ new Set(), zi = 0;
+function Bi() {
+	zi++;
+}
+function Vi() {
+	zi--;
+}
+function Hi() {
+	return zi;
+}
+function Ui(e) {
+	Ii = e;
+	for (let t of Ri) t(e);
+}
+function Wi(e) {
+	if (e === Fi) return;
+	Fi = e;
+	let t = Li.get(e);
+	if (t) {
+		Ui(t);
+		return;
+	}
+	Ui(Mi), Pi(e, Mn, Date.now(), "2026-09-09").then((t) => {
+		Li.set(e, t), Fi === e && Ui(t);
+	});
+}
+function Gi() {
+	return Ii;
+}
+function Ki(e) {
+	return Ri.add(e), e(Ii), () => Ri.delete(e);
+}
+//#endregion
+//#region src/license/console-notice.ts
+var qi = "docs/LICENSING.md", Ji = !1;
+function Yi(e) {
+	if (Ji) return;
+	Ji = !0;
+	let t = e > 1 ? ` (${e} instances on this page)` : "";
+	console.info(`[VScada] Running in unlicensed/evaluation mode${t} — full functionality, watermarked. See ${qi} to apply a license key.`);
+}
+//#endregion
+//#region src/license/watermark.ts
+var Q = "http://www.w3.org/2000/svg", Xi = "vscada-watermark-pattern", Zi = "#808080";
+function Qi(e, t, n) {
+	if (!n.querySelector(`#${Xi}`)) {
+		let e = document.createElementNS(Q, "pattern");
+		e.setAttribute("id", Xi), e.setAttribute("width", "320"), e.setAttribute("height", "200"), e.setAttribute("patternUnits", "userSpaceOnUse"), e.setAttribute("patternTransform", "rotate(-30)");
+		let t = document.createElementNS(Q, "text");
+		t.setAttribute("x", "10"), t.setAttribute("y", "100"), t.setAttribute("font-size", "20"), t.setAttribute("fill", Zi), t.textContent = "VScada — unlicensed", e.appendChild(t), n.appendChild(e);
+	}
+	let r = document.createElementNS(Q, "g");
+	r.setAttribute("class", "vscada-watermark-repeat"), r.setAttribute("pointer-events", "none"), r.setAttribute("display", "none");
+	let i = document.createElementNS(Q, "rect");
+	i.setAttribute("width", String(e)), i.setAttribute("height", String(t)), i.setAttribute("fill", `url(#${Xi})`), i.setAttribute("opacity", "0.12"), r.appendChild(i);
+	let a = document.createElementNS(Q, "g");
+	a.setAttribute("class", "vscada-watermark-badge"), a.setAttribute("pointer-events", "none"), a.setAttribute("display", "none");
+	let o = document.createElementNS(Q, "text");
+	o.setAttribute("x", String(e - 8)), o.setAttribute("y", String(t - 8)), o.setAttribute("text-anchor", "end"), o.setAttribute("font-size", "12"), o.setAttribute("fill", Zi), o.setAttribute("opacity", "0.7"), o.textContent = "VScada — unlicensed", a.appendChild(o);
+	function s(e) {
+		let t = e ? "inline" : "none";
+		r.setAttribute("display", t), a.setAttribute("display", t);
+	}
+	return {
+		repeat: r,
+		badge: a,
+		setVisible: s
+	};
+}
+//#endregion
+//#region src/export/svg-export.ts
+var $i = "http://www.w3.org/2000/svg";
+function ea(e) {
+	let t = e.cloneNode(!0);
+	return ta(e, t), t.getAttribute("xmlns") || t.setAttribute("xmlns", $i), new XMLSerializer().serializeToString(t);
+}
+function ta(e, t) {
+	na(e, t);
+	let n = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT), r = document.createTreeWalker(t, NodeFilter.SHOW_ELEMENT), i = n.nextNode(), a = r.nextNode();
+	for (; i && a;) na(i, a), i = n.nextNode(), a = r.nextNode();
+}
+function na(e, t) {
+	let n = getComputedStyle(e), r = n.transform;
+	r && r !== "none" && (t.style.transform = r), ra(n, t), ia(n, t);
+}
+function ra(e, t) {
+	let n = t.getAttribute("style");
+	if (!n || !n.includes("var(")) return;
+	let r = n.split(";").map((e) => e.trim()).filter(Boolean).map((t) => {
+		let n = t.indexOf(":");
+		if (n === -1) return t;
+		let r = t.slice(0, n).trim(), i = t.slice(n + 1).trim();
+		return i.includes("var(") ? `${r}: ${e.getPropertyValue(r).trim() || i}` : `${r}: ${i}`;
+	}).join("; ");
+	t.setAttribute("style", r);
+}
+function ia(e, t) {
+	for (let n of [...t.attributes]) {
+		if (n.name === "style" || !n.value.includes("var(")) continue;
+		let r = e.getPropertyValue(n.name).trim();
+		r && t.setAttribute(n.name, r);
+	}
+}
+//#endregion
+//#region src/a11y/reduced-motion.ts
+var aa = "(prefers-reduced-motion: reduce)", oa = class {
+	constructor(e, t, n) {
+		this.target = e, this.staticRepresentations = t, this.matchMedia = n, this.mql = null, this.onChange = (e) => this.apply(e.matches), this.priorAnimated = null;
+	}
+	connect() {
+		!this.matchMedia || this.mql || (this.mql = this.matchMedia(aa), this.mql.addEventListener("change", this.onChange), this.apply(this.mql.matches));
+	}
+	disconnect() {
+		this.mql?.removeEventListener("change", this.onChange), this.mql = null;
+	}
+	get active() {
+		return this.mql?.matches ?? !1;
+	}
+	apply(e) {
+		e ? (this.priorAnimated === null && (this.priorAnimated = this.target.animated), this.staticRepresentations.activateAll(), this.target.animated = !1) : (this.priorAnimated !== null && (this.target.animated = this.priorAnimated, this.priorAnimated = null), this.staticRepresentations.deactivateAll());
+	}
+}, sa = class {
+	constructor() {
+		this.entries = [], this.active = !1;
+	}
+	register(e, t) {
+		this.entries.push({
+			elementId: e,
+			handle: t
+		}), this.active && t.activate();
+	}
+	unregisterElement(e) {
+		this.entries = this.entries.filter((t) => t.elementId !== e);
+	}
+	activateAll() {
+		this.active = !0;
+		for (let e of this.entries) e.handle.activate();
+	}
+	deactivateAll() {
+		this.active = !1;
+		for (let e of this.entries) e.handle.deactivate();
+	}
+	get isActive() {
+		return this.active;
+	}
+}, ca = class {
+	constructor() {
+		this.target = null, this.pending = [], this.flushScheduled = !1, this.sawDisconnect = !1;
+	}
+	attach(e) {
+		this.target = e;
+	}
+	announceConditionTransition(e, t, n) {
+		if (!(t !== "bad" && t !== "stale")) {
+			if (t === "stale" && n) {
+				if (this.sawDisconnect) return;
+				this.sawDisconnect = !0, this.enqueue("Scene disconnected");
+				return;
+			}
+			this.enqueue(t === "bad" ? `${e} quality bad` : `${e} stale`);
+		}
+	}
+	announceThresholdCrossing(e, t, n) {
+		n !== "normal" && this.enqueue(`${e} ${t} ${n} alarm`);
+	}
+	enqueue(e) {
+		this.pending.push(e), !this.flushScheduled && (this.flushScheduled = !0, queueMicrotask(() => this.flush()));
+	}
+	flush() {
+		this.flushScheduled = !1, this.sawDisconnect = !1;
+		let e = this.pending.join("; ");
+		this.pending = [], this.target && (this.target.textContent = e);
+	}
+};
+//#endregion
+//#region src/scheduler/alarm-band.ts
+function la(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of t) (r.direction === "below" ? e <= r.value : e >= r.value) && n.add(r.level);
+	return n.has("low-low") ? "low-low" : n.has("high-high") ? "high-high" : n.has("low") ? "low" : n.has("high") ? "high" : "normal";
+}
+function ua(e, t, n) {
+	if (!e) return n;
+	switch (t) {
+		case "low-low": return e.lowLowColor;
+		case "low": return e.lowColor;
+		case "high": return e.highColor;
+		case "high-high": return e.highHighColor;
+		default: return e.normalColor;
+	}
+}
+//#endregion
+//#region src/scada-view.ts
+var da, fa = "http://www.w3.org/2000/svg";
+function pa(e) {
+	return e.type === "off-page";
+}
+function ma(e) {
+	return e.type === "svg-import";
+}
+function ha(e) {
+	return e.startsWith("__vessel-wave-animation-") || e.startsWith("__vapor-drift-animation-") ? "wave" : e.startsWith("pipe-flow-animation") ? "flow" : e.startsWith("__rotating-animations-") ? "rotation" : e.startsWith("__indicator-lamp-animation-") ? "state-lamp" : "rotation";
+}
+var ga = class extends t {
+	constructor(e = C, t = w, n = typeof window < "u" && typeof window.matchMedia == "function" ? window.matchMedia.bind(window) : void 0) {
+		super(), this._scene = null, this._lastError = null, this._pendingDevValidation = null, this._sceneGeneration = 0, this._staticRepresentations = new sa(), this._liveRegion = new ca(), this._unsubscribeConditionTransition = null, this._builtElements = [], this._builtDefs = null, this._watermark = null, this._licenseVerdict = { status: "unlicensed" }, this._needsStructureInsert = !1, this._schedulerStarted = !1, this._unsubscribeLicense = null, this._interactive = !0, this._gestureArbiter = dn(), this._hitLayerGroup = null, this._hitAreaEntries = [], this._viewportGroup = null, this._lodActive = !1, this._listenersAttached = !1, this._isIntersecting = !0, this._intersectionObserver = null, this._boundVisibilityChange = null, this._unsubscribeRenderStats = null, this._groupViewState = null, this._flowInferenceCache = null, this._flowStoppedSourceIds = /* @__PURE__ */ new Set(), this._flowClosedNodeIds = /* @__PURE__ */ new Set(), this._flowTrackedElementIds = [], this._renderer = t, this._store = new Ze(e, (e) => this._dispatchValueWarning(e)), this._animations = new $e(), this._scheduler = new ft(e, this._store, t, this._animations), this._reducedMotion = new oa(this, this._staticRepresentations, n), this._unsubscribeConditionTransition = this._scheduler.onConditionTransition((e, t, n) => this._handleConditionTransition(e, n)), this._viewportState = En(e, (e) => this._onViewportFrame(e)), this._panZoomGestures = gn({
+			onPan: (e, t) => {
+				let n = this._viewBoxScale();
+				this._viewportState.panBy(e * n, t * n);
+			},
+			onZoomAboutPoint: (e, t, n) => {
+				let r = this._toCanvasPoint(t, n);
+				this._viewportState.zoomAboutPoint(e, r.x, r.y);
+			},
+			getZoom: () => this._viewportState.zoom
+		});
+	}
+	get stalenessTimeout() {
+		return this._scheduler.stalenessTimeout;
+	}
+	set stalenessTimeout(e) {
+		this._scheduler.stalenessTimeout = e;
+	}
+	get snapThreshold() {
+		return this._scheduler.snapThreshold;
+	}
+	set snapThreshold(e) {
+		this._scheduler.snapThreshold = e;
+	}
+	get connectionState() {
+		return this._scheduler.connectionState;
+	}
+	set connectionState(e) {
+		this._scheduler.connectionState = e;
+	}
+	get mode() {
+		return this._scheduler.mode;
+	}
+	set mode(e) {
+		this._scheduler.mode = e;
+	}
+	get animated() {
+		return this._scheduler.animate;
+	}
+	set animated(e) {
+		this._scheduler.animate = e;
+	}
+	get reducedMotionActive() {
+		return this._reducedMotion.active;
+	}
+	snapToTargets() {
+		this._scheduler.snapToTargets(), this._viewportState.snap();
+	}
+	get interactive() {
+		return this._interactive;
+	}
+	set interactive(e) {
+		this._interactive = e;
+	}
+	get zoom() {
+		return this._viewportState.zoom;
+	}
+	set zoom(e) {
+		this._viewportState.setZoomAnimated(e);
+	}
+	get debug() {
+		return this._scheduler.debug;
+	}
+	set debug(e) {
+		this._scheduler.debug = e, e && !this._unsubscribeRenderStats ? this._unsubscribeRenderStats = this._scheduler.onRenderStats((e) => this._dispatchRenderStats(e)) : !e && this._unsubscribeRenderStats && (this._unsubscribeRenderStats(), this._unsubscribeRenderStats = null);
+	}
+	seekAll(e) {
+		this._animations.seekAll(e);
+	}
+	exportSVG() {
+		let e = this.renderRoot?.querySelector("svg");
+		return e ? ea(e) : "";
+	}
+	static get observedAttributes() {
+		return [
+			...super.observedAttributes,
+			"license-key",
+			"tag-prefix",
+			"interactive",
+			"mode",
+			"animated"
+		];
+	}
+	attributeChangedCallback(e, t, n) {
+		super.attributeChangedCallback(e, t, n), e === "license-key" && n !== null && n !== t && Wi(n), e === "tag-prefix" && n !== t && (this.tagPrefix = n ?? ""), e === "interactive" && n !== t && (this.interactive = n !== "false"), e === "mode" && n !== t && (this.mode = n === "static" ? "static" : "live"), e === "animated" && n !== t && (this.animated = n !== "false");
+	}
+	get tagPrefix() {
+		return this._store.tagPrefix;
+	}
+	set tagPrefix(e) {
+		this._store.tagPrefix = e;
+	}
+	get scene() {
+		return this._scene;
+	}
+	set scene(e) {
+		if (e === this._scene) return;
+		let t = ++this._sceneGeneration;
+		this._teardownBuiltElements();
+		let n = d(e, _());
+		if (!n.ok) {
+			this._scene = null, this._lastError = n.error, this._pendingDevValidation = null, this.dispatchEvent(new CustomEvent("scene-error", {
+				detail: n.error,
+				bubbles: !0,
+				composed: !0
+			})), this.requestUpdate();
+			return;
+		}
+		this._scene = n.scene, this._lastError = null, this._groupViewState ? this._groupViewState.reset(this._scene) : this._groupViewState = new nn(this._scene, this._animations), this._viewportState.reset(this._scene.canvas.width, this._scene.canvas.height), this._buildElements(this._scene), this.requestUpdate(), this._pendingDevValidation = f(e).then((e) => {
+			if (t === this._sceneGeneration && !(!e || e.length === 0)) {
+				for (let t of e) console.warn(`[vscada] scene diagnostic at "${t.path}": ${t.message}`);
+				this.dispatchEvent(new CustomEvent("scene-error", {
+					detail: {
+						code: "BAD_SHAPE",
+						message: `${e.length} dev-only Zod diagnostic(s); see console`,
+						path: e[0].path
+					},
+					bubbles: !0,
+					composed: !0
+				}));
+			}
+		}).catch((e) => {
+			console.error("[vscada] dev-only scene validation failed", e);
+		});
+	}
+	get pendingDevValidation() {
+		return this._pendingDevValidation;
+	}
+	get values() {
+		return Array.from(this._store.tags()).map((e) => {
+			let t = this._store.get(e), n = {
+				tag: e,
+				value: t.currentValue,
+				quality: t.quality
+			};
+			return t.timestamp !== void 0 && (n.timestamp = t.timestamp), n;
+		});
+	}
+	set values(e) {
+		this.setValues(e);
+	}
+	setValues(e) {
+		this._store.setValues(e), this._scheduler.mode === "static" ? this._scheduler.snapToTargets() : this._maybeStartScheduler();
+	}
+	clearValues() {
+		this._store.clearValues();
+	}
+	connectedCallback() {
+		super.connectedCallback(), Bi();
+		let e = !0;
+		this._unsubscribeLicense = Ki((t) => {
+			if (e) {
+				e = !1, queueMicrotask(() => this._onLicenseVerdict(Gi()));
+				return;
+			}
+			this._onLicenseVerdict(t);
+		}), this._maybeStartScheduler(), this._reducedMotion.connect(), typeof IntersectionObserver < "u" && (this._intersectionObserver = new IntersectionObserver((e) => {
+			let t = e[e.length - 1];
+			t && (this._isIntersecting = t.isIntersecting, this._syncVisibilityPause());
+		}), this._intersectionObserver.observe(this)), typeof document < "u" && (this._boundVisibilityChange = () => this._syncVisibilityPause(), document.addEventListener("visibilitychange", this._boundVisibilityChange));
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback(), Vi(), this._reducedMotion.disconnect(), this._unsubscribeConditionTransition?.(), this._unsubscribeLicense?.(), this._unsubscribeLicense = null, this._intersectionObserver?.disconnect(), this._intersectionObserver = null, this._boundVisibilityChange && (document.removeEventListener("visibilitychange", this._boundVisibilityChange), this._boundVisibilityChange = null), this._viewportState.destroy(), this._scheduler.stop(), this._schedulerStarted = !1;
+	}
+	_onLicenseVerdict(e) {
+		this._licenseVerdict = e, this._watermark?.setVisible(e.status === "unlicensed"), e.status === "unlicensed" && Yi(Hi());
+	}
+	firstUpdated() {
+		let e = this.renderRoot.querySelector(".vscada-live-region");
+		e && this._liveRegion.attach(e);
+		let t = this.renderRoot.querySelector("svg");
+		!t || this._listenersAttached || (this._listenersAttached = !0, this._attachPanZoomListeners(t));
+	}
+	updated(e) {
+		if (super.updated(e), !this._needsStructureInsert) return;
+		this._needsStructureInsert = !1;
+		let t = this.renderRoot.querySelector("svg");
+		if (t) {
+			for (; t.firstChild;) t.removeChild(t.firstChild);
+			this._builtDefs && t.appendChild(this._builtDefs), this._watermark && t.appendChild(this._watermark.repeat), this._viewportGroup = document.createElementNS(fa, "g"), this._viewportGroup.setAttribute("class", "vscada-viewport");
+			for (let e of this._builtElements) this._viewportGroup.appendChild(e.svg);
+			this._hitLayerGroup && this._viewportGroup.appendChild(this._hitLayerGroup), t.appendChild(this._viewportGroup), this._applyViewportTransform({
+				zoom: this._viewportState.zoom,
+				panX: this._viewportState.pan.x,
+				panY: this._viewportState.pan.y
+			}), this._watermark && t.appendChild(this._watermark.badge);
+		}
+	}
+	render() {
+		let e = r`<div class="vscada-live-region" aria-live="assertive" aria-atomic="true"></div>`;
+		if (this._lastError) return r`${e}`;
+		let t = this._scene?.canvas.width ?? 100, n = this._scene?.canvas.height ?? 100;
+		return r`<svg part="canvas" role="graphics-document" aria-label=${this._scene ? `SCADA diagram: ${this._scene.id}` : "SCADA diagram"} viewBox="0 0 ${t} ${n}"></svg>${e}`;
+	}
+	_buildElements(e) {
+		this._builtDefs = document.createElementNS("http://www.w3.org/2000/svg", "defs");
+		let t = {
+			tokens: S(e.theme ?? "classic-hmi"),
+			defs: this._builtDefs
+		};
+		t.tokens.focusRing && (this.style.setProperty("--vscada-focus-ring-color", t.tokens.focusRing.color), this.style.setProperty("--vscada-focus-ring-width", `${t.tokens.focusRing.widthPx}px`), this.style.setProperty("--vscada-focus-ring-offset", `${t.tokens.focusRing.offsetPx}px`)), this._watermark = Qi(e.canvas.width, e.canvas.height, this._builtDefs), this._watermark.setVisible(this._licenseVerdict.status === "unlicensed");
+		let n = Ut(e), r = this._groupViewState?.collapsedGroupIds() ?? /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+		for (let t of e.groups) if (r.has(t.id)) for (let e of t.children) i.add(e);
+		let a = e.topology.sources, o = new Zt(n, e.inferFlow ? new Set(a === void 0 ? [...n.nodes].filter((e) => (n.incoming.get(e)?.length ?? 0) === 0 && (n.outgoing.get(e)?.length ?? 0) > 0) : a.filter((e) => n.nodes.has(e))) : /* @__PURE__ */ new Set());
+		this._flowInferenceCache = o, this._flowStoppedSourceIds = /* @__PURE__ */ new Set(), this._flowClosedNodeIds = /* @__PURE__ */ new Set();
+		let s = e.inferFlow ? [...n.nodes, ...n.edges.map((e) => e.id)] : [];
+		this._scheduler.registerFlowInference(o, s);
+		let c = /* @__PURE__ */ new Map(), l = [], u = 1;
+		for (let r of e.elements) {
+			if (e.inferFlow && !pa(r) && !ma(r) && n.nodes.has(r.id) && this._registerFlowStateTracking(r), i.has(r.id)) continue;
+			let a, o;
+			if (ma(r)) {
+				let e = Ht(r, t, this._renderer, (e) => this._dispatchValueWarning(e));
+				a = e.svg, o = e.handles;
+			} else {
+				let e = h(r.type);
+				if (!e) continue;
+				let n = (pa(r), r), i = e.build(n, t, this._renderer);
+				a = i.svg, o = i.handles;
+			}
+			let s = pa(r) || ma(r) ? o : this._wrapHandlesForLiveRegion(r, o);
+			this._registerHandles(r.id, s);
+			let d = document.createElementNS(fa, "g");
+			if (d.setAttribute("transform", `translate(${r.x} ${r.y})`), d.appendChild(a), !pa(r)) {
+				let e = gt(r.w, r.h, t);
+				d.appendChild(e.group), this._scheduler.registerQualityOverlay(r.id, e);
+				let n = [...new Set(r.bindings.map((e) => e.tag))], i = {
+					x: r.x,
+					y: r.y
+				}, a = ln(r.w, r.h, this._viewportState.zoom, i);
+				a.setAttribute("tabindex", String(u++)), a.setAttribute("aria-label", r.label ?? r.id), this._hitAreaEntries.push({
+					rect: a,
+					w: r.w,
+					h: r.h,
+					origin: i
+				}), fn(a, {
+					elementId: r.id,
+					elementType: r.type,
+					tags: n,
+					arbiter: this._gestureArbiter,
+					isInteractive: () => this._interactive,
+					onClick: (e) => this._dispatchElementClick(e),
+					onHoverChange: (e) => {
+						e && this._dispatchElementHover(r.id, n);
+					}
+				}), l.push({
+					area: r.w * r.h,
+					rect: a
+				});
+			}
+			c.set(r.id, d), this._builtElements.push({
+				elementId: r.id,
+				svg: d
+			});
+		}
+		if (l.length > 0) {
+			this._hitLayerGroup = document.createElementNS(fa, "g"), this._hitLayerGroup.setAttribute("class", "vscada-hit-layer");
+			for (let e of [...l].sort((e, t) => t.area - e.area)) this._hitLayerGroup.appendChild(e.rect);
+		}
+		for (let n of e.groups) {
+			let e = document.createElementNS(fa, "g");
+			if (e.setAttribute("transform", `translate(${n.x} ${n.y})`), e.setAttribute("class", "vscada-group"), r.has(n.id)) {
+				let r = Ue(n, t);
+				r.svg.style.cursor = "pointer", r.svg.addEventListener("click", () => this._toggleGroup(n.id)), e.appendChild(r.svg);
+			} else e.appendChild(We(n, t));
+			c.set(n.id, e), this._builtElements.push({
+				elementId: n.id,
+				svg: e
+			});
+		}
+		let d = tn(n, this._renderer, {
+			getNodeElement: (e) => c.get(e),
+			getEdgeElement: (e) => c.get(e)
+		}), f = ee();
+		if (f) for (let i of e.connections) {
+			let a = Xe(i, e, r, n);
+			if (!a) continue;
+			let { svg: o, handles: s } = f.build(a, t, this._renderer);
+			this._registerHandles(i.id, s), o.addEventListener("pointerenter", (e) => {
+				d.onPointerEnter(i.id, { pointerType: e.pointerType });
+			}), o.addEventListener("pointerleave", () => d.onPointerLeave()), c.set(i.id, o), this._builtElements.push({
+				elementId: i.id,
+				svg: o
+			});
+		}
+		this._needsStructureInsert = !0;
+	}
+	_registerFlowStateTracking(e) {
+		let t = e.bindings.find((e) => e.type === "state");
+		if (!t) return;
+		let n = e.id, r = new on(t.map, e.transitions ?? {}, {
+			duration: 0,
+			easing: "linear"
+		}, (e) => {});
+		this._scheduler.registerHandle(n, t.tag, {
+			kind: "state",
+			write: (e, i) => {
+				let a = r.resolve(i, t.tag);
+				a.state === "stopped" ? this._flowStoppedSourceIds.add(n) : this._flowStoppedSourceIds.delete(n), a.state === "closed" ? this._flowClosedNodeIds.add(n) : this._flowClosedNodeIds.delete(n), this._flowInferenceCache?.update(this._flowStoppedSourceIds, this._flowClosedNodeIds);
+			}
+		}), this._flowTrackedElementIds.push(n);
+	}
+	_toggleGroup(e) {
+		!this._scene || !this._groupViewState || this._interactive && (this._groupViewState.toggleGroup(e), this.dispatchEvent(new CustomEvent("element-click", {
+			detail: {
+				elementId: e,
+				elementType: "group"
+			},
+			bubbles: !0,
+			composed: !0
+		})), this._teardownBuiltElements(), this._buildElements(this._scene), this.requestUpdate());
+	}
+	_handleConditionTransition(e, t) {
+		let n = this._scene?.elements.find((t) => t.id === e)?.label ?? e;
+		this._liveRegion.announceConditionTransition(n, t, this._scheduler.connectionState === "disconnected");
+	}
+	_wrapHandlesForLiveRegion(e, t) {
+		let n = e.thresholds ?? [];
+		if (n.length === 0) return t;
+		let r = e.label ?? e.id, i = {};
+		for (let [a, o] of Object.entries(t)) {
+			let t = o.kind === "numeric" ? n.filter((e) => e.tag === a) : [];
+			if (o.kind !== "numeric" || t.length === 0) {
+				i[a] = o;
+				continue;
+			}
+			let s = e.bindings.find((e) => e.tag === a)?.type ?? "value", c = "normal";
+			i[a] = {
+				kind: "numeric",
+				write: (e, n, i) => {
+					let a = la(n, t);
+					a !== c && (this._liveRegion.announceThresholdCrossing(r, s, a), c = a), o.write(e, n, i);
+				}
+			};
+		}
+		return i;
+	}
+	_registerHandles(e, t) {
+		for (let [n, r] of Object.entries(t)) r.kind === "animation" ? this._animations.register(e, r, ha(n)) : r.kind === "static-representation" ? this._staticRepresentations.register(e, r) : this._scheduler.registerHandle(e, n, r);
+	}
+	_teardownBuiltElements() {
+		for (let e of this._builtElements) this._scheduler.unregisterElement(e.elementId), this._animations.unregisterElement(e.elementId), this._staticRepresentations.unregisterElement(e.elementId);
+		for (let e of this._flowTrackedElementIds) this._scheduler.unregisterElement(e);
+		this._builtElements = [], this._flowTrackedElementIds = [], this._builtDefs = null, this._watermark = null, this._hitLayerGroup = null, this._hitAreaEntries = [], this._viewportGroup = null;
+	}
+	_maybeStartScheduler() {
+		this._schedulerStarted || !this.isConnected || this._store.size === 0 || (this._scheduler.start(), this._schedulerStarted = !0);
+	}
+	_dispatchValueWarning(e) {
+		this.dispatchEvent(new CustomEvent("value-warning", {
+			detail: e,
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	_dispatchElementClick(e) {
+		this.dispatchEvent(new CustomEvent("element-click", {
+			detail: e,
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	_dispatchElementHover(e, t) {
+		let n = {
+			elementId: e,
+			tags: t
+		};
+		this.dispatchEvent(new CustomEvent("element-hover", {
+			detail: n,
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	_dispatchRenderStats(e) {
+		this.dispatchEvent(new CustomEvent("render-stats", {
+			detail: e,
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	_onViewportFrame(e) {
+		this._applyViewportTransform(e);
+		for (let t of this._hitAreaEntries) un(t.rect, t.w, t.h, e.zoom, t.origin);
+		let t = rt(e.zoom, this._lodActive);
+		this._lodActive = t, this._scheduler.lodActive = t, this._viewportGroup?.classList.toggle("vscada-lod-active", t);
+	}
+	_applyViewportTransform(e) {
+		this._viewportGroup && this._renderer.setAttr(this._viewportGroup, "transform", `translate(${e.panX} ${e.panY}) scale(${e.zoom})`);
+	}
+	_viewBoxScale() {
+		if (!this._scene) return 1;
+		let e = this.renderRoot.querySelector("svg");
+		if (!e) return 1;
+		let t = e.getBoundingClientRect();
+		return t.width === 0 ? 1 : this._scene.canvas.width / t.width;
+	}
+	_toCanvasPoint(e, t) {
+		let n = this.renderRoot.querySelector("svg");
+		if (!n || !this._scene) return {
+			x: e,
+			y: t
+		};
+		let r = n.getBoundingClientRect(), i = this._viewBoxScale();
+		return {
+			x: (e - r.left) * i,
+			y: (t - r.top) * i
+		};
+	}
+	_attachPanZoomListeners(e) {
+		e.addEventListener("pointerdown", (e) => {
+			let t = e;
+			this._panZoomGestures.onPointerDown(t.pointerId, t.clientX, t.clientY);
+		}), e.addEventListener("pointermove", (e) => {
+			let t = e;
+			this._panZoomGestures.onPointerMove(t.pointerId, t.clientX, t.clientY);
+		}), e.addEventListener("pointerup", (e) => {
+			this._panZoomGestures.onPointerUp(e.pointerId);
+		}), e.addEventListener("pointercancel", (e) => {
+			this._panZoomGestures.onPointerCancel(e.pointerId);
+		}), e.addEventListener("wheel", (e) => {
+			e.preventDefault();
+			let t = e;
+			this._panZoomGestures.onWheel(t.deltaY, t.clientX, t.clientY);
+		}, { passive: !1 });
+	}
+	_syncVisibilityPause() {
+		!this._isIntersecting || document.hidden ? this._scheduler.pauseForOffscreen() : this._scheduler.resumeFromOffscreen();
+	}
+};
+da = ga, da.styles = n`
+    :host {
+      display: block;
+    }
+    svg {
+      display: block;
+      width: 100%;
+      height: 100%;
+      touch-action: none;
+    }
+    /**
+     * Story 4.3 Task 2 — LOD's "text labels below legibility → hidden".
+     * One core-owned CSS toggle on the viewport group covers every
+     * primitive's text uniformly (labels, readouts, the quality overlay's
+     * age badge) — no per-primitive change needed.
+     */
+    .vscada-viewport.vscada-lod-active text {
+      display: none;
+    }
+    /* Story 4.4 Task 3 — §11 ARIA live region: present in the accessibility
+       tree (never display:none/visibility:hidden, which would strip it
+       from screen readers too) but invisible on screen. Standard
+       visually-hidden recipe. */
+    .vscada-live-region {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      overflow: hidden;
+      clip-path: inset(50%);
+      white-space: nowrap;
+    }
+    /* Story 4.4 Task 4 — §11 keyboard focus ring. Custom properties are
+       resolved from the theme's focusRing token at scene-build time
+       (_buildElements, on the host element) and inherit through the
+       shadow boundary by construction; the fallback values here are the
+       ONLY thing that ever renders if a theme declares no focusRing token
+       at all — a missing focus ring is an accessibility regression, unlike
+       a primitive's own graceful color degrade (AD-7), so this default is
+       deliberate, not a banned literal-color fallback. */
+    .vscada-hit-area:focus-visible {
+      outline: var(--vscada-focus-ring-width, 2px) solid var(--vscada-focus-ring-color, #2c7be5);
+      outline-offset: var(--vscada-focus-ring-offset, 2px);
+    }
+  `;
+function _a(e = "scada-view") {
+	let t = customElements.get(e);
+	t ? t !== ga && console.warn(`defineScadaView: "${e}" is already registered to a different class — ScadaView will not be used for this tag.`) : customElements.define(e, ga);
+}
+//#endregion
+//#region src/scene/crossing-jumps.ts
+var va = 24 * .8, ya = 1e-6, ba = 1e-9;
+function xa(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (r) for (let i = n + 1; i < e.length; i++) {
+			let n = e[i];
+			if (n) for (let e of r.segments) for (let r = 0; r < n.segments.length; r++) {
+				let a = Sa(e, n.segments[r]);
+				if (!a) continue;
+				let o = t.get(i) ?? [];
+				o.push({
+					point: a.point,
+					segmentIndex: r,
+					t: a.u
+				}), t.set(i, o);
+			}
+		}
+	}
+	return t;
+}
+function Sa(e, t) {
+	let n = e.to.x - e.from.x, r = e.to.y - e.from.y, i = t.to.x - t.from.x, a = t.to.y - t.from.y, o = n * a - r * i, s = n * n + r * r + i * i + a * a || 1;
+	if (Math.abs(o) < ba * s) return null;
+	let c = t.from.x - e.from.x, l = t.from.y - e.from.y, u = (c * a - l * i) / o, d = (c * r - l * n) / o;
+	return u <= ya || u >= 1 - ya || d <= ya || d >= 1 - ya ? null : {
+		point: {
+			x: e.from.x + u * n,
+			y: e.from.y + u * r
+		},
+		t: u,
+		u: d
+	};
+}
+function Ca(e, t, n = va) {
+	if (t.length === 0) return e;
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = r.get(e.segmentIndex) ?? [];
+		t.push(e), r.set(e.segmentIndex, t);
+	}
+	let i = [...r.keys()].sort((e, t) => t - e), a = e.segments, o = e.corners;
+	for (let e of i) {
+		let t = [...r.get(e)].sort((e, t) => e.t - t.t), i = wa(a, o, e, t, n);
+		i && (a = i.segments, o = i.corners);
+	}
+	return {
+		...e,
+		segments: a,
+		corners: o
+	};
+}
+function wa(e, t, n, r, i) {
+	let a = e[n];
+	if (!a) return null;
+	let o = a.to.x - a.from.x, s = a.to.y - a.from.y, c = Math.hypot(o, s);
+	if (c < 1e-9) return null;
+	let l = o / c, u = s / c, d = r.map((e) => Math.hypot(e.point.x - a.from.x, e.point.y - a.from.y)), f = d.map((e, t) => {
+		let n = t === 0 ? e : e - d[t - 1], r = t === d.length - 1 ? c - e : d[t + 1] - e;
+		return Math.min(i, n / 2, r / 2);
+	}), p = [], m = [], h = a.from, g = !1;
+	for (let e = 0; e < r.length; e++) {
+		let t = f[e];
+		if (t <= 1e-6) continue;
+		let n = r[e].point, i = {
+			x: n.x - l * t,
+			y: n.y - u * t
+		}, a = {
+			x: n.x + l * t,
+			y: n.y + u * t
+		};
+		p.push({
+			from: h,
+			to: i
+		}), m.push({
+			from: i,
+			to: a,
+			radius: t,
+			sweepFlag: 0
+		}), h = a, g = !0;
+	}
+	return g ? (p.push({
+		from: h,
+		to: a.to
+	}), {
+		segments: [
+			...e.slice(0, n),
+			...p,
+			...e.slice(n + 1)
+		],
+		corners: Ta(t, n, m)
+	}) : null;
+}
+function Ta(e, t, n) {
+	if (n.length === 0) return e.slice();
+	if (e.length === 0) {
+		let e = [];
+		for (let r = 0; r < n.length; r++) e[t + r] = n[r];
+		return e;
+	}
+	return [
+		...e.slice(0, t),
+		...n,
+		...e.slice(t)
+	];
+}
+function Ea(e) {
+	let t = e.connections.map((t) => ({
+		connection: t,
+		route: xe(t, e)
+	})), n = xa(t.map((e) => e.route));
+	return n.size === 0 ? t : t.map(({ connection: e, route: t }, r) => {
+		if (!t) return {
+			connection: e,
+			route: t
+		};
+		let i = n.get(r);
+		return !i || i.length === 0 ? {
+			connection: e,
+			route: t
+		} : {
+			connection: e,
+			route: Ca(t, i)
+		};
+	});
+}
+//#endregion
+//#region src/a11y/contrast.ts
+function Da(e) {
+	let t = e / 255;
+	return t <= .03928 ? t / 12.92 : ((t + .055) / 1.055) ** 2.4;
+}
+function Oa(e) {
+	let t = e.replace("#", ""), n = t.length === 3 ? t.split("").map((e) => e + e).join("") : t;
+	return {
+		r: parseInt(n.slice(0, 2), 16),
+		g: parseInt(n.slice(2, 4), 16),
+		b: parseInt(n.slice(4, 6), 16)
+	};
+}
+function ka(e) {
+	let { r: t, g: n, b: r } = Oa(e);
+	return .2126 * Da(t) + .7152 * Da(n) + .0722 * Da(r);
+}
+function Aa(e, t) {
+	let n = ka(e), r = ka(t), i = Math.max(n, r), a = Math.min(n, r);
+	return (i + .05) / (a + .05);
+}
+//#endregion
+//#region src/units/registry.ts
+function $(e) {
+	return {
+		toCanonical: (t) => t * e,
+		fromCanonical: (t) => t / e
+	};
+}
+var ja = {
+	Pa: {
+		family: "pressure",
+		...$(1)
+	},
+	kPa: {
+		family: "pressure",
+		...$(1e3)
+	},
+	bar: {
+		family: "pressure",
+		...$(1e5)
+	},
+	psi: {
+		family: "pressure",
+		...$(6894.757293168361)
+	},
+	K: {
+		family: "temperature",
+		toCanonical: (e) => e,
+		fromCanonical: (e) => e
+	},
+	degC: {
+		family: "temperature",
+		toCanonical: (e) => e + 273.15,
+		fromCanonical: (e) => e - 273.15
+	},
+	degF: {
+		family: "temperature",
+		toCanonical: (e) => (e - 32) * 5 / 9 + 273.15,
+		fromCanonical: (e) => (e - 273.15) * 9 / 5 + 32
+	},
+	m3s: {
+		family: "flow",
+		...$(1)
+	},
+	m3h: {
+		family: "flow",
+		...$(1 / 3600)
+	},
+	lpm: {
+		family: "flow",
+		...$(1 / 6e4)
+	},
+	gpm: {
+		family: "flow",
+		...$(.003785411784 / 60)
+	},
+	m: {
+		family: "level",
+		...$(1)
+	},
+	mm: {
+		family: "level",
+		...$(.001)
+	},
+	W: {
+		family: "power",
+		...$(1)
+	},
+	kW: {
+		family: "power",
+		...$(1e3)
+	},
+	MW: {
+		family: "power",
+		...$(1e6)
+	},
+	kg: {
+		family: "mass",
+		...$(1)
+	},
+	t: {
+		family: "mass",
+		...$(1e3)
+	},
+	lb: {
+		family: "mass",
+		...$(.45359237)
+	}
+};
+function Ma(e) {
+	return ja[e]?.family;
+}
+function Na(e, t, n) {
+	if (t === n) return e;
+	let r = ja[t], i = ja[n];
+	if (!(!r || !i || r.family !== i.family)) return i.fromCanonical(r.toCanonical(e));
+}
+//#endregion
+//#region src/units/formatter.ts
+function Pa(e, t) {
+	if (typeof e != "number" || !Number.isFinite(e)) return String(e);
+	let n = t.displayUnit ?? t.unit, r = Na(e, t.unit, n), i = r ?? e, a = r === void 0 ? t.unit : n, o = i.toFixed(t.decimals);
+	return a.length > 0 ? `${o} ${a}` : o;
+}
+//#endregion
+//#region src/index.ts
+var Fa = "0.0.0";
+//#endregion
+export { vn as DAMPED_OVERSHOOT_OMEGA, _n as DAMPED_OVERSHOOT_ZETA, Ct as DEFAULT_NEEDLE_SCALE, Zt as FlowInferenceCache, on as Fsm, nn as GroupViewStateController, va as JUMP_ARC_RADIUS, oe as LANE_WIDTH, xt as MAX_BINDING_PLAYBACK_RATE, ae as PIPE_WIDTH_REFERENCE, i as SCENE_ERROR_CODES, e as SUPPORTED_SCENE_VERSIONS, ga as ScadaView, Sn as Tween, an as UNKNOWN_STATE, Fa as VERSION, se as applyLaneOffset, Ke as buildBoundaryReferenceIndex, Ie as buildCollapsedGraphView, We as buildGroupExpandedFrame, Ue as buildGroupSummaryBlock, Ye as buildPresentationScene, Ut as buildTopologyGraph, Yt as computeFlowInference, Qt as computeUpstreamHighlight, Aa as contrastRatio, Na as convertUnit, rn as createGroupViewState, tn as createUpstreamHoverController, C as defaultTimeSource, _a as defineScadaView, xa as detectCrossings, w as domRenderer, Kt as downstreamOf, Pa as formatDisplayValue, Gi as getLicenseVerdict, $t as isFinePointerHover, Ki as onLicenseVerdict, Fe as presentationNodeId, j as rangeFraction, Wt as reachableSet, y as registerConnectionRenderer, m as registerPrimitives, It as registerSvgSources, x as registerThemes, ka as relativeLuminance, la as resolveAlarmBand, ua as resolveAlarmColor, St as resolveBlinkRate, Pt as resolveColorRampColor, be as resolveEffectiveMedium, ye as resolveEffectiveMediumStyle, bt as resolveEmissionIntensity, Xe as resolveGroupAwareConnectionGeometry, yt as resolveLevelFraction, me as resolveMediumStyle, wt as resolveNeedleAngle, Ea as resolveSceneRoutes, et as resolveVisualState, He as rollUpGroupCondition, Me as routeToPathData, Ne as segmentAngle, Wi as setLicenseKey, Ca as spliceJumpOvers, Ma as unitFamily, Gt as upstreamOf, d as validateSceneStructure };