likec4 1.57.0 → 1.58.0

package/__app__/src/chunks/adhoc-editor.mjs

@@ -0,0 +1,3386 @@
+import { i as e } from "./rolldown-runtime.mjs";
+import { B as n, E as r, H as i, U as a, W as o, g as s, h as c, i as l, p as u, s as d } from "./libs/remeda.mjs";
+import { mt as f, pt as p, ut as m, wt as h } from "./libs/@mantine.mjs";
+import { A as g, C as _, D as v, E as y, M as b, N as ee, _ as te, j as ne, x as re } from "./styled-system.mjs";
+import { h as ie, y as ae } from "./libs/@tabler/icons-react.mjs";
+import { $ as oe, D as se, N as ce, T as le, X as ue, Z as de, n as fe, t as pe, w as me, y as he } from "./LikeC4Styles.mjs";
+import { o as ge } from "./Markdown.mjs";
+import { E as _e, T as ve, n as ye, t as be, v as xe, y as Se } from "./DiagramActorProvider.mjs";
+import { u as Ce } from "./hooks.mjs";
+import { s as we } from "./libs/@xyflow/react.mjs";
+import { m as Te } from "./libs/framer.mjs";
+import { a as Ee, d as De, i as Oe, l as ke, n as Ae, r as x, s as S, t as je } from "./libs/@xstate/react.mjs";
+import { Profiler as Me, Suspense as Ne, createContext as Pe, memo as C, useCallback as Fe, useContext as Ie, useDeferredValue as Le, useEffect as w, useLayoutEffect as Re, useMemo as T, useRef as E, useState as D, useSyncExternalStore as ze } from "react";
+import { c as O } from "react/compiler-runtime";
+import { jsx as k, jsxs as A } from "react/jsx-runtime";
+import { flushSync as j } from "react-dom";
+import { ModelFqnExpr as M, nonNullable as Be } from "@likec4/core";
+import { compareNaturalHierarchically as Ve, difference as He, invariant as Ue, nonexhaustive as We, objectHash as Ge, stringHash as Ke, toArray as qe, toSet as N } from "@likec4/core/utils";
+//#region ../../node_modules/.pnpm/remeda@2.37.0/node_modules/remeda/dist/piped.js
+function t(...e) {
+	return (n) => o(n, ...e);
+}
+var Je = ae("outline", "trash", "Trash", [
+	["path", {
+		d: "M4 7l16 0",
+		key: "svg-0"
+	}],
+	["path", {
+		d: "M10 11l0 6",
+		key: "svg-1"
+	}],
+	["path", {
+		d: "M14 11l0 6",
+		key: "svg-2"
+	}],
+	["path", {
+		d: "M5 7l1 12a2 2 0 0 0 2 2h8a2 2 0 0 0 2 -2l1 -12",
+		key: "svg-3"
+	}],
+	["path", {
+		d: "M9 7v-3a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v3",
+		key: "svg-4"
+	}]
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@zag-js+utils@1.33.1/node_modules/@zag-js/utils/dist/index.mjs
+function toArray$1(e) {
+	return e == null ? [] : Array.isArray(e) ? e : [e];
+}
+e(toArray$1, "toArray");
+var first = (e) => e[0], last = (e) => e[e.length - 1], has = (e, n) => e.indexOf(n) !== -1, add = (e, ...n) => e.concat(n), P = /* @__PURE__ */ e((e, ...n) => e.filter((e) => !n.includes(e)), "remove"), uniq = (e) => Array.from(new Set(e)), diff = (e, n) => {
+	let r = new Set(n);
+	return e.filter((e) => !r.has(e));
+}, addOrRemove = (e, n) => has(e, n) ? P(e, n) : add(e, n);
+function partition(e, n) {
+	return e.reduce(([e, r], i) => (n(i) ? e.push(i) : r.push(i), [e, r]), [[], []]);
+}
+var isArrayLike = (e) => e?.constructor.name === "Array", isArrayEqual = (e, n) => {
+	if (e.length !== n.length) return !1;
+	for (let r = 0; r < e.length; r++) if (!isEqual(e[r], n[r])) return !1;
+	return !0;
+}, isEqual = (e, n) => {
+	if (Object.is(e, n)) return !0;
+	if (e == null && n != null || e != null && n == null) return !1;
+	if (typeof e?.isEqual == "function" && typeof n?.isEqual == "function") return e.isEqual(n);
+	if (typeof e == "function" && typeof n == "function") return e.toString() === n.toString();
+	if (isArrayLike(e) && isArrayLike(n)) return isArrayEqual(Array.from(e), Array.from(n));
+	if (typeof e != "object" || typeof n != "object") return !1;
+	let r = Object.keys(n ?? /* @__PURE__ */ Object.create(null)), i = r.length;
+	for (let n = 0; n < i; n++) if (!Reflect.has(e, r[n])) return !1;
+	for (let a = 0; a < i; a++) {
+		let i = r[a];
+		if (!isEqual(e[i], n[i])) return !1;
+	}
+	return !0;
+}, isArray = (e) => Array.isArray(e), isObjectLike = (e) => typeof e == "object" && !!e, F = /* @__PURE__ */ e((e) => isObjectLike(e) && !isArray(e), "isObject"), isString = (e) => typeof e == "string", isFunction = (e) => typeof e == "function", I = /* @__PURE__ */ e((e, n) => Object.prototype.hasOwnProperty.call(e, n), "hasProp"), baseGetTag = (e) => Object.prototype.toString.call(e), Ye = Function.prototype.toString, Xe = Ye.call(Object), isPlainObject = (e) => {
+	if (!isObjectLike(e) || baseGetTag(e) != "[object Object]" || isFrameworkElement(e)) return !1;
+	let n = Object.getPrototypeOf(e);
+	if (n === null) return !0;
+	let r = I(n, "constructor") && n.constructor;
+	return typeof r == "function" && r instanceof r && Ye.call(r) == Xe;
+}, isReactElement = (e) => typeof e == "object" && !!e && "$$typeof" in e && "props" in e, isVueElement = (e) => typeof e == "object" && !!e && "__v_isVNode" in e, isFrameworkElement = (e) => isReactElement(e) || isVueElement(e), Ze = /* @__PURE__ */ e((e) => e(), "identity"), callAll = (...e) => (...n) => {
+	e.forEach(function(e) {
+		e?.(...n);
+	});
+}, { floor: Qe, abs: $e, round: et, min: tt, max: nt, pow: rt, sign: it } = Math;
+function compact(e) {
+	if (!isPlainObject(e) || e === void 0) return e;
+	let n = Reflect.ownKeys(e).filter((e) => typeof e == "string"), r = {};
+	for (let i of n) {
+		let n = e[i];
+		n !== void 0 && (r[i] = compact(n));
+	}
+	return r;
+}
+function splitProps$1(e, n) {
+	let r = {}, i = {}, a = new Set(n), o = Reflect.ownKeys(e);
+	for (let n of o) a.has(n) ? i[n] = e[n] : r[n] = e[n];
+	return [i, r];
+}
+e(splitProps$1, "splitProps");
+function warn(...e) {
+	e.length === 1 ? e[0] : e[1], e.length === 2 && e[0];
+}
+function ensure(e, n) {
+	if (e == null) throw Error(n());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@zag-js+dom-query@1.33.1/node_modules/@zag-js/dom-query/dist/index.mjs
+var at = Object.defineProperty, ot = /* @__PURE__ */ e((e, n, r) => n in e ? at(e, n, {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: r
+}) : e[n] = r, "__defNormalProp"), L = /* @__PURE__ */ e((e, n, r) => ot(e, typeof n == "symbol" ? n : n + "", r), "__publicField"), wrap = (e, n) => e.map((r, i) => e[(Math.max(n, 0) + i) % e.length]), isObject = (e) => typeof e == "object" && !!e, dataAttr = (e) => e ? "" : void 0, ariaAttr = (e) => e ? "true" : void 0, st = 1, ct = 9, lt = 11, isHTMLElement = (e) => isObject(e) && e.nodeType === st && typeof e.nodeName == "string", isDocument = (e) => isObject(e) && e.nodeType === ct, isWindow = (e) => isObject(e) && e === e.window, isNode = (e) => isObject(e) && e.nodeType !== void 0, isShadowRoot = (e) => isNode(e) && e.nodeType === lt && "host" in e, isInputElement = (e) => isHTMLElement(e) && e.localName === "input", isAnchorElement = (e) => !!e?.matches("a[href]");
+function isActiveElement(e) {
+	return e ? getActiveElement(e.getRootNode()) === e : !1;
+}
+var ut = /(textarea|select)/;
+function isEditableElement(e) {
+	if (e == null || !isHTMLElement(e)) return !1;
+	try {
+		return isInputElement(e) && e.selectionStart != null || ut.test(e.localName) || e.isContentEditable || e.getAttribute("contenteditable") === "true" || e.getAttribute("contenteditable") === "";
+	} catch {
+		return !1;
+	}
+}
+function getDocument(e) {
+	return isDocument(e) ? e : isWindow(e) ? e.document : e?.ownerDocument ?? document;
+}
+function getWindow(e) {
+	return isShadowRoot(e) ? getWindow(e.host) : isDocument(e) ? e.defaultView ?? window : isHTMLElement(e) ? e.ownerDocument?.defaultView ?? window : window;
+}
+function getActiveElement(e) {
+	let n = e.activeElement;
+	for (; n?.shadowRoot;) {
+		let e = n.shadowRoot.activeElement;
+		if (!e || e === n) break;
+		n = e;
+	}
+	return n;
+}
+function getComposedPath(e) {
+	return e.composedPath?.() ?? e.nativeEvent?.composedPath?.();
+}
+function getEventTarget(e) {
+	return getComposedPath(e)?.[0] ?? e.target;
+}
+function isComposingEvent(e) {
+	return getNativeEvent(e).isComposing || e.keyCode === 229;
+}
+var isLeftClick = (e) => e.button === 0, isModifierKey = (e) => e.ctrlKey || e.altKey || e.metaKey, dt = {
+	Up: "ArrowUp",
+	Down: "ArrowDown",
+	Esc: "Escape",
+	" ": "Space",
+	",": "Comma",
+	Left: "ArrowLeft",
+	Right: "ArrowRight"
+}, ft = {
+	ArrowLeft: "ArrowRight",
+	ArrowRight: "ArrowLeft"
+};
+function getEventKey(e, n = {}) {
+	let { dir: r = "ltr", orientation: i = "horizontal" } = n, a = e.key;
+	return a = dt[a] ?? a, r === "rtl" && i === "horizontal" && a in ft && (a = ft[a]), a;
+}
+function getNativeEvent(e) {
+	return e.nativeEvent ?? e;
+}
+function getDescriptor(e, n) {
+	let { type: r = "HTMLInputElement", property: i = "value" } = n, a = getWindow(e)[r].prototype;
+	return Object.getOwnPropertyDescriptor(a, i) ?? {};
+}
+function getElementType(e) {
+	if (e.localName === "input") return "HTMLInputElement";
+	if (e.localName === "textarea") return "HTMLTextAreaElement";
+	if (e.localName === "select") return "HTMLSelectElement";
+}
+function setElementValue(e, n, r = "value") {
+	if (!e) return;
+	let i = getElementType(e);
+	i && getDescriptor(e, {
+		type: i,
+		property: r
+	}).set?.call(e, n), e.setAttribute(r, n);
+}
+var pt = class _AnimationFrame {
+	constructor() {
+		L(this, "id", null), L(this, "fn_cleanup"), L(this, "cleanup", () => {
+			this.cancel();
+		});
+	}
+	static create() {
+		return new _AnimationFrame();
+	}
+	request(e) {
+		this.cancel(), this.id = globalThis.requestAnimationFrame(() => {
+			this.id = null, this.fn_cleanup = e?.();
+		});
+	}
+	cancel() {
+		this.id !== null && (globalThis.cancelAnimationFrame(this.id), this.id = null), this.fn_cleanup?.(), this.fn_cleanup = void 0;
+	}
+	isActive() {
+		return this.id !== null;
+	}
+};
+function raf(e) {
+	let n = pt.create();
+	return n.request(e), n.cleanup;
+}
+var defaultItemToId = (e) => e.id;
+function itemById(e, n, r = defaultItemToId) {
+	return e.find((e) => r(e) === n);
+}
+function indexOfId(e, n, r = defaultItemToId) {
+	let i = itemById(e, n, r);
+	return i ? e.indexOf(i) : -1;
+}
+var sanitize = (e) => e.split("").map((e) => {
+	let n = e.charCodeAt(0);
+	return n > 0 && n < 128 ? e : n >= 128 && n <= 255 ? `/x${n.toString(16)}`.replace("/", "\\") : "";
+}).join("").trim(), getValueText = (e) => sanitize(e.dataset?.valuetext ?? e.textContent ?? ""), match = (e, n) => e.trim().toLowerCase().startsWith(n.toLowerCase());
+function getByText(e, n, r, i = defaultItemToId) {
+	let a = r ? indexOfId(e, r, i) : -1, o = r ? wrap(e, a) : e;
+	return n.length === 1 && (o = o.filter((e) => i(e) !== r)), o.find((e) => match(getValueText(e), n));
+}
+function getByTypeaheadImpl(e, n) {
+	let { state: r, activeId: i, key: a, timeout: o = 350, itemToId: s } = n, c = r.keysSoFar + a, l = c.length > 1 && Array.from(c).every((e) => e === c[0]) ? c[0] : c, u = getByText(e.slice(), l, i, s);
+	function cleanup() {
+		clearTimeout(r.timer), r.timer = -1;
+	}
+	function update(e) {
+		r.keysSoFar = e, cleanup(), e !== "" && (r.timer = +setTimeout(() => {
+			update(""), cleanup();
+		}, o));
+	}
+	return update(c), u;
+}
+var R = /* @__PURE__ */ Object.assign(getByTypeaheadImpl, {
+	defaultOptions: {
+		keysSoFar: "",
+		timer: -1
+	},
+	isValidEvent: isValidTypeaheadEvent
+});
+function isValidTypeaheadEvent(e) {
+	return e.key.length === 1 && !e.ctrlKey && !e.metaKey;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@zag-js+core@1.33.1/node_modules/@zag-js/core/dist/index.mjs
+var clsx = (...e) => e.map((e) => e?.trim?.()).filter(Boolean).join(" "), mt = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g, serialize = (e) => {
+	let n = {}, r;
+	for (; r = mt.exec(e);) n[r[1]] = r[2];
+	return n;
+}, css = (e, n) => {
+	if (isString(e)) {
+		if (isString(n)) return `${e};${n}`;
+		e = serialize(e);
+	} else isString(n) && (n = serialize(n));
+	return Object.assign({}, e ?? {}, n ?? {});
+};
+function mergeProps(...e) {
+	let n = {};
+	for (let r of e) {
+		if (!r) continue;
+		for (let e in n) {
+			if (e.startsWith("on") && typeof n[e] == "function" && typeof r[e] == "function") {
+				n[e] = callAll(r[e], n[e]);
+				continue;
+			}
+			if (e === "className" || e === "class") {
+				n[e] = clsx(n[e], r[e]);
+				continue;
+			}
+			if (e === "style") {
+				n[e] = css(n[e], r[e]);
+				continue;
+			}
+			n[e] = r[e] === void 0 ? n[e] : r[e];
+		}
+		for (let e in r) n[e] === void 0 && (n[e] = r[e]);
+		let e = Object.getOwnPropertySymbols(r);
+		for (let i of e) n[i] = r[i];
+	}
+	return n;
+}
+function createGuards() {
+	return {
+		and: (...e) => function andGuard(n) {
+			return e.every((e) => n.guard(e));
+		},
+		or: (...e) => function orGuard(n) {
+			return e.some((e) => n.guard(e));
+		},
+		not: (e) => function notGuard(n) {
+			return !n.guard(e);
+		}
+	};
+}
+function createMachine(e) {
+	return e;
+}
+var z = /* @__PURE__ */ ((e) => (e.NotStarted = "Not Started", e.Started = "Started", e.Stopped = "Stopped", e))(z || {}), ht = "__init__";
+function createScope(e) {
+	let getRootNode = () => e.getRootNode?.() ?? document, getDoc = () => getDocument(getRootNode()), getWin = () => getDoc().defaultView ?? window, getActiveElementFn = () => getActiveElement(getRootNode()), getById = (e) => getRootNode().getElementById(e);
+	return {
+		...e,
+		getRootNode,
+		getDoc,
+		getWin,
+		getActiveElement: getActiveElementFn,
+		isActiveElement,
+		getById
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@zag-js+types@1.33.1/node_modules/@zag-js/types/dist/index.mjs
+function createNormalizer(e) {
+	return new Proxy({}, { get(n, r) {
+		return r === "style" ? (n) => e({ style: n }).style : e;
+	} });
+}
+var createProps = () => (e) => Array.from(new Set(e)), gt = globalThis.document === void 0 ? w : Re;
+function useBindable(e) {
+	let n = e().value ?? e().defaultValue, r = e().isEqual ?? Object.is, [i] = D(n), [a, o] = D(i), s = e().value !== void 0, c = E(a);
+	c.current = s ? e().value : a;
+	let l = E(c.current);
+	gt(() => {
+		l.current = c.current;
+	}, [a, e().value]);
+	let setFn = (n) => {
+		let i = l.current, a = isFunction(n) ? n(i) : n;
+		e().debug && console.log(`[bindable > ${e().debug}] setValue`, {
+			next: a,
+			prev: i
+		}), s || o(a), r(a, i) || e().onChange?.(a, i);
+	};
+	function get() {
+		return s ? e().value : a;
+	}
+	return {
+		initial: i,
+		ref: c,
+		get,
+		set(n) {
+			(e().sync ? j : Ze)(() => setFn(n));
+		},
+		invoke(n, r) {
+			e().onChange?.(n, r);
+		},
+		hash(n) {
+			return e().hash?.(n) ?? String(n);
+		}
+	};
+}
+useBindable.cleanup = (e) => {
+	w(() => e, []);
+}, useBindable.ref = (e) => {
+	let n = E(e);
+	return {
+		get: () => n.current,
+		set: (e) => {
+			n.current = e;
+		}
+	};
+};
+function useRefs(e) {
+	let n = E(e);
+	return {
+		get(e) {
+			return n.current[e];
+		},
+		set(e, r) {
+			n.current[e] = r;
+		}
+	};
+}
+var useTrack = (e, n) => {
+	let r = E(!1), i = E(!1);
+	w(() => {
+		if (r.current && i.current) return n();
+		i.current = !0;
+	}, [...(e ?? []).map((e) => typeof e == "function" ? e() : e)]), w(() => (r.current = !0, () => {
+		r.current = !1;
+	}), []);
+};
+function useMachine(e, n = {}) {
+	let r = T(() => {
+		let { id: e, ids: r, getRootNode: i } = n;
+		return createScope({
+			id: e,
+			ids: r,
+			getRootNode: i
+		});
+	}, [n]), debug = (...n) => {
+		e.debug && console.log(...n);
+	}, i = useProp(e.props?.({
+		props: compact(n),
+		scope: r
+	}) ?? n), a = e.context?.({
+		prop: i,
+		bindable: useBindable,
+		scope: r,
+		flush: flush$1,
+		getContext() {
+			return s;
+		},
+		getComputed() {
+			return computed;
+		},
+		getRefs() {
+			return f;
+		},
+		getEvent() {
+			return getEvent();
+		}
+	}), o = useLiveRef(a), s = {
+		get(e) {
+			return o.current?.[e].ref.current;
+		},
+		set(e, n) {
+			o.current?.[e].set(n);
+		},
+		initial(e) {
+			return o.current?.[e].initial;
+		},
+		hash(e) {
+			let n = o.current?.[e].get();
+			return o.current?.[e].hash(n);
+		}
+	}, c = E(/* @__PURE__ */ new Map()), l = E(null), u = E(null), d = E({ type: "" }), getEvent = () => ({
+		...d.current,
+		current() {
+			return d.current;
+		},
+		previous() {
+			return u.current;
+		}
+	}), getState = () => ({
+		...p,
+		matches(...e) {
+			return e.includes(p.ref.current);
+		},
+		hasTag(n) {
+			return !!e.states[p.ref.current]?.tags?.includes(n);
+		}
+	}), f = useRefs(e.refs?.({
+		prop: i,
+		context: s
+	}) ?? {}), getParams = () => ({
+		state: getState(),
+		context: s,
+		event: getEvent(),
+		prop: i,
+		send,
+		action,
+		guard,
+		track: useTrack,
+		refs: f,
+		computed,
+		flush: flush$1,
+		scope: r,
+		choose
+	}), action = (n) => {
+		let r = isFunction(n) ? n(getParams()) : n;
+		if (!r) return;
+		let i = r.map((n) => {
+			let r = e.implementations?.actions?.[n];
+			return r || warn(`[zag-js] No implementation found for action "${JSON.stringify(n)}"`), r;
+		});
+		for (let e of i) e?.(getParams());
+	}, guard = (n) => isFunction(n) ? n(getParams()) : e.implementations?.guards?.[n](getParams()), effect = (n) => {
+		let r = isFunction(n) ? n(getParams()) : n;
+		if (!r) return;
+		let i = r.map((n) => {
+			let r = e.implementations?.effects?.[n];
+			return r || warn(`[zag-js] No implementation found for effect "${JSON.stringify(n)}"`), r;
+		}), a = [];
+		for (let e of i) {
+			let n = e?.(getParams());
+			n && a.push(n);
+		}
+		return () => a.forEach((e) => e?.());
+	}, choose = (e) => toArray$1(e).find((e) => {
+		let n = !e.guard;
+		return isString(e.guard) ? n = !!guard(e.guard) : isFunction(e.guard) && (n = e.guard(getParams())), n;
+	}), computed = (n) => {
+		ensure(e.computed, () => "[zag-js] No computed object found on machine");
+		let a = e.computed[n];
+		return a({
+			context: s,
+			event: getEvent(),
+			prop: i,
+			refs: f,
+			scope: r,
+			computed
+		});
+	}, p = useBindable(() => ({
+		defaultValue: e.initialState({ prop: i }),
+		onChange(n, r) {
+			r && (c.current.get(r)?.(), c.current.delete(r)), r && action(e.states[r]?.exit), action(l.current?.actions);
+			let i = effect(e.states[n]?.effects);
+			if (i && c.current.set(n, i), r === "__init__") {
+				action(e.entry);
+				let n = effect(e.effects);
+				n && c.current.set(ht, n);
+			}
+			action(e.states[n]?.entry);
+		}
+	})), m = E(void 0), h = E(z.NotStarted);
+	gt(() => {
+		queueMicrotask(() => {
+			let e = h.current === z.Started;
+			h.current = z.Started, debug(e ? "rehydrating..." : "initializing...");
+			let n = m.current ?? p.initial;
+			p.invoke(n, e ? p.get() : ht);
+		});
+		let n = c.current, r = p.ref.current;
+		return () => {
+			debug("unmounting..."), m.current = r, h.current = z.Stopped, n.forEach((e) => e?.()), c.current = /* @__PURE__ */ new Map(), l.current = null, queueMicrotask(() => {
+				action(e.exit);
+			});
+		};
+	}, []);
+	let getCurrentState = () => "ref" in p ? p.ref.current : p.get(), send = (n) => {
+		queueMicrotask(() => {
+			if (h.current !== z.Started) return;
+			u.current = d.current, d.current = n;
+			let r = getCurrentState(), i = choose(e.states[r].on?.[n.type] ?? e.on?.[n.type]);
+			if (!i) return;
+			l.current = i;
+			let a = i.target ?? r;
+			debug("transition", n.type, i.target || r, `(${i.actions})`);
+			let o = a !== r;
+			o ? j(() => p.set(a)) : i.reenter && !o ? p.invoke(r, r) : action(i.actions ?? []);
+		});
+	};
+	return e.watch?.(getParams()), {
+		state: getState(),
+		send,
+		context: s,
+		prop: i,
+		scope: r,
+		refs: f,
+		computed,
+		event: getEvent(),
+		getStatus: () => h.current
+	};
+}
+function useLiveRef(e) {
+	let n = E(e);
+	return n.current = e, n;
+}
+function useProp(e) {
+	let n = useLiveRef(e);
+	return function get(e) {
+		return n.current[e];
+	};
+}
+function flush$1(e) {
+	queueMicrotask(() => {
+		j(() => e());
+	});
+}
+e(flush$1, "flush");
+var _t = createNormalizer((e) => e), vt = ne({
+	base: {
+		border: "none",
+		display: "inline-flex",
+		alignItems: "center",
+		justifyContent: "center",
+		justifySelf: "flex-end",
+		fontSize: "[8px]",
+		fontFamily: "mono",
+		fontWeight: "bold",
+		letterSpacing: "[0.5px]",
+		marginLeft: "2",
+		py: "1",
+		px: "1.5",
+		lineHeight: "1",
+		rounded: "sm",
+		minWidth: 32,
+		transition: "normal",
+		_hover: { color: "text.bright" }
+	},
+	variants: { state: {
+		"include-explicit": {
+			backgroundColor: "grass.6",
+			color: "text"
+		},
+		"include-implicit": {
+			backgroundColor: "grass.6",
+			color: "text"
+		},
+		exclude: {
+			backgroundColor: "red.6",
+			color: "text"
+		},
+		disabled: { color: "text.dimmed" },
+		"not-present": {
+			color: "text.dimmed",
+			backgroundColor: "default.hover/50"
+		}
+	} },
+	defaultVariants: { state: "not-present" }
+}), yt = ee.raw({
+	flex: 0,
+	display: "flex",
+	alignItems: "center",
+	color: "text.dimmed",
+	_groupHover: { color: "text" },
+	_groupFocusWithin: { color: "mantine.colors.primary.lightColor!" },
+	_groupFocusVisible: { color: "mantine.colors.primary.lightColor!" },
+	"& :where(.likec4-shape-icon, .likec4-element-icon)": { display: "contents" },
+	"& :where(svg, img)": {
+		width: "10px",
+		height: "10px"
+	},
+	"@/md": { "& :where(svg, img)": {
+		width: "14px",
+		height: "14px"
+	} },
+	"@/lg": { "& :where(svg, img)": {
+		width: "16px",
+		height: "16px"
+	} },
+	opacity: {
+		base: .8,
+		_groupFocusVisible: 1,
+		_groupHover: 1
+	}
+}), bt = ee.raw({
+	paddingLeft: "[calc((var(--depth, 1) - 1) * {spacing.2} + {spacing.1})]",
+	px: "1",
+	py: "1",
+	mb: "0",
+	columnGap: "1",
+	"@/md": {
+		paddingLeft: "[calc((var(--depth, 1) - 1) * {spacing.2} + {spacing.2})]",
+		px: "2",
+		py: "1.5",
+		mb: "0.5",
+		columnGap: "2"
+	},
+	"@/lg": {
+		paddingLeft: "[calc((var(--depth, 1) - 1) * {spacing.3} + {spacing.2.5})]",
+		py: "2.5"
+	},
+	cursor: "pointer",
+	border: "none",
+	appearance: "none",
+	width: "full",
+	alignItems: "center",
+	display: "grid",
+	gridTemplateColumns: "auto 1fr auto",
+	gridTemplateRows: "auto auto",
+	rounded: "sm",
+	backgroundColor: {
+		base: "transparent",
+		_hover: {
+			base: "mantine.colors.gray[1]",
+			_dark: "mantine.colors.dark[5]"
+		},
+		_focusWithin: "mantine.colors.primary.lightHover!",
+		_focusVisible: "mantine.colors.primary.lightHover!"
+	},
+	color: {
+		base: "text",
+		_hover: "text.bright",
+		_focusWithin: "mantine.colors.primary.lightColor!",
+		_focusVisible: "mantine.colors.primary.lightColor!"
+	},
+	_focusVisible: { outline: "none" }
+}), { withRootProvider: xt, withContext: B } = v(g({
+	slots: [
+		"branch",
+		"item",
+		"control",
+		"state",
+		"icon",
+		"label",
+		"content",
+		"indicator"
+	],
+	base: {
+		branch: {},
+		item: { ...bt },
+		control: { ...bt },
+		state: {
+			border: "none",
+			display: "inline-flex",
+			alignItems: "center",
+			justifySelf: "flex-end",
+			marginLeft: "2",
+			"--chip-fz": "9px",
+			"--chip-checked-padding": "{spacing.1}",
+			"--chip-padding": "{spacing.1}",
+			"--chip-spacing": "0",
+			"--chip-size": "16px",
+			transition: "opacity 150ms ease-out"
+		},
+		icon: { ...yt },
+		label: {
+			cursor: "inherit",
+			color: "inherit",
+			userSelect: "none",
+			textStyle: "xxs",
+			truncate: "ellipsis",
+			"@/sm": { textStyle: "xs" },
+			"@/md": { textStyle: "sm" },
+			fontWeight: "[450]",
+			display: "inline-flex",
+			alignItems: "center",
+			gap: "2"
+		},
+		indicator: {
+			color: "inherit",
+			transition: "transform 150ms ease-out",
+			width: "12px",
+			opacity: .75,
+			"@/md": { width: "14px" },
+			_open: { transform: "rotate(90deg)" }
+		},
+		content: {}
+	},
+	variants: {},
+	defaultVariants: {}
+})), St = xt("div"), Ct = B("div", "branch"), wt = B("div", "item", {
+	forwardProps: [],
+	defaultProps: { className: "group" }
+}), Tt = B("div", "control", {
+	forwardProps: [],
+	defaultProps: { className: "group" }
+}), ElementState = (e) => {
+	let n = O(13), r, i, a, o;
+	if (n[0] !== e) {
+		let { node: s, state: c, onClick: l, className: u, ...d } = e;
+		o = c, i = l, r = u, a = d, n[0] = e, n[1] = r, n[2] = i, n[3] = a, n[4] = o;
+	} else r = n[1], i = n[2], a = n[3], o = n[4];
+	let s;
+	n[5] !== r || n[6] !== o ? (s = b(r, "mantine-active", vt({ state: o })), n[5] = r, n[6] = o, n[7] = s) : s = n[7];
+	let c = s, l;
+	return n[8] !== c || n[9] !== i || n[10] !== a || n[11] !== o ? (l = /* @__PURE__ */ k("div", {
+		...a,
+		onClick: i,
+		className: c,
+		children: o
+	}), n[8] = c, n[9] = i, n[10] = a, n[11] = o, n[12] = l) : l = n[12], l;
+}, V = {
+	Root: St,
+	Branch: Ct,
+	Item: wt,
+	Control: Tt,
+	State: B(ElementState, "state", { forwardProps: [
+		"node",
+		"state",
+		"onClick",
+		"className"
+	] }),
+	Icon: B(de, "icon", { forwardProps: ["element", "className"] }),
+	Label: B("div", "label", { forwardProps: [] }),
+	Content: B("div", "content", { forwardProps: [] }),
+	Indicator: B(ie, "indicator", {
+		forwardProps: [],
+		defaultProps: { size: 14 }
+	})
+}, H = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Mutable = 1] = "Mutable", e[e.Watching = 2] = "Watching", e[e.RecursedCheck = 4] = "RecursedCheck", e[e.Recursed = 8] = "Recursed", e[e.Dirty = 16] = "Dirty", e[e.Pending = 32] = "Pending", e;
+}({});
+function createReactiveSystem({ update: e, notify: n, unwatched: r }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(e, n, r) {
+		let i = n.depsTail;
+		if (i !== void 0 && i.dep === e) return;
+		let a = i === void 0 ? n.deps : i.nextDep;
+		if (a !== void 0 && a.dep === e) {
+			a.version = r, n.depsTail = a;
+			return;
+		}
+		let o = e.subsTail;
+		if (o !== void 0 && o.version === r && o.sub === n) return;
+		let s = n.depsTail = e.subsTail = {
+			version: r,
+			dep: e,
+			sub: n,
+			prevDep: i,
+			nextDep: a,
+			prevSub: o,
+			nextSub: void 0
+		};
+		a !== void 0 && (a.prevDep = s), i === void 0 ? n.deps = s : i.nextDep = s, o === void 0 ? e.subs = s : o.nextSub = s;
+	}
+	function unlink(e, n = e.sub) {
+		let i = e.dep, a = e.prevDep, o = e.nextDep, s = e.nextSub, c = e.prevSub;
+		return o === void 0 ? n.depsTail = a : o.prevDep = a, a === void 0 ? n.deps = o : a.nextDep = o, s === void 0 ? i.subsTail = c : s.prevSub = c, c === void 0 ? (i.subs = s) === void 0 && r(i) : c.nextSub = s, o;
+	}
+	function propagate(e) {
+		let r = e.nextSub, i;
+		top: do {
+			let a = e.sub, o = a.flags;
+			if (o & (H.RecursedCheck | H.Recursed | H.Dirty | H.Pending) ? o & (H.RecursedCheck | H.Recursed) ? o & H.RecursedCheck ? !(o & (H.Dirty | H.Pending)) && isValidLink(e, a) ? (a.flags = o | (H.Recursed | H.Pending), o &= H.Mutable) : o = H.None : a.flags = o & ~H.Recursed | H.Pending : o = H.None : a.flags = o | H.Pending, o & H.Watching && n(a), o & H.Mutable) {
+				let n = a.subs;
+				if (n !== void 0) {
+					let a = (e = n).nextSub;
+					a !== void 0 && (i = {
+						value: r,
+						prev: i
+					}, r = a);
+					continue;
+				}
+			}
+			if ((e = r) !== void 0) {
+				r = e.nextSub;
+				continue;
+			}
+			for (; i !== void 0;) if (e = i.value, i = i.prev, e !== void 0) {
+				r = e.nextSub;
+				continue top;
+			}
+			break;
+		} while (!0);
+	}
+	function checkDirty(n, r) {
+		let i, a = 0, o = !1;
+		top: do {
+			let s = n.dep, c = s.flags;
+			if (r.flags & H.Dirty) o = !0;
+			else if ((c & (H.Mutable | H.Dirty)) === (H.Mutable | H.Dirty)) {
+				if (e(s)) {
+					let e = s.subs;
+					e.nextSub !== void 0 && shallowPropagate(e), o = !0;
+				}
+			} else if ((c & (H.Mutable | H.Pending)) === (H.Mutable | H.Pending)) {
+				(n.nextSub !== void 0 || n.prevSub !== void 0) && (i = {
+					value: n,
+					prev: i
+				}), n = s.deps, r = s, ++a;
+				continue;
+			}
+			if (!o) {
+				let e = n.nextDep;
+				if (e !== void 0) {
+					n = e;
+					continue;
+				}
+			}
+			for (; a--;) {
+				let a = r.subs, s = a.nextSub !== void 0;
+				if (s ? (n = i.value, i = i.prev) : n = a, o) {
+					if (e(r)) {
+						s && shallowPropagate(a), r = n.sub;
+						continue;
+					}
+					o = !1;
+				} else r.flags &= ~H.Pending;
+				r = n.sub;
+				let c = n.nextDep;
+				if (c !== void 0) {
+					n = c;
+					continue top;
+				}
+			}
+			return o;
+		} while (!0);
+	}
+	function shallowPropagate(e) {
+		do {
+			let r = e.sub, i = r.flags;
+			(i & (H.Pending | H.Dirty)) === H.Pending && (r.flags = i | H.Dirty, (i & (H.Watching | H.RecursedCheck)) === H.Watching && n(r));
+		} while ((e = e.nextSub) !== void 0);
+	}
+	function isValidLink(e, n) {
+		let r = n.depsTail;
+		for (; r !== void 0;) {
+			if (r === e) return !0;
+			r = r.prevDep;
+		}
+		return !1;
+	}
+}
+function toObserver(e, n, r) {
+	let i = typeof e == "object", a = i ? e : void 0;
+	return {
+		next: (i ? e.next : e)?.bind(a),
+		error: (i ? e.error : n)?.bind(a),
+		complete: (i ? e.complete : r)?.bind(a)
+	};
+}
+var U = [], W = 0, { link: Et, unlink: Dt, propagate: Ot, checkDirty: kt, shallowPropagate: At } = createReactiveSystem({
+	update(e) {
+		return e._update();
+	},
+	notify(e) {
+		U[jt++] = e, e.flags &= ~H.Watching;
+	},
+	unwatched(e) {
+		e.depsTail !== void 0 && (e.depsTail = void 0, e.flags = H.Mutable | H.Dirty, purgeDeps(e));
+	}
+}), G = 0, jt = 0, K;
+function purgeDeps(e) {
+	let n = e.depsTail, r = n === void 0 ? e.deps : n.nextDep;
+	for (; r !== void 0;) r = Dt(r, e);
+}
+function flush() {
+	for (; G < jt;) {
+		let e = U[G];
+		U[G++] = void 0, e.notify();
+	}
+	G = 0, jt = 0;
+}
+function createAtom(e, n) {
+	let r = typeof e == "function", i = e, a = {
+		_snapshot: r ? void 0 : e,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: r ? H.None : H.Mutable,
+		get() {
+			return K !== void 0 && Et(a, K, W), a._snapshot;
+		},
+		subscribe(e) {
+			let n = toObserver(e), r = { current: !1 }, i = effect(() => {
+				if (a.get(), !r.current) r.current = !0;
+				else {
+					let e = K;
+					K = void 0;
+					try {
+						n.next?.(a._snapshot);
+					} finally {
+						K = e;
+					}
+					a.get();
+				}
+			});
+			return { unsubscribe: () => {
+				i.stop();
+			} };
+		},
+		_update(e) {
+			let o = K, s = n?.compare ?? Object.is;
+			K = a, ++W, a.depsTail = void 0, r && (a.flags = H.Mutable | H.RecursedCheck);
+			try {
+				let n = a._snapshot, read = (e) => e.get(), o = typeof e == "function" ? e(n) : e === void 0 && r ? i(read, n) : e;
+				return n === void 0 || !s(n, o) ? (a._snapshot = o, !0) : !1;
+			} finally {
+				K = o, r && (a.flags &= ~H.RecursedCheck), purgeDeps(a);
+			}
+		}
+	};
+	return r ? (a.flags = H.Mutable | H.Dirty, a.get = function() {
+		let e = a.flags;
+		if (e & H.Dirty || e & H.Pending && kt(a.deps, a)) {
+			if (a._update()) {
+				let e = a.subs;
+				e !== void 0 && At(e);
+			}
+		} else e & H.Pending && (a.flags = e & ~H.Pending);
+		return K !== void 0 && Et(a, K, W), a._snapshot;
+	}) : a.set = function(e) {
+		if (a._update(e)) {
+			let e = a.subs;
+			e !== void 0 && (Ot(e), At(e), flush());
+		}
+	}, a;
+}
+function effect(e) {
+	let run = () => {
+		let r = K;
+		K = n, ++W, n.depsTail = void 0, n.flags = H.Watching | H.RecursedCheck;
+		try {
+			return e();
+		} finally {
+			K = r, n.flags &= ~H.RecursedCheck, purgeDeps(n);
+		}
+	}, n = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: H.Watching | H.RecursedCheck,
+		notify() {
+			let e = this.flags;
+			e & H.Dirty || e & H.Pending && kt(this.deps, this) ? run() : this.flags = H.Watching;
+		},
+		stop() {
+			this.flags = H.None, this.depsTail = void 0, purgeDeps(this);
+		}
+	};
+	return run(), n;
+}
+var Mt = typeof Symbol == "function" && Symbol.observable || "@@observable", q = /* @__PURE__ */ new WeakMap();
+function createStoreCore(e, n) {
+	let r, i = e.getInitialSnapshot(), a = i, o = createAtom(a), emit = (e) => {
+		if (!r) return;
+		let n = e.type, i = r.get(n);
+		i && i.forEach((n) => n(e));
+		let a = r.get("*");
+		a && a.forEach((n) => n(e));
+	}, s = e.transition;
+	function receive(e) {
+		let [r, i] = s(a, e);
+		a = r, q.get(c)?.forEach((n) => {
+			n.next?.({
+				type: "@xstate.snapshot",
+				event: e,
+				snapshot: r,
+				actorRef: c,
+				rootId: c.sessionId
+			});
+		}), o.set(r);
+		for (let e of i) typeof e == "function" ? e() : (n?.[e.type]?.(e), emit(e));
+	}
+	let c = {
+		get _snapshot() {
+			return o._snapshot;
+		},
+		on(e, n) {
+			r ||= /* @__PURE__ */ new Map();
+			let i = r.get(e);
+			i || (i = /* @__PURE__ */ new Set(), r.set(e, i));
+			let a = n.bind(void 0);
+			return i.add(a), { unsubscribe() {
+				i.delete(a);
+			} };
+		},
+		transition: e.transition,
+		sessionId: uniqueId(),
+		send(e) {
+			q.get(c)?.forEach((n) => {
+				n.next?.({
+					type: "@xstate.event",
+					event: e,
+					sourceRef: void 0,
+					actorRef: c,
+					rootId: c.sessionId
+				});
+			}), receive(e);
+		},
+		getSnapshot() {
+			return a;
+		},
+		get() {
+			return o.get();
+		},
+		getInitialSnapshot() {
+			return i;
+		},
+		subscribe: o.subscribe.bind(o),
+		[Mt]() {
+			return this;
+		},
+		inspect: (e) => {
+			let n = toObserver(e);
+			return q.set(c, q.get(c) ?? /* @__PURE__ */ new Set()), q.get(c).add(n), n.next?.({
+				type: "@xstate.actor",
+				actorRef: c,
+				rootId: c.sessionId
+			}), n.next?.({
+				type: "@xstate.snapshot",
+				snapshot: i,
+				event: { type: "@xstate.init" },
+				actorRef: c,
+				rootId: c.sessionId
+			}), { unsubscribe() {
+				return q.get(c)?.delete(n);
+			} };
+		},
+		trigger: new Proxy({}, { get: (e, n) => (e) => {
+			c.send({
+				...e,
+				type: n
+			});
+		} }),
+		select(e, n = Object.is) {
+			return createAtom(() => e(c.get().context), { compare: n });
+		},
+		with(r) {
+			return createStoreCore(r(e), n);
+		}
+	};
+	return c;
+}
+function createStore(e) {
+	return "transition" in e ? createStoreCore(e) : createStoreCore({
+		getInitialSnapshot: () => ({
+			status: "active",
+			context: e.context,
+			output: void 0,
+			error: void 0
+		}),
+		transition: createStoreTransition(e.on)
+	}, e.emits);
+}
+function createStoreTransition(e, n) {
+	return (r, i) => {
+		let a = r.context, o = e?.[i.type], s = [], c = {
+			emit: new Proxy({}, { get: (e, n) => (e) => {
+				s.push({
+					...e,
+					type: n
+				});
+			} }),
+			effect: (e) => {
+				s.push(e);
+			}
+		};
+		if (!o) return [r, s];
+		let l = n ? n(a, (e) => o(e, i, c)) : o(a, i, c) ?? a;
+		return [l === a ? r : {
+			...r,
+			context: l
+		}, s];
+	};
+}
+function uniqueId() {
+	return Math.random().toString(36).slice(6);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@xstate+store@3.17.5_react@19.2.7/node_modules/@xstate/store/dist/xstate-store.esm.js
+function is(e, n) {
+	return e === n ? e !== 0 || n !== 0 || 1 / e == 1 / n : e !== e && n !== n;
+}
+function shallowEqual(e, n) {
+	if (is(e, n)) return !0;
+	if (typeof e != "object" || !e || typeof n != "object" || !n) return !1;
+	let r = Object.keys(e), i = Object.keys(n);
+	if (r.length !== i.length) return !1;
+	for (let i = 0; i < r.length; i++) if (!Object.prototype.hasOwnProperty.call(n, r[i]) || !is(e[r[i]], n[r[i]])) return !1;
+	return !0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@xstate+store@3.17.5_react@19.2.7/node_modules/@xstate/store/react/dist/xstate-store-react.esm.js
+function defaultCompare(e, n) {
+	return e === n;
+}
+function identity(e) {
+	return e;
+}
+function useSelectorWithCompare(e, n) {
+	let r = E(void 0);
+	return (i) => {
+		let a = e(i);
+		return r.current && n(r.current, a) ? r.current : r.current = a;
+	};
+}
+function useSelector(e, n = identity, r = defaultCompare) {
+	let i = useSelectorWithCompare(n, r);
+	return ze(Fe((n) => e.subscribe(n).unsubscribe, [e]), () => i(e.get()), () => i(e.get()));
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/hooks.ts
+var Nt = Pe(null), Pt = Nt.Provider;
+function useAdhocEditorActor() {
+	let e = O(2), n = Ie(Nt), r;
+	return e[0] === n ? r = e[1] : (r = Be(n, "No AdhocEditorActorContext"), e[0] = n, e[1] = r), r;
+}
+var Ft = {
+	id: "adhoc",
+	_type: "element",
+	autoLayout: { direction: "LR" },
+	nodes: [],
+	edges: [],
+	bounds: {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	},
+	_stage: "layouted",
+	title: null,
+	description: null,
+	hash: ""
+}, selectView = ({ context: e }) => e.view ?? Ft;
+function useAdhocView() {
+	return Ae(useAdhocEditorActor(), selectView);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@zag-js+anatomy@1.33.1/node_modules/@zag-js/anatomy/dist/index.mjs
+var createAnatomy = (e, n = []) => ({
+	parts: (...r) => {
+		if (isEmpty(n)) return createAnatomy(e, r);
+		throw Error("createAnatomy().parts(...) should only be called once. Did you mean to use .extendWith(...) ?");
+	},
+	extendWith: (...r) => createAnatomy(e, [...n, ...r]),
+	omit: (...r) => createAnatomy(e, n.filter((e) => !r.includes(e))),
+	rename: (e) => createAnatomy(e, n),
+	keys: () => n,
+	build: () => [...new Set(n)].reduce((n, r) => Object.assign(n, { [r]: {
+		selector: [`&[data-scope="${toKebabCase(e)}"][data-part="${toKebabCase(r)}"]`, `& [data-scope="${toKebabCase(e)}"][data-part="${toKebabCase(r)}"]`].join(", "),
+		attrs: {
+			"data-scope": toKebabCase(e),
+			"data-part": toKebabCase(r)
+		}
+	} }), {})
+}), toKebabCase = (e) => e.replace(/([A-Z])([A-Z])/g, "$1-$2").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase(), isEmpty = (e) => e.length === 0, It = Object.defineProperty, __defNormalProp = (e, n, r) => n in e ? It(e, n, {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: r
+}) : e[n] = r, __publicField = (e, n, r) => __defNormalProp(e, typeof n == "symbol" ? n : n + "", r);
+function access(e, n, r) {
+	for (let i = 0; i < n.length; i++) e = r.getChildren(e, n.slice(i + 1))[n[i]];
+	return e;
+}
+function ancestorIndexPaths(e) {
+	let n = sortIndexPaths(e), r = [], i = /* @__PURE__ */ new Set();
+	for (let e of n) {
+		let n = e.join();
+		i.has(n) || (i.add(n), r.push(e));
+	}
+	return r;
+}
+function compareIndexPaths(e, n) {
+	for (let r = 0; r < Math.min(e.length, n.length); r++) {
+		if (e[r] < n[r]) return -1;
+		if (e[r] > n[r]) return 1;
+	}
+	return e.length - n.length;
+}
+function sortIndexPaths(e) {
+	return e.sort(compareIndexPaths);
+}
+function find(e, n) {
+	let r;
+	return visit(e, {
+		...n,
+		onEnter: (e, i) => {
+			if (n.predicate(e, i)) return r = e, "stop";
+		}
+	}), r;
+}
+function findAll(e, n) {
+	let r = [];
+	return visit(e, {
+		onEnter: (e, i) => {
+			n.predicate(e, i) && r.push(e);
+		},
+		getChildren: n.getChildren
+	}), r;
+}
+function findIndexPath(e, n) {
+	let r;
+	return visit(e, {
+		onEnter: (e, i) => {
+			if (n.predicate(e, i)) return r = [...i], "stop";
+		},
+		getChildren: n.getChildren
+	}), r;
+}
+function reduce(e, n) {
+	let r = n.initialResult;
+	return visit(e, {
+		...n,
+		onEnter: (e, i) => {
+			r = n.nextResult(r, e, i);
+		}
+	}), r;
+}
+function flatMap(e, n) {
+	return reduce(e, {
+		...n,
+		initialResult: [],
+		nextResult: (e, r, i) => (e.push(...n.transform(r, i)), e)
+	});
+}
+function filter(e, n) {
+	let { predicate: r, create: i, getChildren: a } = n, filterRecursive = (e, n) => {
+		let o = a(e, n), s = [];
+		o.forEach((e, r) => {
+			let i = filterRecursive(e, [...n, r]);
+			i && s.push(i);
+		});
+		let c = n.length === 0, l = r(e, n), u = s.length > 0;
+		return c || l || u ? i(e, s, n) : null;
+	};
+	return filterRecursive(e, []) || i(e, [], []);
+}
+function flatten(e, n) {
+	let r = [], i = 0, a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+	return visit(e, {
+		getChildren: n.getChildren,
+		onEnter: (e, s) => {
+			a.has(e) || a.set(e, i++);
+			let c = n.getChildren(e, s);
+			c.forEach((n) => {
+				o.has(n) || o.set(n, e), a.has(n) || a.set(n, i++);
+			});
+			let l = c.length > 0 ? c.map((e) => a.get(e)) : void 0, u = o.get(e), d = u ? a.get(u) : void 0, f = a.get(e);
+			r.push({
+				...e,
+				_children: l,
+				_parent: d,
+				_index: f
+			});
+		}
+	}), r;
+}
+function insertOperation(e, n) {
+	return {
+		type: "insert",
+		index: e,
+		nodes: n
+	};
+}
+function removeOperation(e) {
+	return {
+		type: "remove",
+		indexes: e
+	};
+}
+function replaceOperation() {
+	return { type: "replace" };
+}
+function splitIndexPath(e) {
+	return [e.slice(0, -1), e[e.length - 1]];
+}
+function getInsertionOperations(e, n, r = /* @__PURE__ */ new Map()) {
+	let [i, a] = splitIndexPath(e);
+	for (let e = i.length - 1; e >= 0; e--) {
+		let n = i.slice(0, e).join();
+		switch (r.get(n)?.type) {
+			case "remove": continue;
+		}
+		r.set(n, replaceOperation());
+	}
+	let o = r.get(i.join());
+	switch (o?.type) {
+		case "remove":
+			r.set(i.join(), {
+				type: "removeThenInsert",
+				removeIndexes: o.indexes,
+				insertIndex: a,
+				insertNodes: n
+			});
+			break;
+		default: r.set(i.join(), insertOperation(a, n));
+	}
+	return r;
+}
+function getRemovalOperations(e) {
+	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.slice(0, -1).join(), i = r.get(e) ?? [];
+		i.push(n[n.length - 1]), r.set(e, i.sort((e, n) => e - n));
+	}
+	for (let r of e) for (let e = r.length - 2; e >= 0; e--) {
+		let i = r.slice(0, e).join();
+		n.has(i) || n.set(i, replaceOperation());
+	}
+	for (let [e, i] of r) n.set(e, removeOperation(i));
+	return n;
+}
+function getReplaceOperations(e, n) {
+	let r = /* @__PURE__ */ new Map(), [i, a] = splitIndexPath(e);
+	for (let e = i.length - 1; e >= 0; e--) {
+		let n = i.slice(0, e).join();
+		r.set(n, replaceOperation());
+	}
+	return r.set(i.join(), {
+		type: "removeThenInsert",
+		removeIndexes: [a],
+		insertIndex: a,
+		insertNodes: [n]
+	}), r;
+}
+function mutate(e, n, r) {
+	return map(e, {
+		...r,
+		getChildren: (e, i) => {
+			let a = i.join();
+			switch (n.get(a)?.type) {
+				case "replace":
+				case "remove":
+				case "removeThenInsert":
+				case "insert": return r.getChildren(e, i);
+				default: return [];
+			}
+		},
+		transform: (e, i, a) => {
+			let o = a.join(), s = n.get(o);
+			switch (s?.type) {
+				case "remove": return r.create(e, i.filter((e, n) => !s.indexes.includes(n)), a);
+				case "removeThenInsert":
+					let n = i.filter((e, n) => !s.removeIndexes.includes(n)), o = s.removeIndexes.reduce((e, n) => n < e ? e - 1 : e, s.insertIndex);
+					return r.create(e, splice(n, o, 0, ...s.insertNodes), a);
+				case "insert": return r.create(e, splice(i, s.index, 0, ...s.nodes), a);
+				case "replace": return r.create(e, i, a);
+				default: return e;
+			}
+		}
+	});
+}
+function splice(e, n, r, ...i) {
+	return [
+		...e.slice(0, n),
+		...i,
+		...e.slice(n + r)
+	];
+}
+function map(e, n) {
+	let r = {};
+	return visit(e, {
+		...n,
+		onLeave: (e, i) => {
+			let a = [0, ...i], o = a.join(), s = n.transform(e, r[o] ?? [], i), c = a.slice(0, -1).join(), l = r[c] ?? [];
+			l.push(s), r[c] = l;
+		}
+	}), r[""][0];
+}
+function insert2(e, n) {
+	let { nodes: r, at: i } = n;
+	if (i.length === 0) throw Error("Can't insert nodes at the root");
+	return mutate(e, getInsertionOperations(i, r), n);
+}
+function replace(e, n) {
+	return n.at.length === 0 ? n.node : mutate(e, getReplaceOperations(n.at, n.node), n);
+}
+function remove(e, n) {
+	if (n.indexPaths.length === 0) return e;
+	for (let e of n.indexPaths) if (e.length === 0) throw Error("Can't remove the root node");
+	return mutate(e, getRemovalOperations(n.indexPaths), n);
+}
+function move2(e, n) {
+	if (n.indexPaths.length === 0) return e;
+	for (let e of n.indexPaths) if (e.length === 0) throw Error("Can't move the root node");
+	if (n.to.length === 0) throw Error("Can't move nodes to the root");
+	let r = ancestorIndexPaths(n.indexPaths), i = r.map((r) => access(e, r, n));
+	return mutate(e, getInsertionOperations(n.to, i, getRemovalOperations(r)), n);
+}
+function visit(e, n) {
+	let { onEnter: r, onLeave: i, getChildren: a } = n, o = [], s = [{ node: e }], c = n.reuseIndexPath ? () => o : () => o.slice();
+	for (; s.length > 0;) {
+		let e = s[s.length - 1];
+		if (e.state === void 0) {
+			let n = r?.(e.node, c());
+			if (n === "stop") return;
+			e.state = n === "skip" ? -1 : 0;
+		}
+		let n = e.children || a(e.node, c());
+		if (e.children ||= n, e.state !== -1) {
+			if (e.state < n.length) {
+				let r = e.state;
+				o.push(r), s.push({ node: n[r] }), e.state = r + 1;
+				continue;
+			}
+			if (i?.(e.node, c()) === "stop") return;
+		}
+		o.pop(), s.pop();
+	}
+}
+var Lt = class _TreeCollection {
+	constructor(e) {
+		this.options = e, __publicField(this, "rootNode"), __publicField(this, "isEqual", (e) => isEqual(this.rootNode, e.rootNode)), __publicField(this, "getNodeChildren", (e) => this.options.nodeToChildren?.(e) ?? J.nodeToChildren(e) ?? []), __publicField(this, "resolveIndexPath", (e) => typeof e == "string" ? this.getIndexPath(e) : e), __publicField(this, "resolveNode", (e) => {
+			let n = this.resolveIndexPath(e);
+			return n ? this.at(n) : void 0;
+		}), __publicField(this, "getNodeChildrenCount", (e) => this.options.nodeToChildrenCount?.(e) ?? J.nodeToChildrenCount(e)), __publicField(this, "getNodeValue", (e) => this.options.nodeToValue?.(e) ?? J.nodeToValue(e)), __publicField(this, "getNodeDisabled", (e) => this.options.isNodeDisabled?.(e) ?? J.isNodeDisabled(e)), __publicField(this, "stringify", (e) => {
+			let n = this.findNode(e);
+			return n ? this.stringifyNode(n) : null;
+		}), __publicField(this, "stringifyNode", (e) => this.options.nodeToString?.(e) ?? J.nodeToString(e)), __publicField(this, "getFirstNode", (e = this.rootNode, n = {}) => {
+			let r;
+			return visit(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (i, a) => {
+					if (!this.isSameNode(i, e)) {
+						if (n.skip?.({
+							value: this.getNodeValue(i),
+							node: i,
+							indexPath: a
+						})) return "skip";
+						if (!r && a.length > 0 && !this.getNodeDisabled(i)) return r = i, "stop";
+					}
+				}
+			}), r;
+		}), __publicField(this, "getLastNode", (e = this.rootNode, n = {}) => {
+			let r;
+			return visit(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (i, a) => {
+					if (!this.isSameNode(i, e)) {
+						if (n.skip?.({
+							value: this.getNodeValue(i),
+							node: i,
+							indexPath: a
+						})) return "skip";
+						a.length > 0 && !this.getNodeDisabled(i) && (r = i);
+					}
+				}
+			}), r;
+		}), __publicField(this, "at", (e) => access(this.rootNode, e, { getChildren: this.getNodeChildren })), __publicField(this, "findNode", (e, n = this.rootNode) => find(n, {
+			getChildren: this.getNodeChildren,
+			predicate: (n) => this.getNodeValue(n) === e
+		})), __publicField(this, "findNodes", (e, n = this.rootNode) => {
+			let r = new Set(e.filter((e) => e != null));
+			return findAll(n, {
+				getChildren: this.getNodeChildren,
+				predicate: (e) => r.has(this.getNodeValue(e))
+			});
+		}), __publicField(this, "sort", (e) => e.reduce((e, n) => {
+			let r = this.getIndexPath(n);
+			return r && e.push({
+				value: n,
+				indexPath: r
+			}), e;
+		}, []).sort((e, n) => compareIndexPaths(e.indexPath, n.indexPath)).map(({ value: e }) => e)), __publicField(this, "getIndexPath", (e) => findIndexPath(this.rootNode, {
+			getChildren: this.getNodeChildren,
+			predicate: (n) => this.getNodeValue(n) === e
+		})), __publicField(this, "getValue", (e) => {
+			let n = this.at(e);
+			return n ? this.getNodeValue(n) : void 0;
+		}), __publicField(this, "getValuePath", (e) => {
+			if (!e) return [];
+			let n = [], r = [...e];
+			for (; r.length > 0;) {
+				let e = this.at(r);
+				e && n.unshift(this.getNodeValue(e)), r.pop();
+			}
+			return n;
+		}), __publicField(this, "getDepth", (e) => findIndexPath(this.rootNode, {
+			getChildren: this.getNodeChildren,
+			predicate: (n) => this.getNodeValue(n) === e
+		})?.length ?? 0), __publicField(this, "isSameNode", (e, n) => this.getNodeValue(e) === this.getNodeValue(n)), __publicField(this, "isRootNode", (e) => this.isSameNode(e, this.rootNode)), __publicField(this, "contains", (e, n) => !e || !n ? !1 : n.slice(0, e.length).every((r, i) => e[i] === n[i])), __publicField(this, "getNextNode", (e, n = {}) => {
+			let r = !1, i;
+			return visit(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (a, o) => {
+					if (this.isRootNode(a)) return;
+					let s = this.getNodeValue(a);
+					if (n.skip?.({
+						value: s,
+						node: a,
+						indexPath: o
+					})) return s === e && (r = !0), "skip";
+					if (r && !this.getNodeDisabled(a)) return i = a, "stop";
+					s === e && (r = !0);
+				}
+			}), i;
+		}), __publicField(this, "getPreviousNode", (e, n = {}) => {
+			let r, i = !1;
+			return visit(this.rootNode, {
+				getChildren: this.getNodeChildren,
+				onEnter: (a, o) => {
+					if (this.isRootNode(a)) return;
+					let s = this.getNodeValue(a);
+					if (n.skip?.({
+						value: s,
+						node: a,
+						indexPath: o
+					})) return "skip";
+					if (s === e) return i = !0, "stop";
+					this.getNodeDisabled(a) || (r = a);
+				}
+			}), i ? r : void 0;
+		}), __publicField(this, "getParentNodes", (e) => {
+			let n = this.resolveIndexPath(e)?.slice();
+			if (!n) return [];
+			let r = [];
+			for (; n.length > 0;) {
+				n.pop();
+				let e = this.at(n);
+				e && !this.isRootNode(e) && r.unshift(e);
+			}
+			return r;
+		}), __publicField(this, "getDescendantNodes", (e, n) => {
+			let r = this.resolveNode(e);
+			if (!r) return [];
+			let i = [];
+			return visit(r, {
+				getChildren: this.getNodeChildren,
+				onEnter: (e, r) => {
+					r.length !== 0 && (!n?.withBranch && this.isBranchNode(e) || i.push(e));
+				}
+			}), i;
+		}), __publicField(this, "getDescendantValues", (e, n) => this.getDescendantNodes(e, n).map((e) => this.getNodeValue(e))), __publicField(this, "getParentIndexPath", (e) => e.slice(0, -1)), __publicField(this, "getParentNode", (e) => {
+			let n = this.resolveIndexPath(e);
+			return n ? this.at(this.getParentIndexPath(n)) : void 0;
+		}), __publicField(this, "visit", (e) => {
+			let { skip: n, ...r } = e;
+			visit(this.rootNode, {
+				...r,
+				getChildren: this.getNodeChildren,
+				onEnter: (e, i) => {
+					if (!this.isRootNode(e)) return n?.({
+						value: this.getNodeValue(e),
+						node: e,
+						indexPath: i
+					}) ? "skip" : r.onEnter?.(e, i);
+				}
+			});
+		}), __publicField(this, "getPreviousSibling", (e) => {
+			let n = this.getParentNode(e);
+			if (!n) return;
+			let r = this.getNodeChildren(n), i = e[e.length - 1];
+			for (; --i >= 0;) {
+				let e = r[i];
+				if (!this.getNodeDisabled(e)) return e;
+			}
+		}), __publicField(this, "getNextSibling", (e) => {
+			let n = this.getParentNode(e);
+			if (!n) return;
+			let r = this.getNodeChildren(n), i = e[e.length - 1];
+			for (; ++i < r.length;) {
+				let e = r[i];
+				if (!this.getNodeDisabled(e)) return e;
+			}
+		}), __publicField(this, "getSiblingNodes", (e) => {
+			let n = this.getParentNode(e);
+			return n ? this.getNodeChildren(n) : [];
+		}), __publicField(this, "getValues", (e = this.rootNode) => flatMap(e, {
+			getChildren: this.getNodeChildren,
+			transform: (e) => [this.getNodeValue(e)]
+		}).slice(1)), __publicField(this, "isValidDepth", (e, n) => n == null ? !0 : typeof n == "function" ? n(e.length) : e.length === n), __publicField(this, "isBranchNode", (e) => this.getNodeChildren(e).length > 0 || this.getNodeChildrenCount(e) != null), __publicField(this, "getBranchValues", (e = this.rootNode, n = {}) => {
+			let r = [];
+			return visit(e, {
+				getChildren: this.getNodeChildren,
+				onEnter: (e, i) => {
+					if (i.length === 0) return;
+					let a = this.getNodeValue(e);
+					if (n.skip?.({
+						value: a,
+						node: e,
+						indexPath: i
+					})) return "skip";
+					this.isBranchNode(e) && this.isValidDepth(i, n.depth) && r.push(this.getNodeValue(e));
+				}
+			}), r;
+		}), __publicField(this, "flatten", (e = this.rootNode) => flatten(e, { getChildren: this.getNodeChildren })), __publicField(this, "_create", (e, n) => this.getNodeChildren(e).length > 0 || n.length > 0 ? {
+			...e,
+			children: n
+		} : { ...e }), __publicField(this, "_insert", (e, n, r) => this.copy(insert2(e, {
+			at: n,
+			nodes: r,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), __publicField(this, "copy", (e) => new _TreeCollection({
+			...this.options,
+			rootNode: e
+		})), __publicField(this, "_replace", (e, n, r) => this.copy(replace(e, {
+			at: n,
+			node: r,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), __publicField(this, "_move", (e, n, r) => this.copy(move2(e, {
+			indexPaths: n,
+			to: r,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), __publicField(this, "_remove", (e, n) => this.copy(remove(e, {
+			indexPaths: n,
+			getChildren: this.getNodeChildren,
+			create: this._create
+		}))), __publicField(this, "replace", (e, n) => this._replace(this.rootNode, e, n)), __publicField(this, "remove", (e) => this._remove(this.rootNode, e)), __publicField(this, "insertBefore", (e, n) => this.getParentNode(e) ? this._insert(this.rootNode, e, n) : void 0), __publicField(this, "insertAfter", (e, n) => {
+			if (!this.getParentNode(e)) return;
+			let r = [...e.slice(0, -1), e[e.length - 1] + 1];
+			return this._insert(this.rootNode, r, n);
+		}), __publicField(this, "move", (e, n) => this._move(this.rootNode, e, n)), __publicField(this, "filter", (e) => {
+			let n = filter(this.rootNode, {
+				predicate: e,
+				getChildren: this.getNodeChildren,
+				create: this._create
+			});
+			return this.copy(n);
+		}), __publicField(this, "toJSON", () => this.getValues(this.rootNode)), this.rootNode = e.rootNode;
+	}
+}, J = {
+	nodeToValue(e) {
+		return typeof e == "string" ? e : F(e) && I(e, "value") ? e.value : "";
+	},
+	nodeToString(e) {
+		return typeof e == "string" ? e : F(e) && I(e, "label") ? e.label : J.nodeToValue(e);
+	},
+	isNodeDisabled(e) {
+		return F(e) && I(e, "disabled") ? !!e.disabled : !1;
+	},
+	nodeToChildren(e) {
+		return e.children;
+	},
+	nodeToChildrenCount(e) {
+		if (F(e) && I(e, "childrenCount")) return e.childrenCount;
+	}
+}, Y = createAnatomy("tree-view").parts("branch", "branchContent", "branchControl", "branchIndentGuide", "branchIndicator", "branchText", "branchTrigger", "item", "itemIndicator", "itemText", "label", "nodeCheckbox", "nodeRenameInput", "root", "tree").build(), collection = (e) => new Lt(e);
+collection.empty = () => new Lt({ rootNode: { children: [] } });
+var getRootId = (e) => e.ids?.root ?? `tree:${e.id}:root`, getLabelId = (e) => e.ids?.label ?? `tree:${e.id}:label`, getNodeId = (e, n) => e.ids?.node?.(n) ?? `tree:${e.id}:node:${n}`, getTreeId = (e) => e.ids?.tree ?? `tree:${e.id}:tree`, focusNode = (e, n) => {
+	n != null && e.getById(getNodeId(e, n))?.focus();
+}, getRenameInputId = (e, n) => `tree:${e.id}:rename-input:${n}`, getRenameInputEl = (e, n) => e.getById(getRenameInputId(e, n));
+function getCheckedState(e, n, r) {
+	let i = e.getNodeValue(n);
+	if (!e.isBranchNode(n)) return r.includes(i);
+	let a = e.getDescendantValues(i), o = a.every((e) => r.includes(e)), s = a.some((e) => r.includes(e));
+	return o ? !0 : s ? "indeterminate" : !1;
+}
+function toggleBranchChecked(e, n, r) {
+	let i = e.getDescendantValues(n);
+	return uniq(i.every((e) => r.includes(e)) ? P(r, ...i) : add(r, ...i));
+}
+function getCheckedValueMap(e, n) {
+	let r = /* @__PURE__ */ new Map();
+	return e.visit({ onEnter: (i) => {
+		let a = e.getNodeValue(i), o = e.isBranchNode(i), s = getCheckedState(e, i, n);
+		r.set(a, {
+			type: o ? "branch" : "leaf",
+			checked: s
+		});
+	} }), r;
+}
+function connect(e, n) {
+	let { context: r, scope: i, computed: a, prop: o, send: s } = e, c = o("collection"), l = Array.from(r.get("expandedValue")), u = Array.from(r.get("selectedValue")), d = Array.from(r.get("checkedValue")), f = a("isTypingAhead"), p = r.get("focusedValue"), m = r.get("loadingStatus"), h = r.get("renamingValue"), skip = ({ indexPath: e }) => c.getValuePath(e).slice(0, -1).some((e) => !l.includes(e)), g = c.getFirstNode(void 0, { skip }), _ = g ? c.getNodeValue(g) : null;
+	function getNodeState(e) {
+		let { node: n, indexPath: r } = e, a = c.getNodeValue(n);
+		return {
+			id: getNodeId(i, a),
+			value: a,
+			indexPath: r,
+			valuePath: c.getValuePath(r),
+			disabled: !!n.disabled,
+			focused: p == null ? _ === a : p === a,
+			selected: u.includes(a),
+			expanded: l.includes(a),
+			loading: m[a] === "loading",
+			depth: r.length,
+			isBranch: c.isBranchNode(n),
+			renaming: h === a,
+			get checked() {
+				return getCheckedState(c, n, d);
+			}
+		};
+	}
+	return {
+		collection: c,
+		expandedValue: l,
+		selectedValue: u,
+		checkedValue: d,
+		toggleChecked(e, n) {
+			s({
+				type: "CHECKED.TOGGLE",
+				value: e,
+				isBranch: n
+			});
+		},
+		setChecked(e) {
+			s({
+				type: "CHECKED.SET",
+				value: e
+			});
+		},
+		clearChecked() {
+			s({ type: "CHECKED.CLEAR" });
+		},
+		getCheckedMap() {
+			return getCheckedValueMap(c, d);
+		},
+		expand(e) {
+			s({
+				type: e ? "BRANCH.EXPAND" : "EXPANDED.ALL",
+				value: e
+			});
+		},
+		collapse(e) {
+			s({
+				type: e ? "BRANCH.COLLAPSE" : "EXPANDED.CLEAR",
+				value: e
+			});
+		},
+		deselect(e) {
+			s({
+				type: e ? "NODE.DESELECT" : "SELECTED.CLEAR",
+				value: e
+			});
+		},
+		select(e) {
+			s({
+				type: e ? "NODE.SELECT" : "SELECTED.ALL",
+				value: e,
+				isTrusted: !1
+			});
+		},
+		getVisibleNodes() {
+			return a("visibleNodes");
+		},
+		focus(e) {
+			focusNode(i, e);
+		},
+		selectParent(e) {
+			let n = c.getParentNode(e);
+			n && s({
+				type: "SELECTED.SET",
+				value: add(u, c.getNodeValue(n)),
+				src: "select.parent"
+			});
+		},
+		expandParent(e) {
+			let n = c.getParentNode(e);
+			n && s({
+				type: "EXPANDED.SET",
+				value: add(l, c.getNodeValue(n)),
+				src: "expand.parent"
+			});
+		},
+		setExpandedValue(e) {
+			s({
+				type: "EXPANDED.SET",
+				value: uniq(e)
+			});
+		},
+		setSelectedValue(e) {
+			s({
+				type: "SELECTED.SET",
+				value: uniq(e)
+			});
+		},
+		startRenaming(e) {
+			s({
+				type: "NODE.RENAME",
+				value: e
+			});
+		},
+		submitRenaming(e, n) {
+			s({
+				type: "RENAME.SUBMIT",
+				value: e,
+				label: n
+			});
+		},
+		cancelRenaming() {
+			s({ type: "RENAME.CANCEL" });
+		},
+		getRootProps() {
+			return n.element({
+				...Y.root.attrs,
+				id: getRootId(i),
+				dir: o("dir")
+			});
+		},
+		getLabelProps() {
+			return n.element({
+				...Y.label.attrs,
+				id: getLabelId(i),
+				dir: o("dir")
+			});
+		},
+		getTreeProps() {
+			return n.element({
+				...Y.tree.attrs,
+				id: getTreeId(i),
+				dir: o("dir"),
+				role: "tree",
+				"aria-label": "Tree View",
+				"aria-labelledby": getLabelId(i),
+				"aria-multiselectable": o("selectionMode") === "multiple" || void 0,
+				tabIndex: -1,
+				onKeyDown(e) {
+					if (e.defaultPrevented || isComposingEvent(e)) return;
+					let n = getEventTarget(e);
+					if (isEditableElement(n)) return;
+					let r = n?.closest("[data-part=branch-control], [data-part=item]");
+					if (!r) return;
+					let i = r.dataset.value;
+					if (i == null) {
+						console.warn("[zag-js/tree-view] Node id not found for node", r);
+						return;
+					}
+					let a = r.matches("[data-part=branch-control]"), l = {
+						ArrowDown(e) {
+							isModifierKey(e) || (e.preventDefault(), s({
+								type: "NODE.ARROW_DOWN",
+								id: i,
+								shiftKey: e.shiftKey
+							}));
+						},
+						ArrowUp(e) {
+							isModifierKey(e) || (e.preventDefault(), s({
+								type: "NODE.ARROW_UP",
+								id: i,
+								shiftKey: e.shiftKey
+							}));
+						},
+						ArrowLeft(e) {
+							isModifierKey(e) || r.dataset.disabled || (e.preventDefault(), s({
+								type: a ? "BRANCH_NODE.ARROW_LEFT" : "NODE.ARROW_LEFT",
+								id: i
+							}));
+						},
+						ArrowRight(e) {
+							!a || r.dataset.disabled || (e.preventDefault(), s({
+								type: "BRANCH_NODE.ARROW_RIGHT",
+								id: i
+							}));
+						},
+						Home(e) {
+							isModifierKey(e) || (e.preventDefault(), s({
+								type: "NODE.HOME",
+								id: i,
+								shiftKey: e.shiftKey
+							}));
+						},
+						End(e) {
+							isModifierKey(e) || (e.preventDefault(), s({
+								type: "NODE.END",
+								id: i,
+								shiftKey: e.shiftKey
+							}));
+						},
+						Space(e) {
+							r.dataset.disabled || (f ? s({
+								type: "TREE.TYPEAHEAD",
+								key: e.key
+							}) : l.Enter?.(e));
+						},
+						Enter(e) {
+							r.dataset.disabled || isAnchorElement(n) && isModifierKey(e) || (s({
+								type: a ? "BRANCH_NODE.CLICK" : "NODE.CLICK",
+								id: i,
+								src: "keyboard"
+							}), isAnchorElement(n) || e.preventDefault());
+						},
+						"*"(e) {
+							r.dataset.disabled || (e.preventDefault(), s({
+								type: "SIBLINGS.EXPAND",
+								id: i
+							}));
+						},
+						a(e) {
+							!e.metaKey || r.dataset.disabled || (e.preventDefault(), s({
+								type: "SELECTED.ALL",
+								moveFocus: !0
+							}));
+						},
+						F2(e) {
+							if (r.dataset.disabled) return;
+							let n = o("canRename");
+							if (!n) return;
+							let a = c.getIndexPath(i);
+							if (a) {
+								let e = c.at(a);
+								if (e && !n(e, a)) return;
+							}
+							e.preventDefault(), s({
+								type: "NODE.RENAME",
+								value: i
+							});
+						}
+					}, u = l[getEventKey(e, { dir: o("dir") })];
+					if (u) {
+						u(e);
+						return;
+					}
+					R.isValidEvent(e) && (s({
+						type: "TREE.TYPEAHEAD",
+						key: e.key,
+						id: i
+					}), e.preventDefault());
+				}
+			});
+		},
+		getNodeState,
+		getItemProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.item.attrs,
+				id: r.id,
+				dir: o("dir"),
+				"data-ownedby": getTreeId(i),
+				"data-path": e.indexPath.join("/"),
+				"data-value": r.value,
+				tabIndex: r.focused ? 0 : -1,
+				"data-focus": dataAttr(r.focused),
+				role: "treeitem",
+				"aria-current": r.selected ? "true" : void 0,
+				"aria-selected": r.disabled ? void 0 : r.selected,
+				"data-selected": dataAttr(r.selected),
+				"aria-disabled": ariaAttr(r.disabled),
+				"data-disabled": dataAttr(r.disabled),
+				"data-renaming": dataAttr(r.renaming),
+				"aria-level": r.depth,
+				"data-depth": r.depth,
+				style: { "--depth": r.depth },
+				onFocus(e) {
+					e.stopPropagation(), s({
+						type: "NODE.FOCUS",
+						id: r.value
+					});
+				},
+				onClick(e) {
+					if (r.disabled || !isLeftClick(e) || isAnchorElement(e.currentTarget) && isModifierKey(e)) return;
+					let n = e.metaKey || e.ctrlKey;
+					s({
+						type: "NODE.CLICK",
+						id: r.value,
+						shiftKey: e.shiftKey,
+						ctrlKey: n
+					}), e.stopPropagation(), isAnchorElement(e.currentTarget) || e.preventDefault();
+				}
+			});
+		},
+		getItemTextProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.itemText.attrs,
+				"data-disabled": dataAttr(r.disabled),
+				"data-selected": dataAttr(r.selected),
+				"data-focus": dataAttr(r.focused)
+			});
+		},
+		getItemIndicatorProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.itemIndicator.attrs,
+				"aria-hidden": !0,
+				"data-disabled": dataAttr(r.disabled),
+				"data-selected": dataAttr(r.selected),
+				"data-focus": dataAttr(r.focused),
+				hidden: !r.selected
+			});
+		},
+		getBranchProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branch.attrs,
+				"data-depth": r.depth,
+				dir: o("dir"),
+				"data-branch": r.value,
+				role: "treeitem",
+				"data-ownedby": getTreeId(i),
+				"data-value": r.value,
+				"aria-level": r.depth,
+				"aria-selected": r.disabled ? void 0 : r.selected,
+				"data-path": e.indexPath.join("/"),
+				"data-selected": dataAttr(r.selected),
+				"aria-expanded": r.expanded,
+				"data-state": r.expanded ? "open" : "closed",
+				"aria-disabled": ariaAttr(r.disabled),
+				"data-disabled": dataAttr(r.disabled),
+				"data-loading": dataAttr(r.loading),
+				"aria-busy": ariaAttr(r.loading),
+				style: { "--depth": r.depth }
+			});
+		},
+		getBranchIndicatorProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchIndicator.attrs,
+				"aria-hidden": !0,
+				"data-state": r.expanded ? "open" : "closed",
+				"data-disabled": dataAttr(r.disabled),
+				"data-selected": dataAttr(r.selected),
+				"data-focus": dataAttr(r.focused),
+				"data-loading": dataAttr(r.loading)
+			});
+		},
+		getBranchTriggerProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchTrigger.attrs,
+				role: "button",
+				dir: o("dir"),
+				"data-disabled": dataAttr(r.disabled),
+				"data-state": r.expanded ? "open" : "closed",
+				"data-value": r.value,
+				"data-loading": dataAttr(r.loading),
+				disabled: r.loading,
+				onClick(e) {
+					r.disabled || r.loading || (s({
+						type: "BRANCH_TOGGLE.CLICK",
+						id: r.value
+					}), e.stopPropagation());
+				}
+			});
+		},
+		getBranchControlProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchControl.attrs,
+				role: "button",
+				id: r.id,
+				dir: o("dir"),
+				tabIndex: r.focused ? 0 : -1,
+				"data-path": e.indexPath.join("/"),
+				"data-state": r.expanded ? "open" : "closed",
+				"data-disabled": dataAttr(r.disabled),
+				"data-selected": dataAttr(r.selected),
+				"data-focus": dataAttr(r.focused),
+				"data-renaming": dataAttr(r.renaming),
+				"data-value": r.value,
+				"data-depth": r.depth,
+				"data-loading": dataAttr(r.loading),
+				"aria-busy": ariaAttr(r.loading),
+				onFocus(e) {
+					s({
+						type: "NODE.FOCUS",
+						id: r.value
+					}), e.stopPropagation();
+				},
+				onClick(e) {
+					if (r.disabled || r.loading || !isLeftClick(e) || isAnchorElement(e.currentTarget) && isModifierKey(e)) return;
+					let n = e.metaKey || e.ctrlKey;
+					s({
+						type: "BRANCH_NODE.CLICK",
+						id: r.value,
+						shiftKey: e.shiftKey,
+						ctrlKey: n
+					}), e.stopPropagation();
+				}
+			});
+		},
+		getBranchTextProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchText.attrs,
+				dir: o("dir"),
+				"data-disabled": dataAttr(r.disabled),
+				"data-state": r.expanded ? "open" : "closed",
+				"data-loading": dataAttr(r.loading)
+			});
+		},
+		getBranchContentProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchContent.attrs,
+				role: "group",
+				dir: o("dir"),
+				"data-state": r.expanded ? "open" : "closed",
+				"data-depth": r.depth,
+				"data-path": e.indexPath.join("/"),
+				"data-value": r.value,
+				hidden: !r.expanded
+			});
+		},
+		getBranchIndentGuideProps(e) {
+			let r = getNodeState(e);
+			return n.element({
+				...Y.branchIndentGuide.attrs,
+				"data-depth": r.depth
+			});
+		},
+		getNodeCheckboxProps(e) {
+			let r = getNodeState(e), i = r.checked;
+			return n.element({
+				...Y.nodeCheckbox.attrs,
+				tabIndex: -1,
+				role: "checkbox",
+				"data-state": i === !0 ? "checked" : i === !1 ? "unchecked" : "indeterminate",
+				"aria-checked": i === !0 ? "true" : i === !1 ? "false" : "mixed",
+				"data-disabled": dataAttr(r.disabled),
+				onClick(e) {
+					e.defaultPrevented || r.disabled || isLeftClick(e) && (s({
+						type: "CHECKED.TOGGLE",
+						value: r.value,
+						isBranch: r.isBranch
+					}), e.stopPropagation(), e.currentTarget.closest("[role=treeitem]")?.focus({ preventScroll: !0 }));
+				}
+			});
+		},
+		getNodeRenameInputProps(e) {
+			let r = getNodeState(e);
+			return n.input({
+				...Y.nodeRenameInput.attrs,
+				id: getRenameInputId(i, r.value),
+				type: "text",
+				"aria-label": "Rename tree item",
+				hidden: !r.renaming,
+				onKeyDown(e) {
+					isComposingEvent(e) || (e.key === "Escape" && (s({ type: "RENAME.CANCEL" }), e.preventDefault()), e.key === "Enter" && (s({
+						type: "RENAME.SUBMIT",
+						label: e.currentTarget.value
+					}), e.preventDefault()), e.stopPropagation());
+				},
+				onBlur(e) {
+					s({
+						type: "RENAME.SUBMIT",
+						label: e.currentTarget.value
+					});
+				}
+			});
+		}
+	};
+}
+function expandBranches(e, n) {
+	let { context: r, prop: i, refs: a } = e;
+	if (!i("loadChildren")) {
+		r.set("expandedValue", (e) => uniq(add(e, ...n)));
+		return;
+	}
+	let o = r.get("loadingStatus"), [s, c] = partition(n, (e) => o[e] === "loaded");
+	if (s.length > 0 && r.set("expandedValue", (e) => uniq(add(e, ...s))), c.length === 0) return;
+	let l = i("collection"), [u, d] = partition(c, (e) => {
+		let n = l.findNode(e);
+		return l.getNodeChildren(n).length > 0;
+	});
+	if (u.length > 0 && r.set("expandedValue", (e) => uniq(add(e, ...u))), d.length === 0) return;
+	r.set("loadingStatus", (e) => ({
+		...e,
+		...d.reduce((e, n) => ({
+			...e,
+			[n]: "loading"
+		}), {})
+	}));
+	let f = d.map((e) => {
+		let n = l.getIndexPath(e);
+		return {
+			id: e,
+			indexPath: n,
+			valuePath: l.getValuePath(n),
+			node: l.findNode(e)
+		};
+	}), p = a.get("pendingAborts"), m = i("loadChildren");
+	ensure(m, () => "[zag-js/tree-view] `loadChildren` is required for async expansion");
+	let h = f.map(({ id: e, indexPath: n, valuePath: r, node: i }) => {
+		let a = p.get(e);
+		a && (a.abort(), p.delete(e));
+		let o = new AbortController();
+		return p.set(e, o), m({
+			valuePath: r,
+			indexPath: n,
+			node: i,
+			signal: o.signal
+		});
+	});
+	Promise.allSettled(h).then((e) => {
+		let n = [], a = [], o = r.get("loadingStatus"), s = i("collection");
+		e.forEach((e, r) => {
+			let { id: i, indexPath: c, node: l, valuePath: u } = f[r];
+			e.status === "fulfilled" ? (o[i] = "loaded", n.push(i), s = s.replace(c, {
+				...l,
+				children: e.value
+			})) : (p.delete(i), Reflect.deleteProperty(o, i), a.push({
+				node: l,
+				error: e.reason,
+				indexPath: c,
+				valuePath: u
+			}));
+		}), r.set("loadingStatus", o), n.length && (r.set("expandedValue", (e) => uniq(add(e, ...n))), i("onLoadChildrenComplete")?.({ collection: s })), a.length && i("onLoadChildrenError")?.({ nodes: a });
+	});
+}
+function skipFn(e) {
+	let { prop: n, context: r } = e;
+	return function skip({ indexPath: e }) {
+		return n("collection").getValuePath(e).slice(0, -1).some((e) => !r.get("expandedValue").includes(e));
+	};
+}
+var { and: X } = createGuards(), Rt = createMachine({
+	props({ props: e }) {
+		return {
+			selectionMode: "single",
+			collection: collection.empty(),
+			typeahead: !0,
+			expandOnClick: !0,
+			defaultExpandedValue: [],
+			defaultSelectedValue: [],
+			...e
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop: e, bindable: n, getContext: r }) {
+		return {
+			expandedValue: n(() => ({
+				defaultValue: e("defaultExpandedValue"),
+				value: e("expandedValue"),
+				isEqual,
+				onChange(n) {
+					let i = r().get("focusedValue");
+					e("onExpandedChange")?.({
+						expandedValue: n,
+						focusedValue: i,
+						get expandedNodes() {
+							return e("collection").findNodes(n);
+						}
+					});
+				}
+			})),
+			selectedValue: n(() => ({
+				defaultValue: e("defaultSelectedValue"),
+				value: e("selectedValue"),
+				isEqual,
+				onChange(n) {
+					let i = r().get("focusedValue");
+					e("onSelectionChange")?.({
+						selectedValue: n,
+						focusedValue: i,
+						get selectedNodes() {
+							return e("collection").findNodes(n);
+						}
+					});
+				}
+			})),
+			focusedValue: n(() => ({
+				defaultValue: e("defaultFocusedValue") || null,
+				value: e("focusedValue"),
+				onChange(n) {
+					e("onFocusChange")?.({
+						focusedValue: n,
+						get focusedNode() {
+							return n ? e("collection").findNode(n) : null;
+						}
+					});
+				}
+			})),
+			loadingStatus: n(() => ({ defaultValue: {} })),
+			checkedValue: n(() => ({
+				defaultValue: e("defaultCheckedValue") || [],
+				value: e("checkedValue"),
+				isEqual,
+				onChange(n) {
+					e("onCheckedChange")?.({ checkedValue: n });
+				}
+			})),
+			renamingValue: n(() => ({
+				sync: !0,
+				defaultValue: null
+			}))
+		};
+	},
+	refs() {
+		return {
+			typeaheadState: { ...R.defaultOptions },
+			pendingAborts: /* @__PURE__ */ new Map()
+		};
+	},
+	computed: {
+		isMultipleSelection: ({ prop: e }) => e("selectionMode") === "multiple",
+		isTypingAhead: ({ refs: e }) => e.get("typeaheadState").keysSoFar.length > 0,
+		visibleNodes: ({ prop: e, context: n }) => {
+			let r = [];
+			return e("collection").visit({
+				skip: skipFn({
+					prop: e,
+					context: n
+				}),
+				onEnter: (e, n) => {
+					r.push({
+						node: e,
+						indexPath: n
+					});
+				}
+			}), r;
+		}
+	},
+	on: {
+		"EXPANDED.SET": { actions: ["setExpanded"] },
+		"EXPANDED.CLEAR": { actions: ["clearExpanded"] },
+		"EXPANDED.ALL": { actions: ["expandAllBranches"] },
+		"BRANCH.EXPAND": { actions: ["expandBranches"] },
+		"BRANCH.COLLAPSE": { actions: ["collapseBranches"] },
+		"SELECTED.SET": { actions: ["setSelected"] },
+		"SELECTED.ALL": [{
+			guard: X("isMultipleSelection", "moveFocus"),
+			actions: ["selectAllNodes", "focusTreeLastNode"]
+		}, {
+			guard: "isMultipleSelection",
+			actions: ["selectAllNodes"]
+		}],
+		"SELECTED.CLEAR": { actions: ["clearSelected"] },
+		"NODE.SELECT": { actions: ["selectNode"] },
+		"NODE.DESELECT": { actions: ["deselectNode"] },
+		"CHECKED.TOGGLE": { actions: ["toggleChecked"] },
+		"CHECKED.SET": { actions: ["setChecked"] },
+		"CHECKED.CLEAR": { actions: ["clearChecked"] },
+		"NODE.FOCUS": { actions: ["setFocusedNode"] },
+		"NODE.ARROW_DOWN": [{
+			guard: X("isShiftKey", "isMultipleSelection"),
+			actions: ["focusTreeNextNode", "extendSelectionToNextNode"]
+		}, { actions: ["focusTreeNextNode"] }],
+		"NODE.ARROW_UP": [{
+			guard: X("isShiftKey", "isMultipleSelection"),
+			actions: ["focusTreePrevNode", "extendSelectionToPrevNode"]
+		}, { actions: ["focusTreePrevNode"] }],
+		"NODE.ARROW_LEFT": { actions: ["focusBranchNode"] },
+		"BRANCH_NODE.ARROW_LEFT": [{
+			guard: "isBranchExpanded",
+			actions: ["collapseBranch"]
+		}, { actions: ["focusBranchNode"] }],
+		"BRANCH_NODE.ARROW_RIGHT": [{
+			guard: X("isBranchFocused", "isBranchExpanded"),
+			actions: ["focusBranchFirstNode"]
+		}, { actions: ["expandBranch"] }],
+		"SIBLINGS.EXPAND": { actions: ["expandSiblingBranches"] },
+		"NODE.HOME": [{
+			guard: X("isShiftKey", "isMultipleSelection"),
+			actions: ["extendSelectionToFirstNode", "focusTreeFirstNode"]
+		}, { actions: ["focusTreeFirstNode"] }],
+		"NODE.END": [{
+			guard: X("isShiftKey", "isMultipleSelection"),
+			actions: ["extendSelectionToLastNode", "focusTreeLastNode"]
+		}, { actions: ["focusTreeLastNode"] }],
+		"NODE.CLICK": [
+			{
+				guard: X("isCtrlKey", "isMultipleSelection"),
+				actions: ["toggleNodeSelection"]
+			},
+			{
+				guard: X("isShiftKey", "isMultipleSelection"),
+				actions: ["extendSelectionToNode"]
+			},
+			{ actions: ["selectNode"] }
+		],
+		"BRANCH_NODE.CLICK": [
+			{
+				guard: X("isCtrlKey", "isMultipleSelection"),
+				actions: ["toggleNodeSelection"]
+			},
+			{
+				guard: X("isShiftKey", "isMultipleSelection"),
+				actions: ["extendSelectionToNode"]
+			},
+			{
+				guard: "expandOnClick",
+				actions: ["selectNode", "toggleBranchNode"]
+			},
+			{ actions: ["selectNode"] }
+		],
+		"BRANCH_TOGGLE.CLICK": { actions: ["toggleBranchNode"] },
+		"TREE.TYPEAHEAD": { actions: ["focusMatchedNode"] }
+	},
+	exit: ["clearPendingAborts"],
+	states: {
+		idle: { on: { "NODE.RENAME": {
+			target: "renaming",
+			actions: ["setRenamingValue"]
+		} } },
+		renaming: {
+			entry: ["syncRenameInput", "focusRenameInput"],
+			on: {
+				"RENAME.SUBMIT": {
+					guard: "isRenameLabelValid",
+					target: "idle",
+					actions: ["submitRenaming"]
+				},
+				"RENAME.CANCEL": {
+					target: "idle",
+					actions: ["cancelRenaming"]
+				}
+			}
+		}
+	},
+	implementations: {
+		guards: {
+			isBranchFocused: ({ context: e, event: n }) => e.get("focusedValue") === n.id,
+			isBranchExpanded: ({ context: e, event: n }) => e.get("expandedValue").includes(n.id),
+			isShiftKey: ({ event: e }) => e.shiftKey,
+			isCtrlKey: ({ event: e }) => e.ctrlKey,
+			hasSelectedItems: ({ context: e }) => e.get("selectedValue").length > 0,
+			isMultipleSelection: ({ prop: e }) => e("selectionMode") === "multiple",
+			moveFocus: ({ event: e }) => !!e.moveFocus,
+			expandOnClick: ({ prop: e }) => !!e("expandOnClick"),
+			isRenameLabelValid: ({ event: e }) => e.label.trim() !== ""
+		},
+		actions: {
+			selectNode({ context: e, event: n }) {
+				let r = n.id || n.value;
+				e.set("selectedValue", (e) => r == null ? e : !n.isTrusted && isArray(r) ? e.concat(...r) : [isArray(r) ? last(r) : r].filter(Boolean));
+			},
+			deselectNode({ context: e, event: n }) {
+				let r = toArray$1(n.id || n.value);
+				e.set("selectedValue", (e) => P(e, ...r));
+			},
+			setFocusedNode({ context: e, event: n }) {
+				e.set("focusedValue", n.id);
+			},
+			clearFocusedNode({ context: e }) {
+				e.set("focusedValue", null);
+			},
+			clearSelectedItem({ context: e }) {
+				e.set("selectedValue", []);
+			},
+			toggleBranchNode({ context: e, event: n, action: r }) {
+				r(e.get("expandedValue").includes(n.id) ? ["collapseBranch"] : ["expandBranch"]);
+			},
+			expandBranch(e) {
+				let { event: n } = e;
+				expandBranches(e, [n.id]);
+			},
+			expandBranches(e) {
+				let { context: n, event: r } = e;
+				expandBranches(e, diff(toArray$1(r.value), n.get("expandedValue")));
+			},
+			collapseBranch({ context: e, event: n }) {
+				e.set("expandedValue", (e) => P(e, n.id));
+			},
+			collapseBranches(e) {
+				let { context: n, event: r } = e, i = toArray$1(r.value);
+				n.set("expandedValue", (e) => P(e, ...i));
+			},
+			setExpanded({ context: e, event: n }) {
+				isArray(n.value) && e.set("expandedValue", n.value);
+			},
+			clearExpanded({ context: e }) {
+				e.set("expandedValue", []);
+			},
+			setSelected({ context: e, event: n }) {
+				isArray(n.value) && e.set("selectedValue", n.value);
+			},
+			clearSelected({ context: e }) {
+				e.set("selectedValue", []);
+			},
+			focusTreeFirstNode(e) {
+				let { prop: n, scope: r } = e, i = n("collection"), a = i.getFirstNode(void 0, { skip: skipFn(e) });
+				if (!a) return;
+				let o = i.getNodeValue(a);
+				scrollToNode(e, o) ? raf(() => focusNode(r, o)) : focusNode(r, o);
+			},
+			focusTreeLastNode(e) {
+				let { prop: n, scope: r } = e, i = n("collection"), a = i.getLastNode(void 0, { skip: skipFn(e) }), o = i.getNodeValue(a);
+				scrollToNode(e, o) ? raf(() => focusNode(r, o)) : focusNode(r, o);
+			},
+			focusBranchFirstNode(e) {
+				let { event: n, prop: r, scope: i } = e, a = r("collection"), o = a.findNode(n.id), s = a.getFirstNode(o, { skip: skipFn(e) });
+				if (!s) return;
+				let c = a.getNodeValue(s);
+				scrollToNode(e, c) ? raf(() => focusNode(i, c)) : focusNode(i, c);
+			},
+			focusTreeNextNode(e) {
+				let { event: n, prop: r, scope: i } = e, a = r("collection"), o = a.getNextNode(n.id, { skip: skipFn(e) });
+				if (!o) return;
+				let s = a.getNodeValue(o);
+				scrollToNode(e, s) ? raf(() => focusNode(i, s)) : focusNode(i, s);
+			},
+			focusTreePrevNode(e) {
+				let { event: n, prop: r, scope: i } = e, a = r("collection"), o = a.getPreviousNode(n.id, { skip: skipFn(e) });
+				if (!o) return;
+				let s = a.getNodeValue(o);
+				scrollToNode(e, s) ? raf(() => focusNode(i, s)) : focusNode(i, s);
+			},
+			focusBranchNode(e) {
+				let { event: n, prop: r, scope: i } = e, a = r("collection"), o = a.getParentNode(n.id), s = o ? a.getNodeValue(o) : void 0;
+				s && (scrollToNode(e, s) ? raf(() => focusNode(i, s)) : focusNode(i, s));
+			},
+			selectAllNodes({ context: e, prop: n }) {
+				e.set("selectedValue", n("collection").getValues());
+			},
+			focusMatchedNode(e) {
+				let { context: n, prop: r, refs: i, event: a, scope: o, computed: s } = e, c = R(s("visibleNodes").map(({ node: e }) => ({
+					textContent: r("collection").stringifyNode(e),
+					id: r("collection").getNodeValue(e)
+				})), {
+					state: i.get("typeaheadState"),
+					activeId: n.get("focusedValue"),
+					key: a.key
+				});
+				c?.id && (scrollToNode(e, c.id) ? raf(() => focusNode(o, c.id)) : focusNode(o, c.id));
+			},
+			toggleNodeSelection({ context: e, event: n }) {
+				let r = addOrRemove(e.get("selectedValue"), n.id);
+				e.set("selectedValue", r);
+			},
+			expandAllBranches(e) {
+				let { context: n, prop: r } = e;
+				expandBranches(e, diff(r("collection").getBranchValues(), n.get("expandedValue")));
+			},
+			expandSiblingBranches(e) {
+				let { context: n, event: r, prop: i } = e, a = i("collection"), o = a.getIndexPath(r.id);
+				o && expandBranches(e, diff(a.getSiblingNodes(o).map((e) => a.getNodeValue(e)), n.get("expandedValue")));
+			},
+			extendSelectionToNode(e) {
+				let { context: n, event: r, prop: i, computed: a } = e, o = i("collection"), s = first(n.get("selectedValue")) || o.getNodeValue(o.getFirstNode()), c = r.id, l = [s, c], u = 0;
+				a("visibleNodes").forEach(({ node: e }) => {
+					let n = o.getNodeValue(e);
+					u === 1 && l.push(n), (n === s || n === c) && u++;
+				}), n.set("selectedValue", uniq(l));
+			},
+			extendSelectionToNextNode(e) {
+				let { context: n, event: r, prop: i } = e, a = i("collection"), o = a.getNextNode(r.id, { skip: skipFn(e) });
+				if (!o) return;
+				let s = new Set(n.get("selectedValue")), c = a.getNodeValue(o);
+				c != null && (s.has(r.id) && s.has(c) ? s.delete(r.id) : s.has(c) || s.add(c), n.set("selectedValue", Array.from(s)));
+			},
+			extendSelectionToPrevNode(e) {
+				let { context: n, event: r, prop: i } = e, a = i("collection"), o = a.getPreviousNode(r.id, { skip: skipFn(e) });
+				if (!o) return;
+				let s = new Set(n.get("selectedValue")), c = a.getNodeValue(o);
+				c != null && (s.has(r.id) && s.has(c) ? s.delete(r.id) : s.has(c) || s.add(c), n.set("selectedValue", Array.from(s)));
+			},
+			extendSelectionToFirstNode(e) {
+				let { context: n, prop: r } = e, i = r("collection"), a = first(n.get("selectedValue")), o = [];
+				i.visit({
+					skip: skipFn(e),
+					onEnter: (e) => {
+						let n = i.getNodeValue(e);
+						if (o.push(n), n === a) return "stop";
+					}
+				}), n.set("selectedValue", o);
+			},
+			extendSelectionToLastNode(e) {
+				let { context: n, prop: r } = e, i = r("collection"), a = first(n.get("selectedValue")), o = [], s = !1;
+				i.visit({
+					skip: skipFn(e),
+					onEnter: (e) => {
+						let n = i.getNodeValue(e);
+						n === a && (s = !0), s && o.push(n);
+					}
+				}), n.set("selectedValue", o);
+			},
+			clearPendingAborts({ refs: e }) {
+				let n = e.get("pendingAborts");
+				n.forEach((e) => e.abort()), n.clear();
+			},
+			toggleChecked({ context: e, event: n, prop: r }) {
+				let i = r("collection");
+				e.set("checkedValue", (e) => n.isBranch ? toggleBranchChecked(i, n.value, e) : addOrRemove(e, n.value));
+			},
+			setChecked({ context: e, event: n }) {
+				e.set("checkedValue", n.value);
+			},
+			clearChecked({ context: e }) {
+				e.set("checkedValue", []);
+			},
+			setRenamingValue({ context: e, event: n, prop: r }) {
+				e.set("renamingValue", n.value);
+				let i = r("onRenameStart");
+				if (i) {
+					let e = r("collection"), a = e.getIndexPath(n.value);
+					if (a) {
+						let r = e.at(a);
+						r && i({
+							value: n.value,
+							node: r,
+							indexPath: a
+						});
+					}
+				}
+			},
+			submitRenaming({ context: e, event: n, prop: r, scope: i }) {
+				let a = e.get("renamingValue");
+				if (!a) return;
+				let o = r("collection").getIndexPath(a);
+				if (!o) return;
+				let s = n.label.trim(), c = r("onBeforeRename");
+				if (c && !c({
+					value: a,
+					label: s,
+					indexPath: o
+				})) {
+					e.set("renamingValue", null), focusNode(i, a);
+					return;
+				}
+				r("onRenameComplete")?.({
+					value: a,
+					label: s,
+					indexPath: o
+				}), e.set("renamingValue", null), focusNode(i, a);
+			},
+			cancelRenaming({ context: e, scope: n }) {
+				let r = e.get("renamingValue");
+				e.set("renamingValue", null), r && focusNode(n, r);
+			},
+			syncRenameInput({ context: e, scope: n, prop: r }) {
+				let i = e.get("renamingValue");
+				if (!i) return;
+				let a = r("collection"), o = a.findNode(i);
+				if (!o) return;
+				let s = a.stringifyNode(o);
+				setElementValue(getRenameInputEl(n, i), s);
+			},
+			focusRenameInput({ context: e, scope: n }) {
+				let r = e.get("renamingValue");
+				if (!r) return;
+				let i = getRenameInputEl(n, r);
+				i && (i.focus(), i.select());
+			}
+		}
+	}
+});
+function scrollToNode(e, n) {
+	let { prop: r, scope: i, computed: a } = e, o = r("scrollToIndexFn");
+	if (!o) return !1;
+	let s = r("collection"), c = a("visibleNodes");
+	for (let e = 0; e < c.length; e++) {
+		let { node: r, indexPath: a } = c[e];
+		if (s.getNodeValue(r) === n) return o({
+			index: e,
+			node: r,
+			indexPath: a,
+			getElement: () => i.getById(getNodeId(i, n))
+		}), !0;
+	}
+	return !1;
+}
+createProps()(/* @__PURE__ */ "ids.collection.dir.expandedValue.expandOnClick.defaultFocusedValue.focusedValue.getRootNode.id.onExpandedChange.onFocusChange.onSelectionChange.checkedValue.selectedValue.selectionMode.typeahead.defaultExpandedValue.defaultSelectedValue.defaultCheckedValue.onCheckedChange.onLoadChildrenComplete.onLoadChildrenError.loadChildren.canRename.onRenameStart.onBeforeRename.onRenameComplete.scrollToIndexFn".split(".")), createProps()(["node", "indexPath"]);
+//#endregion
+//#region ../diagram/src/adhoc-editor/useElementsTree.ts
+function getElementState(e, n) {
+	return n ? n.disabled.has(e) ? "disabled" : n.includedExplicit.has(e) ? "include-explicit" : n.includedImplicit.has(e) ? "include-implicit" : n.excluded.has(e) ? "exclude" : "not-present" : "not-present";
+}
+function mapToTreeNodes(e, n) {
+	return qe(e).map((e) => ({
+		id: e.id,
+		title: e.title,
+		shape: e.shape,
+		icon: e.icon ?? void 0,
+		children: mapToTreeNodes(e.children(), n),
+		state: getElementState(e.id, n)
+	}));
+}
+function createTreeCollection(e, n) {
+	return collection({
+		rootNode: {
+			id: "@ROOT",
+			title: "",
+			shape: "rectangle",
+			icon: void 0,
+			children: mapToTreeNodes(e.roots(), n),
+			state: "not-present"
+		},
+		nodeToValue(e) {
+			return e.id;
+		},
+		nodeToString(e) {
+			return e.title;
+		},
+		nodeToChildren(e) {
+			return e.children;
+		},
+		isNodeDisabled() {
+			return !1;
+		}
+	});
+}
+var zt = selectEditorPanelState((e) => ({
+	searchInput: e.searchInput.length > 2 ? e.searchInput.toLowerCase() : "",
+	collection: e.collection
+}), (e, n) => e?.searchInput === n.searchInput && e?.collection.isEqual(n.collection));
+function useElementsTree() {
+	let e = O(21), { searchInput: n, collection: r } = useEditorPanelState(zt), o = Le(n), s;
+	bb0: {
+		if (!o) {
+			s = r;
+			break bb0;
+		}
+		let n;
+		if (e[0] !== r || e[1] !== o) {
+			let t2;
+			e[3] === o ? t2 = e[4] : (t2 = (e) => e.title.toLowerCase().includes(o), e[3] = o, e[4] = t2), n = r.filter(t2), e[0] = r, e[1] = o, e[2] = n;
+		} else n = e[2];
+		s = n;
+	}
+	let c = s, u;
+	e[5] === Symbol.for("react.memo_cache_sentinel") ? (u = [], e[5] = u) : u = e[5];
+	let [d, f] = D(u), t2;
+	e[6] !== r || e[7] !== c ? (t2 = () => {
+		c !== r && f((e) => {
+			let n = a(c.getBranchValues(), e);
+			return i(n, 1) ? l([...e, ...n], Ve()) : e;
+		});
+	}, e[6] = r, e[7] = c, e[8] = t2) : t2 = e[8];
+	let p;
+	e[9] === c ? p = e[10] : (p = [c], e[9] = c, e[10] = p), w(t2, p);
+	let m = he(), h, g;
+	e[11] === Symbol.for("react.memo_cache_sentinel") ? (h = [], g = [], e[11] = h, e[12] = g) : (h = e[11], g = e[12]);
+	let _;
+	e[13] !== d || e[14] !== c || e[15] !== m ? (_ = {
+		id: m,
+		collection: c,
+		defaultCheckedValue: h,
+		defaultSelectedValue: g,
+		expandedValue: d,
+		onExpandedChange(e) {
+			let { expandedValue: n } = e;
+			f(n);
+		},
+		onFocusChange(e) {
+			console.log("Focus change", e);
+		},
+		onSelectionChange(e) {
+			console.log("Selection change", e);
+		}
+	}, e[13] = d, e[14] = c, e[15] = m, e[16] = _) : _ = e[16];
+	let v = useMachine(Rt, _);
+	v.context.get("focusedValue")?.slice;
+	let y;
+	e[17] === v ? y = e[18] : (y = connect(v, _t), e[17] = v, e[18] = y);
+	let b = y, t9;
+	return e[19] === b ? t9 = e[20] : (t9 = () => {
+		let e = b.collection.getFirstNode()?.id;
+		e && b.focus(e);
+	}, e[19] = b, e[20] = t9), useOnEditorPanelEvent("inputKeyDown", t9), b;
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/state/utils.ts
+function deriveElementStates({ rules: e, view: i }) {
+	let a = new Set(i ? i.nodes.map((e) => e.modelRef ?? null).filter(r) : []), s = o(e, n((e) => e.type === "include" && e.enabled), c((e) => e.expr.ref.model), N()), l = o(e, n((e) => e.type === "exclude" && e.enabled), c((e) => e.expr.ref.model), N());
+	return {
+		disabled: o(e, n((e) => !e.enabled), c((e) => e.expr.ref.model), N()),
+		includedExplicit: s,
+		includedImplicit: He(a, s),
+		excluded: He(l, a)
+	};
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/state/panel.tsx
+var createEditorPanelStore = ({ initial: e, sideEffects: n }) => createStore({
+	context: {
+		searchInput: "",
+		expandedValue: [],
+		collection: e
+	},
+	emits: { inputKeyDown: (e) => {} },
+	on: {
+		inputChange: (e, n) => ({
+			...e,
+			searchInput: n.value
+		}),
+		inputKeyDown: (e, n, r) => {
+			r.emit.inputKeyDown();
+		},
+		modelUpdate: (e, n) => ({
+			...e,
+			collection: n.collection
+		}),
+		elementClick: (e, r, i) => {
+			let a = e.collection.findNode(r.id), o = e.collection.getIndexPath(r.id);
+			return !a || !o || i.effect(() => {
+				n.onElementStateClick({ id: r.id });
+			}), e;
+		}
+	}
+}), Bt = Pe(null), EditorPanelStoreProvider = (e) => {
+	let n = Se(), r = E(n);
+	r.current = n;
+	let i = useAdhocEditorActor(), a = T(() => createEditorPanelStore({
+		initial: createTreeCollection(n),
+		sideEffects: { onElementStateClick({ id: e }) {
+			i.send({
+				type: "toggle.element",
+				id: e
+			});
+		} }
+	}), [i]);
+	return ge(() => {
+		a.trigger.modelUpdate({ collection: createTreeCollection(n, deriveElementStates(i.getSnapshot().context)) });
+	}, [n]), w(() => {
+		let e = i.on("view.update", () => {
+			a.trigger.modelUpdate({ collection: createTreeCollection(r.current, deriveElementStates(i.getSnapshot().context)) });
+		});
+		return () => {
+			e.unsubscribe();
+		};
+	}, [i]), /* @__PURE__ */ k(Bt.Provider, {
+		value: a,
+		children: e.children
+	});
+};
+function selectEditorPanelState(e, n) {
+	return [(n) => e(n.context), n ?? shallowEqual];
+}
+function useEditorPanelStore() {
+	return Ie(Bt);
+}
+function useEditorPanelState(...e) {
+	let n = O(4), r = e, a = useEditorPanelStore(), o, s;
+	if (r.length === 2) [o, s] = r;
+	else if (r.length === 1 && Array.isArray(r[0]) && i(r[0], 2)) [o, s] = r[0];
+	else if (r.length === 1 && Array.isArray(r[0]) && i(r[0], 1)) {
+		let e = r[0], i;
+		n[0] === e ? i = n[1] : (i = [e, shallowEqual], n[0] = e, n[1] = i), [o, s] = i;
+	} else if (r.length === 1 && typeof r[0] == "function") {
+		let e = r[0], i;
+		n[2] === e ? i = n[3] : (i = [e, shallowEqual], n[2] = e, n[3] = i), [o, s] = i;
+	} else throw Error("Invalid arguments for useEditorPanelState");
+	return useSelector(a, o, s);
+}
+function useOnEditorPanelEvent(...e) {
+	let n = O(7), r = e, i = useEditorPanelStore(), a = r[0], o = ue(r[1]), t1;
+	n[0] !== a || n[1] !== o || n[2] !== i ? (t1 = () => {
+		let e = i.on(a, o);
+		return () => {
+			e.unsubscribe();
+		};
+	}, n[0] = a, n[1] = o, n[2] = i, n[3] = t1) : t1 = n[3];
+	let s;
+	n[4] !== a || n[5] !== i ? (s = [a, i], n[4] = a, n[5] = i, n[6] = s) : s = n[6], w(t1, s);
+}
+function useEditorPanelTrigger(...e) {
+	let n = useEditorPanelStore();
+	if (e.length === 0) return n.trigger;
+	let r = e[0];
+	return ue((...e) => {
+		r(n.trigger, ...e);
+	});
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/ElementsTree.tsx
+var Vt = C(() => {
+	let e = O(20), n = useElementsTree(), t0;
+	e[0] === n ? t0 = e[1] : (t0 = (e, r) => {
+		let i = r.currentTarget.closest("[data-value]")?.getAttribute("data-value");
+		if (i) try {
+			r.stopPropagation(), r.preventDefault(), n.expand([i]), e.elementClick({ id: i });
+		} catch (e) {
+			console.error("Failed to handle element click", e);
+		}
+	}, e[0] = n, e[1] = t0);
+	let r = useEditorPanelTrigger(t0), i;
+	if (e[2] !== n) {
+		let t2;
+		e[4] === n.selectedValue ? t2 = e[5] : (t2 = (e) => {
+			bb32: switch (e.key) {
+				case "Escape": {
+					let n = document.getElementById("search-input");
+					n && (e.stopPropagation(), e.preventDefault(), n.focus());
+					break bb32;
+				}
+				case "ArrowUp": break bb32;
+				default: return;
+			}
+		}, e[4] = n.selectedValue, e[5] = t2), i = mergeProps(n.getRootProps(), { onKeyDown: t2 }), e[2] = n, e[3] = i;
+	} else i = e[3];
+	let a = i, o;
+	e[6] === n ? o = e[7] : (o = n.getTreeProps(), e[6] = n, e[7] = o);
+	let s;
+	e[8] !== n || e[9] !== r ? (s = n.collection.rootNode.children.map((e, i) => /* @__PURE__ */ k(TreeNode, {
+		node: e,
+		api: n,
+		onClick: r
+	}, e.id)), e[8] = n, e[9] = r, e[10] = s) : s = e[10];
+	let c;
+	e[11] === n.collection ? c = e[12] : (c = !n.collection.getFirstNode() && /* @__PURE__ */ k(y, {
+		css: {
+			p: "4",
+			textAlign: "center"
+		},
+		children: "Nothing found"
+	}), e[11] = n.collection, e[12] = c);
+	let l;
+	e[13] !== o || e[14] !== s || e[15] !== c ? (l = /* @__PURE__ */ A(V.Root, {
+		...o,
+		children: [s, c]
+	}), e[13] = o, e[14] = s, e[15] = c, e[16] = l) : l = e[16];
+	let u;
+	return e[17] !== a || e[18] !== l ? (u = /* @__PURE__ */ k(h, {
+		flex: "1 1 100%",
+		scrollbars: "y",
+		type: "scroll",
+		scrollbarSize: "4px",
+		...a,
+		children: l
+	}), e[17] = a, e[18] = l, e[19] = u) : u = e[19], u;
+}), TreeNode = (e) => {
+	let n = O(29), { api: r, node: i, onClick: a } = e, o = r.collection, s, c, l, u, d, f;
+	if (n[0] !== r || n[1] !== i || n[2] !== a) {
+		f = Symbol.for("react.early_return_sentinel");
+		bb0: {
+			let e = o.getIndexPath(i.id);
+			Ue(e, "Node not found in collection");
+			let p = {
+				indexPath: e,
+				node: i
+			}, m = r.getNodeState(p);
+			if (m.isBranch) {
+				let e;
+				n[9] === i ? e = n[10] : (e = /* @__PURE__ */ k(V.Icon, { element: i }), n[9] = i, n[10] = e);
+				let o;
+				n[11] !== i || n[12] !== a ? (o = /* @__PURE__ */ k(V.State, {
+					node: i,
+					state: i.state,
+					onClick: a
+				}), n[11] = i, n[12] = a, n[13] = o) : o = n[13], f = /* @__PURE__ */ A(V.Branch, {
+					...r.getBranchProps(p),
+					children: [/* @__PURE__ */ A(V.Control, {
+						...r.getBranchControlProps(p),
+						children: [
+							e,
+							/* @__PURE__ */ A(V.Label, {
+								...r.getBranchTextProps(p),
+								children: [i.title, /* @__PURE__ */ k(V.Indicator, { ...r.getBranchIndicatorProps(p) })]
+							}),
+							o
+						]
+					}), /* @__PURE__ */ k(V.Content, {
+						...r.getBranchContentProps(p),
+						children: m.expanded && i.children.map((e, n) => /* @__PURE__ */ k(TreeNode, {
+							node: e,
+							api: r,
+							onClick: a
+						}, e.id))
+					})]
+				});
+				break bb0;
+			}
+			c = V.Item, u = r.getItemProps(p), n[14] === i ? d = n[15] : (d = /* @__PURE__ */ k(V.Icon, { element: i }), n[14] = i, n[15] = d), s = V.Label, l = r.getItemTextProps(p);
+		}
+		n[0] = r, n[1] = i, n[2] = a, n[3] = s, n[4] = c, n[5] = l, n[6] = u, n[7] = d, n[8] = f;
+	} else s = n[3], c = n[4], l = n[5], u = n[6], d = n[7], f = n[8];
+	if (f !== Symbol.for("react.early_return_sentinel")) return f;
+	let p;
+	n[16] !== s || n[17] !== i.title || n[18] !== l ? (p = /* @__PURE__ */ k(s, {
+		...l,
+		children: i.title
+	}), n[16] = s, n[17] = i.title, n[18] = l, n[19] = p) : p = n[19];
+	let m;
+	n[20] !== i || n[21] !== a ? (m = /* @__PURE__ */ k(V.State, {
+		node: i,
+		state: i.state,
+		onClick: a
+	}), n[20] = i, n[21] = a, n[22] = m) : m = n[22];
+	let h;
+	return n[23] !== c || n[24] !== u || n[25] !== d || n[26] !== p || n[27] !== m ? (h = /* @__PURE__ */ A(c, {
+		...u,
+		children: [
+			d,
+			p,
+			m
+		]
+	}), n[23] = c, n[24] = u, n[25] = d, n[26] = p, n[27] = m, n[28] = h) : h = n[28], h;
+}, EditorPanel = () => {
+	let e = O(6), n;
+	e[0] === Symbol.for("react.memo_cache_sentinel") ? (n = {
+		position: "fixed",
+		top: "0",
+		left: "0",
+		gap: "1",
+		bottom: "0",
+		height: "auto",
+		overflow: "hidden",
+		layerStyle: "likec4.panel",
+		width: "[300px]",
+		rounded: "0"
+	}, e[0] = n) : n = e[0];
+	let r, i;
+	e[1] === Symbol.for("react.memo_cache_sentinel") ? (r = /* @__PURE__ */ k(fe, { style: { height: 16 } }), i = /* @__PURE__ */ k(te, {
+		size: "sm",
+		fontWeight: "medium",
+		flex: "1",
+		children: "Explore"
+	}), e[1] = r, e[2] = i) : (r = e[1], i = e[2]);
+	let a;
+	e[3] === Symbol.for("react.memo_cache_sentinel") ? (a = /* @__PURE__ */ A(re, {
+		p: "2",
+		gap: "4",
+		justifyItems: "stretch",
+		children: [
+			r,
+			i,
+			/* @__PURE__ */ k(re, {
+				gap: "1",
+				children: /* @__PURE__ */ k(f, { children: /* @__PURE__ */ k(Je, {}) })
+			})
+		]
+	}), e[3] = a) : a = e[3];
+	let o;
+	e[4] === Symbol.for("react.memo_cache_sentinel") ? (o = /* @__PURE__ */ k(y, { children: /* @__PURE__ */ k(SearchInput, {}) }), e[4] = o) : o = e[4];
+	let s;
+	return e[5] === Symbol.for("react.memo_cache_sentinel") ? (s = /* @__PURE__ */ k(EditorPanelStoreProvider, { children: /* @__PURE__ */ k(Te, {
+		mode: "popLayout",
+		children: /* @__PURE__ */ A(_, {
+			css: n,
+			onClick: _temp,
+			children: [
+				a,
+				o,
+				/* @__PURE__ */ k(Ne, { children: /* @__PURE__ */ k(Vt, {}) })
+			]
+		})
+	}) }), e[5] = s) : s = e[5], s;
+}, Ht = selectEditorPanelState(d("searchInput"));
+function SearchInput() {
+	let e = O(13), n = useEditorPanelState(Ht), r = useEditorPanelTrigger(), i = useEditorPanelTrigger(_temp2), a = useEditorPanelTrigger(_temp3), o = n ? void 0 : "none", s;
+	e[0] === o ? s = e[1] : (s = { display: o }, e[0] = o, e[1] = s);
+	let c;
+	e[2] !== a || e[3] !== s ? (c = /* @__PURE__ */ k(p, {
+		size: "sm",
+		"aria-label": "Clear input",
+		onClick: a,
+		style: s
+	}), e[2] = a, e[3] = s, e[4] = c) : c = e[4];
+	let t3;
+	e[5] !== a || e[6] !== r ? (t3 = (e) => {
+		bb8: switch (e.key) {
+			case "Escape":
+				e.stopPropagation(), e.preventDefault(), a();
+				break bb8;
+			case "Enter":
+				e.stopPropagation(), e.preventDefault();
+				break bb8;
+			case "ArrowDown":
+				e.stopPropagation(), e.preventDefault(), r.inputKeyDown();
+				break bb8;
+			default: return;
+		}
+	}, e[5] = a, e[6] = r, e[7] = t3) : t3 = e[7];
+	let l;
+	return e[8] !== n || e[9] !== i || e[10] !== c || e[11] !== t3 ? (l = /* @__PURE__ */ k(y, { children: /* @__PURE__ */ k(m, {
+		id: "search-input",
+		size: "xs",
+		variant: "filled",
+		placeholder: "Search by title, description or start with # or kind:",
+		value: n,
+		onChange: i,
+		"data-likec4-search-input": !0,
+		rightSectionPointerEvents: "all",
+		rightSection: c,
+		onKeyDownCapture: t3
+	}) }), e[8] = n, e[9] = i, e[10] = c, e[11] = t3, e[12] = l) : l = e[12], l;
+}
+function _temp3(e) {
+	e.inputChange({ value: "" });
+}
+function _temp2(e, n) {
+	e.inputChange({ value: n.currentTarget.value });
+}
+function _temp(e) {
+	e.stopPropagation();
+	let n = document.getElementById("search-input");
+	n && n.focus();
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/state/actor.types.ts
+function ruleToPredicate(e) {
+	return e.type === "include" ? { include: [e.expr] } : { exclude: [e.expr] };
+}
+var Z = Oe({
+	types: {
+		context: {},
+		tags: "",
+		events: {},
+		emitted: {}
+	},
+	actors: { service: {} },
+	guards: { hasView: ({ context: e }) => e.view !== null }
+});
+function createContext$1() {
+	return {
+		view: null,
+		error: void 0,
+		rules: []
+	};
+}
+e(createContext$1, "createContext");
+//#endregion
+//#region ../diagram/src/adhoc-editor/state/actor.layouter.ts
+var Q = {
+	idle: { target: "#layouter-idle" },
+	call: { target: "#layouter-call" }
+}, Ut = Z.createStateConfig({
+	id: Q.idle.target.substring(1),
+	entry: S("entry idle ->"),
+	exit: S(" -> idle exit "),
+	on: { layout: { ...Q.call } }
+}), emitViewUpdate = () => Z.emit({ type: "view.update" }), Wt = t(n((e) => e.enabled), c(ruleToPredicate)), Gt = Z.createStateConfig({
+	id: Q.call.target.substring(1),
+	entry: S("entry call ->"),
+	exit: S(" -> call exit "),
+	invoke: {
+		src: "service",
+		input: ({ context: e }) => ({ predicates: Wt(e.rules) }),
+		onDone: {
+			actions: [ke({
+				view: ({ context: e, event: n }) => {
+					let r = Ge(Wt(e.rules));
+					return {
+						...n.output.view,
+						hash: r,
+						id: r
+					};
+				},
+				error: void 0
+			}), Ee({ type: "view.update" })],
+			...Q.idle
+		},
+		onError: {
+			actions: [S(({ event: e }) => `error: ${e.error}`), ke({ error: ({ event: e }) => `${e.error}` })],
+			...Q.idle
+		}
+	}
+}), Kt = Z.createStateConfig({
+	initial: "idle",
+	states: {
+		idle: Ut,
+		call: Gt
+	}
+}), $ = {
+	idle: { target: "#idle" },
+	selecting: { target: "#selecting" },
+	layouting: { target: "#layouting" }
+};
+function nextId({ rules: e }, n = "") {
+	return Ke((e.at(-1)?.id ?? (/* @__PURE__ */ new Date()).toISOString()) + n);
+}
+var isRuleOf = (e) => (n) => M.isModelRef(n.expr) && n.expr.ref.model === e, isIncludeOf = (e) => (n) => n.type === "include" && M.isModelRef(n.expr) && n.expr.ref.model === e, isExcludeOf = (e) => (n) => n.type === "exclude" && M.isModelRef(n.expr) && n.expr.ref.model === e;
+function deriveElementState(e, { rules: n, view: r }) {
+	let i = n.find(isRuleOf(e));
+	if (i && !i.enabled) return {
+		state: "disabled",
+		ruleId: i.id
+	};
+	let a = r ? r.nodes.some((n) => n.modelRef === e) : !1, o = n.find(isIncludeOf(e)), s = n.find(isExcludeOf(e));
+	switch (!0) {
+		case o && a: return {
+			state: "include-explicit",
+			ruleId: o.id
+		};
+		case !o && a: return {
+			state: "include-implicit",
+			ruleId: void 0
+		};
+		case o && !a: return {
+			state: "not-present",
+			ruleId: o.id
+		};
+		case !!s: return {
+			state: "exclude",
+			ruleId: s.id
+		};
+		default: return Ue(a === !1, "Element not in view should not be included or excluded by any rule"), {
+			state: "not-present",
+			ruleId: void 0
+		};
+	}
+}
+var enableRule = (e) => Z.assign(({ context: n }) => ({ rules: n.rules.map((n) => n.id === e && !n.enabled ? {
+	...n,
+	enabled: !0
+} : n) })), addElementRules = (e, n) => Z.assign(({ context: r }) => ({ rules: [...r.rules, {
+	id: nextId(r, n + e),
+	expr: { ref: { model: e } },
+	enabled: !0,
+	type: n
+}] })), removeElementRules = (e) => Z.assign(({ context: n }) => {
+	let r = isRuleOf(e);
+	return { rules: n.rules.filter((e) => !r(e)) };
+}), toggleElement = () => Z.enqueueActions(({ context: e, event: n, enqueue: r }) => {
+	x(n, "toggle.element");
+	let i = isRuleOf(n.id), a = s(e.rules);
+	if (a && i(a)) {
+		r.assign({ rules: e.rules.slice(0, -1) });
+		return;
+	}
+	let o = deriveElementState(n.id, e);
+	switch (o.state) {
+		case "disabled":
+			r(enableRule(o.ruleId));
+			break;
+		case "not-present":
+			r(removeElementRules(n.id)), r(addElementRules(n.id, "include"));
+			break;
+		case "include-implicit":
+			r(removeElementRules(n.id)), r(addElementRules(n.id, "exclude"));
+			break;
+		case "include-explicit":
+		case "exclude":
+			r(removeElementRules(n.id));
+			break;
+		default: We(o);
+	}
+}), toggleRule = () => Z.assign(({ context: e, event: n }) => (x(n, "toggle.rule"), { rules: e.rules.map((e) => e.id === n.ruleId ? {
+	...e,
+	enabled: !e.enabled
+} : e) })), deleteRule = () => Z.assign(({ context: e, event: n }) => (x(n, "delete.rule"), { rules: e.rules.filter((e) => e.id !== n.ruleId) })), scheduleLayout = () => Z.raise({ type: "layout" }), qt = Z.createStateConfig({
+	id: "idle",
+	on: {
+		"select.open": { ...$.selecting },
+		"toggle.rule": {
+			actions: toggleRule(),
+			...$.layouting
+		},
+		"delete.rule": {
+			actions: deleteRule(),
+			...$.layouting
+		}
+	}
+}), Jt = Z.createStateConfig({
+	id: "selecting",
+	on: {
+		"toggle.element": { actions: [
+			toggleElement(),
+			emitViewUpdate(),
+			scheduleLayout()
+		] },
+		"select.close": { ...$.idle }
+	}
+}), Yt = Z.createStateConfig({
+	id: "layouting",
+	always: {
+		actions: scheduleLayout(),
+		...$.idle
+	}
+}), Xt = Z.createStateConfig({
+	initial: "selecting",
+	states: {
+		idle: qt,
+		selecting: Jt,
+		layouting: Yt
+	}
+}), Zt = Z.createMachine({
+	id: "adhoc-editor",
+	context: createContext$1,
+	type: "parallel",
+	states: {
+		layouter: Kt,
+		editor: Xt
+	}
+}), Qt = {
+	read: () => JSON.parse(sessionStorage.getItem("adhoc-editor-state") || "null") ?? void 0,
+	write: (e) => sessionStorage.setItem("adhoc-editor-state", JSON.stringify(e))
+};
+function AdhocEditorActorProvider({ children: e, service: n }) {
+	let r = E(n);
+	r.current = n;
+	let i = T(() => ({ actors: { service: De(({ input: e }) => r.current.process(e)) } }), []), a = je(Zt.provide(i), {
+		id: "adhoc-editor",
+		snapshot: Qt.read(),
+		systemId: "adhoc-editor",
+		inspect: (e) => {
+			console.log("[AdhocEditorActor]", e);
+		}
+	});
+	return w(() => {
+		let e = a.subscribe((e) => {
+			Qt.write(e);
+		});
+		return () => e.unsubscribe();
+	}, [a]), /* @__PURE__ */ k(Pt, {
+		value: a,
+		children: e
+	});
+}
+//#endregion
+//#region ../diagram/src/adhoc-editor/LikeC4AdHocViewEditor.tsx
+var noop = () => {}, $t = {
+	...u(ve, () => !1),
+	enableFitView: !0,
+	enableReadOnly: !0
+};
+function LikeC4AdHocViewEditor({ service: e }) {
+	let n = he(), r = E({
+		fitView: !0,
+		defaultNodes: [],
+		defaultEdges: []
+	});
+	return /* @__PURE__ */ k(le, { children: /* @__PURE__ */ k(me, { children: /* @__PURE__ */ k(Me, {
+		id: "LikeC4AdHocViewEditor",
+		onRender: noop,
+		children: /* @__PURE__ */ k(oe, {
+			value: null,
+			children: /* @__PURE__ */ k(AdhocEditorActorProvider, {
+				service: e,
+				children: /* @__PURE__ */ A(_e, {
+					features: $t,
+					children: [/* @__PURE__ */ k(pe, { id: n }), /* @__PURE__ */ k(xe, {
+						rootSelector: `#${n}`,
+						children: /* @__PURE__ */ k(se, {
+							id: n,
+							children: /* @__PURE__ */ A(we, {
+								...r.current,
+								children: [/* @__PURE__ */ k(en, { id: n }), /* @__PURE__ */ k(EditorPanel, {})]
+							})
+						})
+					})]
+				})
+			})
+		})
+	}) }) });
+}
+var en = C((e) => {
+	let n = O(5), { id: r } = e, i = useAdhocView(), a, o;
+	n[0] === Symbol.for("react.memo_cache_sentinel") ? (a = /* @__PURE__ */ k(ye, {}), o = /* @__PURE__ */ k(tn, {}), n[0] = a, n[1] = o) : (a = n[0], o = n[1]);
+	let s;
+	return n[2] !== r || n[3] !== i ? (s = /* @__PURE__ */ A(be, {
+		id: r,
+		view: i,
+		zoomable: !0,
+		pannable: !0,
+		fitViewPadding: ce.withControls,
+		nodesDraggable: !1,
+		nodesSelectable: !0,
+		children: [a, o]
+	}), n[2] = r, n[3] = i, n[4] = s) : s = n[4], s;
+}), tn = C(() => {
+	let e = O(4), n = useAdhocEditorActor(), r = Ce(), t0, i;
+	return e[0] !== n || e[1] !== r ? (t0 = () => {
+		let e = n.on("click.element", (e) => {
+			let { id: n } = e;
+			r.focusOnElement(n);
+		});
+		return () => e.unsubscribe();
+	}, i = [n, r], e[0] = n, e[1] = r, e[2] = t0, e[3] = i) : (t0 = e[2], i = e[3]), w(t0, i), null;
+});
+//#endregion
+export { LikeC4AdHocViewEditor };