@ankhzet/graph 0.1.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,2283 @@
+import { DisposableEventSource as e } from "@ankhzet/gcl";
+import { debounce as t, isLike as n, matchId as r } from "@ankhzet/utils";
+import { forwardRef as i, useEffect as a, useImperativeHandle as o, useLayoutEffect as s, useMemo as c, useRef as l, useState as u } from "react";
+import { Styles as d, handleAsNoop as f, useDrag as p, useIsomorphicLayoutEffect as m, useLastCallback as h, useMeasure as g, usePrevious as _, useSyncStore as v } from "@ankhzet/ui";
+import { observer as y } from "mobx-react-lite";
+import { jsx as b, jsxs as x } from "react/jsx-runtime";
+import { reaction as S } from "mobx";
+//#region \0rolldown/runtime.js
+var C = Object.defineProperty, w = Object.getOwnPropertyDescriptor, ee = Object.getOwnPropertyNames, te = Object.prototype.hasOwnProperty, ne = (e, t) => {
+	let n = {};
+	for (var r in e) C(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || C(n, Symbol.toStringTag, { value: "Module" }), n;
+}, re = (e, t, n, r) => {
+	if (t && typeof t == "object" || typeof t == "function") for (var i = ee(t), a = 0, o = i.length, s; a < o; a++) s = i[a], !te.call(e, s) && s !== n && C(e, s, {
+		get: ((e) => t[e]).bind(null, s),
+		enumerable: !(r = w(t, s)) || r.enumerable
+	});
+	return e;
+}, T = (e, t, n) => (re(e, t, "default"), n && re(n, t, "default")), E = (e, t, n = 1) => ({
+	x: ~~(e.x + t.x * n),
+	y: ~~(e.y + t.y * n)
+}), D = (e, t) => (n) => n.node === e && n.port === t, ie = (e) => (t) => t.node === e, O = (e, t, n) => {
+	if (n) for (let r of n) {
+		let n = t.nodes.findIndex(D(r.node, r.port));
+		n >= 0 !== e && (e ? t.nodes.push(r) : t.nodes.splice(n, 1));
+	}
+	else e || (t.nodes = []);
+}, ae = (e, t, n, r, i, a, o, s) => {
+	if (e === n && t === r || i === o && a === s) return !1;
+	let c = (s - a) * (n - e) - (o - i) * (r - t);
+	if (c === 0) return !1;
+	let l = ((o - i) * (t - a) - (s - a) * (e - i)) / c, u = ((n - e) * (t - a) - (r - t) * (e - i)) / c;
+	return l < 0 || l > 1 || u < 0 || u > 1 ? !1 : {
+		x: e + l * (n - e),
+		y: t + l * (r - t)
+	};
+}, k = class {
+	joints = /* @__PURE__ */ new Map();
+	parentId;
+	constructor(e, t) {
+		this.parentId = e;
+		for (let e of t) this.joints.set(e.port, e);
+	}
+	[Symbol.iterator]() {
+		return this.joints.values();
+	}
+	get connected() {
+		let e = [];
+		for (let t of this.joints.values()) t.nodes.length && e.push(t);
+		return e;
+	}
+	find(e) {
+		for (let t of this.joints.values()) if (e(t)) return t;
+	}
+	map(e) {
+		let t = Array(this.joints.size), n = 0;
+		for (let r of this.joints.values()) t[n] = e(r, n), n++;
+		return t;
+	}
+	has(e, t) {
+		return !!this.getPort(e, t);
+	}
+	hasAtPort(e, t, n) {
+		return !!this.joints.get(e)?.nodes.some(D(t, n));
+	}
+	getPort(e, t) {
+		let n = this.find(t === void 0 ? (t) => t.nodes.some(ie(e)) : (n) => n.nodes.some(D(e, t)));
+		if (n) return n.port;
+	}
+	connect({ port: e, target: t, connect: n }) {
+		let r = this.joints.get(e);
+		if (!r) throw Error(`Node ${this.parentId} does not have joint "${e}"`);
+		return O(n, r, t), r;
+	}
+	getNodes(e) {
+		return this.joints.get(e)?.nodes;
+	}
+	get ids() {
+		let e = /* @__PURE__ */ new Set();
+		for (let { nodes: t } of this.joints.values()) for (let { node: n } of t) e.add(n);
+		return [...e];
+	}
+	get count() {
+		return this.joints.size;
+	}
+}, oe = Symbol("E_CONNECT"), se = Symbol("E_MOVE"), ce = class extends e {
+	id;
+	description;
+	inputs;
+	outputs;
+	coordinator;
+	#e = {
+		x: 0,
+		y: 0
+	};
+	constructor({ id: e, coordinator: t, inputs: n = [], outputs: r = [], ...i }) {
+		super(), this.id = e, this.coordinator = t, this.description = i, this.inputs = new k(e, n), this.outputs = new k(e, r);
+	}
+	get title() {
+		return this.description.title;
+	}
+	get width() {
+		return this.coordinator.sizes.lane * 2 + this.coordinator.sizes.space;
+	}
+	get height() {
+		return this.coordinator.sizes.lane * Math.max(1, this.inputs.count, this.outputs.count);
+	}
+	get position() {
+		return this.#e;
+	}
+	set position({ x: e, y: t }) {
+		e = this.coordinator.snap(e), t = this.coordinator.snap(t), !(this.#e.x === e && this.#e.y === t) && (this.#e.x = e, this.#e.y = t, this.dispatchEvent(se, this.#e));
+	}
+	isInput(e, t, n) {
+		return this.inputs.hasAtPort(e, t, n);
+	}
+	isOutput(e, t, n) {
+		return this.outputs.hasAtPort(e, t, n);
+	}
+	isConnected(e, t, n) {
+		return t ? this.inputs.hasAtPort(e, n.node, n.port) : this.outputs.hasAtPort(e, n.node, n.port);
+	}
+	getNodes(e, t) {
+		return t ? this.inputs.getNodes(e) : this.outputs.getNodes(e);
+	}
+	connect({ input: e, connect: t, port: n, nodes: r }) {
+		let i = {
+			node: this.id,
+			port: n
+		}, a = r ? r.map(({ node: e, port: t }) => ({
+			node: e.id,
+			port: t
+		})) : this.getNodes(n, e);
+		if (e ? this.inputs.connect({
+			connect: t,
+			port: n,
+			target: a
+		}) : this.outputs.connect({
+			connect: t,
+			port: n,
+			target: a
+		}), r) {
+			let a = [{
+				node: this,
+				port: n
+			}];
+			for (let { node: n, port: o } of r) t !== n.isConnected(o, !e, i) && n.connect({
+				connect: t,
+				input: !e,
+				port: o,
+				nodes: a
+			});
+		}
+		this.dispatchEvent(oe, {
+			connect: t,
+			input: e,
+			source: i,
+			target: a
+		});
+	}
+	move(e) {
+		return this.position = e, this.position;
+	}
+	onConnect(e) {
+		return this.handleEvent(oe, e);
+	}
+	onMove(e) {
+		return this.handleEvent(se, e);
+	}
+}, A = class {
+	_barriers = {};
+	_isBarrier;
+	map;
+	nodes;
+	constructor(e, t) {
+		this.nodes = e, this.map = Object.fromEntries(e.map((e) => [e.id, e])), this._isBarrier = t;
+	}
+	isBarrier(e) {
+		let t = this._barriers[e];
+		return t === void 0 ? this._barriers[e] = this._isBarrier(this.map[e]) : t;
+	}
+	getSubGraphs(e) {
+		let t = [...e || Object.keys(this.map)], n = [], r;
+		for (; r = t.pop();) {
+			if (this.isBarrier(r)) continue;
+			let i = this.map[r], a = i && this.getConnectedNodes(i, e);
+			if (a) {
+				for (let e of a) {
+					let n = t.indexOf(e);
+					n >= 0 && t.splice(n, 1);
+				}
+				n.push(a);
+			}
+		}
+		return n;
+	}
+	inputs(e) {
+		return this.map[e].inputs.ids;
+	}
+	outputs(e) {
+		return this.map[e].outputs.ids;
+	}
+	getConnectedNodes(e, t, n = [e.id]) {
+		for (let r of [e.inputs.ids, e.outputs.ids]) for (let e of r) {
+			if (n.includes(e) || t && !t.includes(e)) continue;
+			let r = this.map[e];
+			r && (n.push(e), this.isBarrier(e) || this.getConnectedNodes(r, t, n));
+		}
+		return n;
+	}
+	getCenter(e) {
+		let t = this.nodes.map(e).filter(n);
+		if (!t.length) return {
+			x: 0,
+			y: 0
+		};
+		let r = {
+			x: Infinity,
+			y: Infinity
+		}, i = {
+			x: -Infinity,
+			y: -Infinity
+		};
+		for (let { x: e, y: n } of t) e < r.x && (r.x = e), e > i.x && (i.x = e), n < r.y && (r.y = n), n > i.y && (i.y = n);
+		for (let e of t) e.x -= r.x, e.y -= r.y;
+		return {
+			x: (i.x - r.x) / 2,
+			y: (i.y - r.y) / 2
+		};
+	}
+}, le = class extends A {
+	layers = [];
+	hash = null;
+	get center() {
+		return this.hash ||= this.getCenter((e) => e.position), this.hash;
+	}
+	spread(e, t) {
+		let n = [], r = 0;
+		for (let i of t) {
+			let t = this.map[i], a = this.shift(t, this.findLayer(t), e, n);
+			r = Math.max(r, a);
+		}
+		return r;
+	}
+	findMax(e) {
+		let t = this.findLayers(this.get(e.inputs.ids)), n = 0;
+		for (let e of Object.values(t)) {
+			let t = +e;
+			t > n && (n = t);
+		}
+		return n || 0;
+	}
+	dependants({ id: e }) {
+		let t = [];
+		for (let n of this.nodes) n.id !== e && n.inputs.has(e) && t.push(n);
+		return t;
+	}
+	get(e) {
+		return e.map((e) => this.map[e]).filter(n);
+	}
+	remove(e, t) {
+		return this.layers[t] ? delete this.layers[t][e.id] : !1;
+	}
+	put(e, t) {
+		let n = this.layers[t] || (this.layers[t] = {});
+		n[e.id] = e;
+	}
+	findLayer(e) {
+		for (let [t, n] of Object.entries(this.layers)) if (n[e.id]) return +t;
+		return 0;
+	}
+	findLayers(e) {
+		let t = {};
+		for (let n in this.layers) {
+			let r = this.layers[n], i = [];
+			for (let a of e) r[a.id] && (t[a.id] = +n, i.push(a));
+			e = e.filter((e) => i.indexOf(e) < 0);
+		}
+		return t;
+	}
+	shift(e, t, n, r = []) {
+		if (r.includes(e)) return 0;
+		r.push(e);
+		let i = t + n, a = this.dependants(e), o = i, s = i;
+		t && this.remove(e, t), this.put(e, i);
+		for (let e of a) {
+			let t = this.findLayer(e), n = i - t + 1;
+			s = Math.min(s, t + n), o = Math.max(o, t + n), t && n > 0 && this.shift(e, t, n, r);
+		}
+		return o - s + 1;
+	}
+	all(e) {
+		let t = e.concat([]);
+		return this.walk(e, (e) => {
+			t.push(e), t.concat(this.all(this.get(e.inputs.ids)));
+		}), t;
+	}
+	walk(e, t) {
+		for (let n of e) for (let e of n.inputs.ids) {
+			let n = this.map[e];
+			if (n && !1 === t(n)) break;
+		}
+	}
+}, ue = class extends A {
+	cache = {};
+	hash = null;
+	get center() {
+		return this.hash ||= this.getCenter((e) => e.position), this.hash;
+	}
+	splice(e, t, n, r = []) {
+		for (let i of e) r.includes(i) || (n(i, t), this.isBarrier(i) || (this.splice(this.inputs(i), t - 1, n, r), this.splice(this.outputs(i), t + 1, n, r)));
+	}
+	align(e, t) {
+		let n = e - t.length;
+		if (n <= 0) return t.map((e, t) => [e, t]);
+		let r = [], i = ~~(n / 2);
+		for (let e of t) r.push([e, i++]);
+		return r;
+	}
+	spread(e, t) {
+		let n = [], r = [];
+		this.splice(t, t.length, (e, t) => {
+			let i = n[t];
+			i ? i.push(e) : n[t] = [e], r.push(e);
+		}, r);
+		let i = [], a = 1, o = 0;
+		for (let e of n) e && (a = Math.max(a, e.length), i.push(e));
+		for (let t of i) {
+			for (let [n, r] of this.align(a, t)) this.cache[n] = {
+				x: o,
+				y: e + r
+			};
+			o++;
+		}
+		return this.hash = null, a;
+	}
+}, de = class {
+	sort(e) {
+		let t = {}, n = {}, r = [];
+		for (let i of e) {
+			let a = [], o = i.id;
+			for (let t of e) t.inputs.ids.indexOf(o) >= 0 && a.push(t.id);
+			r.push(o), a.length && (n[o] = a), i.inputs.ids.length && (t[o] = i.inputs.ids);
+		}
+		return this.walk(r, n, t);
+	}
+	walk(e, t, n) {
+		let r = Object.keys(t), i = Object.keys(n), { roots: a, joint: o, leafs: s } = this.split(e, i, r), c = [];
+		if (o.length === e.length) return [o];
+		switch (o.length) {
+			case 0: break;
+			case 1:
+			case 2:
+				c.push(o);
+				break;
+			default:
+				let e = {}, a = {};
+				for (let n of r) {
+					let r = t[n];
+					if (!r || o.indexOf(n) < 0) continue;
+					let i = r.filter((e) => o.indexOf(e) >= 0);
+					i.length && (e[n] = i);
+				}
+				for (let e of i) {
+					let t = n[e];
+					if (!t || o.indexOf(e) < 0) continue;
+					let r = t.filter((e) => o.indexOf(e) >= 0);
+					r.length && (a[e] = r);
+				}
+				Object.keys(e).length && Object.keys(a).length ? c.push(...this.walk(o, e, a)) : c.push(o);
+		}
+		return c.unshift(a), c.push(s), c;
+	}
+	split(e, t, n) {
+		let r = n.filter((e) => t.indexOf(e) < 0), i = t.filter((e) => n.indexOf(e) < 0), a = r.concat(i), o = e.filter((e) => a.indexOf(e) < 0);
+		return o.length > 1 && console.log("left", e, {
+			dependants: t,
+			dependencies: n
+		}, {
+			roots: i,
+			leafs: r,
+			joint: o
+		}), {
+			roots: i,
+			joint: o,
+			leafs: r
+		};
+	}
+}, fe = class {
+	sort(e, t, n) {
+		let r = n.pop();
+		for (let e of r);
+	}
+	mutate(e, t) {
+		let n = [];
+		for (let r = 0; r < t.length; r++) {
+			let i = [...t];
+			i.splice(r, 0, e), n.push(i);
+		}
+		return n;
+	}
+}, pe = class {
+	isBarrier;
+	klass;
+	constructor(e, t) {
+		this.klass = e, this.isBarrier = t;
+	}
+	layout(e, t) {
+		return new this.klass(e, this.isBarrier);
+	}
+	getSubGraphs(e) {
+		return new this.klass(e, this.isBarrier).getSubGraphs();
+	}
+}, j = Symbol("changed"), M = class extends e {
+	all;
+	map = {};
+	constructor(e = []) {
+		super(), this.all = e;
+	}
+	clear() {
+		let e = this.all;
+		this.all = [], this.map = {}, this.dispatchEvent(j, {
+			diff: e,
+			added: !1
+		});
+	}
+	find(e) {
+		return this.all.find(e);
+	}
+	filter(e) {
+		return this.all.filter(e);
+	}
+	get(e) {
+		return this.map[e];
+	}
+	add(e) {
+		let t = Array.isArray(e) ? e : [e], n = [];
+		for (let e of t) this.all.includes(e) || (n.push(e), this.map[e.id] = e);
+		return n.length && (this.all = this.all.concat(n), this.dispatchEvent(j)), e;
+	}
+	remove(e) {
+		Array.isArray(e) || (e = [e]);
+		let t = this.all.filter((t) => !e.includes(t.id));
+		if (t.length !== this.all.length) {
+			for (let t of e) delete this.map[t];
+			this.all = t, this.dispatchEvent(j);
+		}
+		return this;
+	}
+	onChange(e) {
+		return this.handleEvent(j, e);
+	}
+}, N = (e, t) => e === t ? !0 : e.length === t.length ? e.every((e, n) => e.id === t[n]?.id) : !1;
+function me(e) {
+	let [[t, n]] = u(() => {
+		let t = e();
+		return [t, [
+			(e) => t.onChange(e),
+			() => t.all,
+			() => t.all,
+			(e) => e,
+			N
+		]];
+	});
+	return s(() => () => {
+		for (let e of t.all) e.dispose();
+	}, []), [t, v(...n)];
+}
+//#endregion
+//#region src/graph/useDraggable.tsx
+var P = (e) => {
+	let t = e.position, [n, r] = u(() => ({
+		x: t.x,
+		y: t.y
+	})), { isDragging: i, bind: a } = p(({ isDragging: t, offset: i, pos: a, move: o, up: s, down: c, context: l, e: u }) => {
+		let { x: d, y: f } = e.position;
+		s ? (r({
+			x: d,
+			y: f
+		}), e.onUp({
+			x: n.x + a.x,
+			y: n.y + a.y
+		})) : o ? t ? e.onDrag({
+			x: n.x + i.x,
+			y: n.y + i.y
+		}) : e.onPointer({
+			x: d + a.x,
+			y: f + a.y
+		}) : c && (l ? e.onContext({
+			x: n.x + a.x,
+			y: n.y + a.y
+		}) : e.onClick({
+			x: n.x + a.x,
+			y: n.y + a.y
+		}, u));
+	});
+	return {
+		isDragging: i,
+		bind: a,
+		anchor: n,
+		reset: h((t) => {
+			e.onDrag(t), r(t);
+		})
+	};
+}, F = /* @__PURE__ */ ne({});
+import * as he from "@pixi/core";
+T(F, he);
+import * as ge from "@pixi/display";
+T(F, ge);
+import * as _e from "@pixi/sprite";
+T(F, _e);
+import * as ve from "@pixi/graphics";
+T(F, ve);
+import * as ye from "@pixi/text";
+T(F, ye);
+import * as be from "@pixi/text-bitmap";
+T(F, be);
+import * as xe from "@pixi/events";
+T(F, xe);
+//#endregion
+//#region src/graph/render/Batch.ts
+var I = class extends e {
+	counter;
+	constructor() {
+		super(), this.counter = 0;
+	}
+	batch(e) {
+		try {
+			this.begin(), e();
+		} finally {
+			this.end();
+		}
+	}
+	begin() {
+		this.counter++;
+	}
+	end() {
+		--this.counter <= 0 && (this.counter = 0, this.dispatchEvent(".", this));
+	}
+	and(e) {
+		return this.handleEvent(".", e);
+	}
+}, Se = [
+	[0, -1],
+	[-1, 0],
+	[0, 1],
+	[1, 0]
+], L = Math.PI * 2, R = Math.PI / 2, z = class extends F.Graphics {
+	sizeX;
+	sizeY;
+	lineSize;
+	color;
+	progress;
+	active = !1;
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor(e, { lineSize: t, sizeX: n, sizeY: r, radius: i, color: a }) {
+		super(), this.lineSize = t, this.color = a, this.sizeX = n, this.sizeY = r, this.#t = new F.Graphics().lineStyle({
+			width: t,
+			color: a
+		}).drawRoundedRect(0, 0, n, r, i), this.#e = new F.Graphics(), this.#e.position.set(n / 2, r / 2), this.#t.mask = this.#e, this.addChild(e), this.addChild(this.#t), this.addChild(this.#e), this.progress = 0;
+		let o = this.sizeX / 2, s = this.sizeY / 2, c = -o + this.lineSize, l = -s + this.lineSize, u = +o - this.lineSize, d = +s - this.lineSize, f = [
+			[
+				c,
+				l,
+				u,
+				l
+			],
+			[
+				c,
+				l,
+				c,
+				d
+			],
+			[
+				c,
+				d,
+				u,
+				d
+			],
+			[
+				u,
+				l,
+				u,
+				d
+			]
+		], p = [
+			+o + this.lineSize,
+			-s - this.lineSize,
+			+o + this.lineSize,
+			+s + this.lineSize,
+			-o - this.lineSize,
+			+s + this.lineSize,
+			-o - this.lineSize,
+			-s - this.lineSize
+		];
+		this.#r = {
+			segments: f,
+			corners: p
+		};
+	}
+	setActive(e) {
+		e !== this.active && (this.update(0), this.#n &&= (clearInterval(this.#n), 0), this.active = e, e && (this.#n = setInterval(() => this.update(this.progress + .005), 10)));
+	}
+	destroy(e) {
+		super.destroy(e), this.removeFromParent(), clearInterval(this.#n);
+	}
+	hotSwap(e) {
+		this.removeChildren(), this.addChild(e), this.addChild(this.#t), this.addChild(this.#e);
+	}
+	update(e) {
+		this.progress = e;
+		let t = e * L % L, n = Math.cos(t - R) * this.sizeX * 2, r = Math.sin(t - R) * this.sizeY * 2, i, a = null, o = 0;
+		for (let e = 0; e < this.#r.segments.length; e++) {
+			let t = this.#r.segments[e], s = ae(0, 0, n, r, t[0], t[1], t[2], t[3]);
+			if (s) {
+				a = s, o = e === 0 ? s.x > 0 ? 0 : 4 : 4 - e, i = Se[e];
+				break;
+			}
+		}
+		if (a && i) {
+			this.#e.clear().beginFill().moveTo(0, 0).moveTo(0, -(this.sizeX / 2) - this.lineSize);
+			for (let e = 0; e < o; e++) this.#e.lineTo(this.#r.corners[e * 2], this.#r.corners[e * 2 + 1]);
+			this.#e.lineTo(a.x + i[0] * this.lineSize * 2, a.y + i[1] * this.lineSize * 2).lineTo(a.x, a.y).lineTo(0, 0).endFill();
+		}
+	}
+}, B = class extends F.Graphics {
+	from;
+	to;
+	angled = !1;
+	color = 5592405;
+	#e;
+	#t = 2;
+	constructor(e, t, n, r, i = 2) {
+		super(), this.#e = i, this.from = new F.ObservablePoint(() => this.update(), 0, e, t), this.to = new F.ObservablePoint(() => this.update(), 0, n, r), this.eventMode = "none";
+	}
+	moveFromPoint(e) {
+		let t = this.from.x !== e.x || this.from.y !== e.y;
+		return t && this.from.copyFrom(e), t;
+	}
+	moveToPoint(e) {
+		let t = this.to.x !== e.x || this.to.y !== e.y;
+		return t && this.to.copyFrom(e), t;
+	}
+	setColor(e) {
+		return this.color = e, this;
+	}
+	setWidth(e) {
+		return this.#t = e, this;
+	}
+	update() {
+		let { x: e, y: t } = this.from, { x: n, y: r } = this.to, i = n - e, a = r - t, o = i / 2, s = a / 2;
+		return this.clear(), this.lineStyle(this.#t, this.color, this.alpha), this.x = n - o, this.y = r - s, this.angled ? (this.moveTo(-o, -s), this.lineTo(0, -s), this.lineTo(0, s), this.lineTo(o, s)) : (this.moveTo(-o, -s), this.lineTo(o, s)), this.#e && (this.beginFill(this.color, this.alpha), this.drawCircle(-o, -s, this.#e / 2), this.drawCircle(o, s, this.#e / 2), this.endFill()), this;
+	}
+}, V = class extends F.Graphics {
+	from;
+	to;
+	constructor(e, t) {
+		super(), this.from = new F.Point(e, t), this.to = {};
+		for (let e of Object.values(this.to)) this.addChild(e);
+	}
+	addTarget(e, t) {
+		let n = `${e}-${t}`;
+		return this.to[n] || (this.to[n] = this.addChild(new B(this.from.x, this.from.y, 0, 0)));
+	}
+	moveTargetTo(e, t, n) {
+		return this.addTarget(e, t).moveToPoint(n);
+	}
+	removeTarget(e, t) {
+		let n = `${e}-${t}`, r = this.to[n];
+		r && (delete this.to[n], this.removeChild(r));
+	}
+	move(e) {
+		let t = this.from.x !== e.x || this.from.y !== e.y;
+		if (t) {
+			this.from.copyFrom(e);
+			for (let t of Object.values(this.to)) t.moveFromPoint(e);
+		}
+		return t;
+	}
+}, Ce = {
+	0: 6710886,
+	2: 16737894,
+	1: 6750054
+}, we = {
+	0: 6710886,
+	2: 11167334,
+	1: 16724787
+}, Te = (e, t, n) => {
+	let { point: { parent: r, input: i } } = e;
+	if (t.hover) {
+		let a = r === t.point.parent || i === t.point.input ? 2 : 1;
+		if (a && n) {
+			let n = e.point.nodes.some(D(t.point.parent, t.point.port)), r = t.point.nodes.some(D(e.point.parent, e.point.port));
+			return n && r ? 1 : 0;
+		}
+		return a;
+	}
+	return 0;
+}, Ee = (e, t) => e.parent === t.parent && e.port === t.port, De = class extends F.Graphics {
+	line1;
+	line2;
+	line12;
+	line22;
+	constructor(e, t = 0, n = 1118481) {
+		super();
+		let r = e / 2, i = e / 2 + 2;
+		this.line12 = new B(-i, -i, i, i, 0).setWidth(6).setColor(n).update(), this.line22 = new B(i, -i, -i, i, 0).setWidth(6).setColor(n).update(), this.line1 = new B(-r, -r, r, r, 0), this.line2 = new B(r, -r, -r, r, 0), this.setColor(t), this.addChild(this.line12, this.line22, this.line2, this.line1);
+	}
+	show() {
+		return this.visible = !0, this;
+	}
+	hide() {
+		return this.visible = !1, this;
+	}
+	setColor(e) {
+		return this.line1.setColor(e).update(), this.line2.setColor(e).update(), this;
+	}
+	setAngle(e) {
+		return this.angle === e ? this : (this.angle = e, this.rotation = e, this);
+	}
+	setPosition(e) {
+		return this.x = e.x, this.y = e.y, this;
+	}
+}, Oe = class extends V {
+	start;
+	finish;
+	viable;
+	#e;
+	#t;
+	constructor(e) {
+		super(e.pos.x, e.pos.y), this.start = e, this.viable = 0, this.#e = this.addTarget(0, 0), this.#t = new De(10, 16724787).hide(), this.addChild(this.#t);
+	}
+	get isRemoving() {
+		return this.start.remove || !!this.finish?.remove;
+	}
+	setLine(e) {
+		this.#e.visible = !0;
+		let { x: t, y: n } = this.start.pos, { x: r, y: i } = e, a = r - t, o = i - n, s = a ? Math.atan(o / a) : 0;
+		if (this.isRemoving) {
+			let e = {
+				x: t + a / 2,
+				y: n + o / 2
+			};
+			this.#t.setColor(we[this.viable]).setPosition(e).setAngle(s).show(), this.viable === 0 && (this.#e.visible = !1, this.#t.hide());
+		} else this.#t.hide();
+		this.#e.setColor(this.isRemoving ? we[this.viable] : Ce[this.viable]).moveToPoint(e);
+	}
+	flail(e) {
+		this.finish || this.setLine(e);
+	}
+	hoverPort(e) {
+		this.viable = Te(this.start, e, this.isRemoving), this.finish = this.viable === 1 ? e : void 0, this.setLine(e.pos);
+	}
+	connect({ point: e }) {
+		if (this.finish && Ee(this.finish.point, e)) {
+			let { start: { remove: e, point: t }, finish: { remove: n, point: r } } = this, i = t.input ? t : r, a = t.input ? r : t;
+			return {
+				connect: !(e || n),
+				output: a,
+				input: i
+			};
+		}
+		return !1;
+	}
+}, H = class extends F.Container {
+	static makeFont = (e, t, n) => typeof document < "u" && F.BitmapFont.from(e, t, {
+		chars: [
+			["a", "z"],
+			["A", "Z"],
+			["а", "я"],
+			["А", "Я"],
+			["0", "9"],
+			"!@#$%^&*?()~{}[]<>\\/|_+-=.,\n:;'\"` ",
+			"←↑→↓"
+		],
+		...n
+	});
+	#e;
+	static factory = (e, t, n) => (this.makeFont(e, t, n), (t, n) => new this(t, {
+		...n,
+		fontName: e
+	}));
+	constructor(e, t) {
+		super(), this.#e = this.addChild(new F.BitmapText(String(e), t));
+	}
+	set text(e) {
+		this.#e.text = String(e);
+	}
+	get text() {
+		return this.#e.text;
+	}
+	set tint(e) {
+		this.#e.tint = e;
+	}
+}, U = Symbol.for("E_PORT_CLICK"), W = Symbol.for("E_PORT_HOVER"), ke = class t extends F.Graphics {
+	connectorPoint;
+	hasBothLanes;
+	static port = H.factory("nodePort", {
+		fontFamily: ["Menlo", "monospace"],
+		fontSize: 16,
+		lineHeight: 20,
+		align: "center"
+	});
+	#e = new e();
+	#t;
+	constructor(e, n) {
+		super(), this.connectorPoint = e, this.hasBothLanes = n, this.#t = !!e.nodes.length, this.x = e.x, this.y = e.y;
+		let r = e.input ? 1 : -1, i = this.addChild(t.port(this.label, { fontSize: 8 }));
+		i.y = -4, i.x = r * 12 - (e.input ? 0 : i.width), i.eventMode = "none", this.lineStyle(1, 3355443, 1), this.beginFill(this.#t ? 11184810 : 16777215), this.drawCircle(0, 0, 8 / 2), this.endFill(), this.eventMode = "static", this.cursor = "pointer", this.addEventListener("pointerdown", (e) => {
+			e.preventDefault(), e.stopPropagation(), this.#e.dispatchEvent(U, e);
+		}), this.addEventListener("pointerenter", (e) => {
+			e.preventDefault(), e.stopPropagation(), this.#e.dispatchEvent(W, !0);
+		}), this.addEventListener("pointerleave", (e) => {
+			e.preventDefault(), e.stopPropagation(), this.#e.dispatchEvent(W, !1);
+		});
+	}
+	get label() {
+		return String(this.connectorPoint.name).slice(0, this.hasBothLanes ? 2 : 8);
+	}
+	dispose() {
+		this.#e.dispose(), this.removeFromParent();
+	}
+	get active() {
+		return this.#t;
+	}
+	setActive(e) {
+		this.#t = e, this.update();
+	}
+	update() {
+		this.beginFill(this.active ? 11184810 : 16777215), this.drawCircle(0, 0, 8 / 2), this.endFill();
+	}
+	onClick(e) {
+		return this.#e.handleEvent(U, e);
+	}
+	onHover(e) {
+		return this.#e.handleEvent(W, e);
+	}
+}, Ae = Symbol.for("E_MOVE_NODE"), G = Symbol.for("E_CAPTURE_NODE"), K = (e, t) => {
+	let n = e.global;
+	return t ? (t.x = n.x, t.y = n.y, t) : {
+		x: n.x,
+		y: n.y
+	};
+}, q = (e) => e.__drag_root ? e : e.parent && q(e.parent);
+function je(e) {
+	return function(t) {
+		if (e.dispatchEvent(G, !0), t.buttons & 2) return;
+		let n = this._drag_meta = {
+			root: q(this.parent) || (() => {
+				throw Error("Can't find scene root");
+			})(),
+			emitter: e,
+			dragging: !0,
+			anchor: this.position.clone(),
+			lastPosition: K(t),
+			newPosition: K(t),
+			onDragEnd: Ne(this),
+			onDragMove: Me(this)
+		};
+		n.root.addEventListener("pointerup", n.onDragEnd, {
+			capture: !0,
+			passive: !0
+		}), n.root.addEventListener("pointerupoutside", n.onDragEnd, {
+			capture: !0,
+			passive: !0
+		}), n.root.addEventListener("pointermove", n.onDragMove, {
+			capture: !0,
+			passive: !0
+		});
+	};
+}
+var Me = (e) => (t) => {
+	if (!e._drag_meta?.dragging) return;
+	let { newPosition: n, lastPosition: r, anchor: i, emitter: a } = e._drag_meta;
+	K(t, n), n.x -= r.x, n.y -= r.y, a.dispatchEvent(Ae, {
+		x: i.x + n.x,
+		y: i.y + n.y
+	});
+}, Ne = (e) => () => {
+	if (!e._drag_meta) return;
+	let { root: t, emitter: n, onDragEnd: r, onDragMove: i } = e._drag_meta;
+	t.removeEventListener("pointerup", r), t.removeEventListener("pointerupoutside", r), t.removeEventListener("pointermove", i), n.dispatchEvent(G, !1), delete e._drag_meta;
+}, J = Symbol.for("E_NODE_CONTEXT"), Y = Symbol.for("E_CONNECTORS_UPDATE"), Pe = class t extends e {
+	static label = H.factory("nodeLabel", {
+		fontSize: 24,
+		align: "center",
+		fill: "#efefef",
+		dropShadow: !0,
+		dropShadowDistance: 2
+	});
+	#e;
+	#t;
+	#n;
+	#r = je(this);
+	data;
+	find;
+	ports = /* @__PURE__ */ new Map();
+	constructor(e, n) {
+		super(), this.data = e, this.find = n, this.data.onConnect(this.#i.bind(this)), this.#e = t.label(this.label, { fontSize: 11 });
+	}
+	get id() {
+		return this.data.id;
+	}
+	get label() {
+		return this.data.title;
+	}
+	dispose() {
+		for (let e of this.ports.values()) e.dispose();
+		if (this.#n) {
+			let e = this.#n.map(({ port: e }) => `${this.id}-${e}`);
+			e.length && this.dispatchEvent(Y, { remove: e });
+		}
+		this.#t &&= (this.#t.removeFromParent(), void 0), super.dispose();
+	}
+	move(e) {
+		this.renderable.position.copyFrom(this.data.move(e)), this.placeConnectors();
+	}
+	hitTest({ x: e, y: t }) {
+		let { x: n, y: r } = this.renderable;
+		return e < n || t < r ? !1 : e - n <= this.width && t - r <= this.height;
+	}
+	get width() {
+		return this.data.width;
+	}
+	get height() {
+		return this.data.height + 16;
+	}
+	#i({ connect: e, input: t, source: { port: n }, target: r }) {
+		let i = this.connectors.find((e) => e.port === n && e.input === t);
+		if (!i) return;
+		O(e, i, r);
+		let a = this.ports.get(n);
+		a && a.setActive(!!i.nodes.length);
+	}
+	connectedAt(e, t, n) {
+		return this.connectors.find(({ nodes: r, connector: i }) => n !== !i && r.length && r.some(D(e, t)));
+	}
+	get connectors() {
+		if (this.#n) return this.#n;
+		let e = [], t = 1, n = 1;
+		for (let n of this.data.inputs) {
+			let r = {
+				x: 16 / 2,
+				y: t * 16 + 16 / 2
+			}, i = E(this.data.position, r);
+			e.push({
+				parent: this.data.id,
+				port: n.port,
+				name: n.name,
+				nodes: n.nodes,
+				input: !0,
+				x: r.x,
+				y: r.y,
+				connector: new V(i.x, i.y)
+			}), t++;
+		}
+		for (let t of this.data.outputs) e.push({
+			parent: this.data.id,
+			port: t.port,
+			name: t.name,
+			nodes: t.nodes,
+			input: !1,
+			x: 64 - 16 / 2,
+			y: n * 16 + 16 / 2
+		}), n++;
+		return this.#n = e;
+	}
+	placeConnectors(e = !0) {
+		let t = /* @__PURE__ */ new Map(), n = [];
+		for (let r of this.connectors) {
+			let { connector: i, nodes: a, port: o } = r, s = `${this.id}-${o}`;
+			if (i) if (i.move(E(this.renderable, r)), a.length) {
+				let e = 0;
+				for (let { node: t, port: n } of a) {
+					let r = this.find(t), a = r?.connectedAt(this.id, o);
+					r && a ? (i.moveTargetTo(t, n, E(r.renderable, a)), e++) : i.removeTarget(t, n);
+				}
+				e && t.set(s, i);
+			} else n.push(s);
+			else if (e && a.length) for (let { node: e } of a) this.find(e)?.placeConnectors(!1);
+		}
+		(t.size || n.length) && this.dispatchEvent(Y, {
+			add: t.size ? [...t.entries()].map(([e, t]) => ({
+				uid: e,
+				connector: t
+			})) : void 0,
+			remove: n.length ? n : void 0
+		});
+	}
+	get renderable() {
+		if (this.#t) return this.#t;
+		let e = this.width, t = this.height, n = this.makeRoundRect({
+			width: e,
+			height: t,
+			stroke: 14671855,
+			fill: 16645629
+		});
+		this.#e.y = (16 - this.#e.height) / 2, this.#e.x = (e - this.#e.width) / 2, n.addChild(this.makeLane({
+			x: 0,
+			y: 0,
+			width: e,
+			height: 16,
+			fill: 8224125
+		})).addChild(this.#e);
+		let r = this.data.inputs.count, i = this.data.outputs.count;
+		r && n.addChild(this.makeLane({
+			x: 0,
+			y: 16,
+			height: t - 16
+		})), i && n.addChild(this.makeLane({
+			x: e - 16,
+			y: 16,
+			height: t - 16
+		}));
+		let a = !!(r && i);
+		for (let e of this.connectors) n.addChild(this.makePort(e, a));
+		let o = this.data.render(n);
+		return o.eventMode = "static", o.addEventListener("pointerdown", (e) => this.handleClick(e)), o.x = this.data.position.x, o.y = this.data.position.y, this.#t = o;
+	}
+	makeRoundRect({ stroke: e, fill: t, x: n = 0, y: r = 0, width: i, height: a, thickness: o = 1, radius: s = 4 }) {
+		let c = new F.Graphics();
+		return c.lineStyle(o, e), c.beginFill(t), c.drawRoundedRect(0, 0, i, a, s), c.endFill(), c.x = n, c.y = r, c;
+	}
+	makeLane(e) {
+		return this.makeRoundRect(Object.assign({
+			width: 16,
+			height: 16,
+			stroke: 14737632,
+			fill: 15592941
+		}, e));
+	}
+	makePort(e, t) {
+		let { port: n, x: r, y: i } = e, a = new ke(e, t);
+		return this.ports.set(n, a), a.onClick((t) => {
+			if (t.buttons & 2) return this.dispatchEvent(J, {
+				event: t,
+				tag: {
+					type: "port",
+					id: n
+				}
+			});
+			this.dispatchEvent(U, {
+				remove: t.ctrlKey || t.metaKey,
+				point: e,
+				pos: {
+					x: this.renderable.x + r,
+					y: this.renderable.y + i
+				}
+			});
+		}), a.onHover((t) => this.dispatchEvent(W, {
+			point: e,
+			hover: t,
+			pos: {
+				x: this.renderable.x + r,
+				y: this.renderable.y + i
+			}
+		})), a;
+	}
+	handleClick(e) {
+		e.buttons & 2 ? (e.stopPropagation(), e.preventDefault(), this.dispatchEvent(J, {
+			event: e,
+			tag: {
+				type: "node",
+				id: this.data.id
+			}
+		})) : this.#r.call(this.renderable, e);
+	}
+	onContext(e) {
+		return this.handleEvent(J, e);
+	}
+	onPortClick(e) {
+		return this.handleEvent(U, e);
+	}
+	onPortHover(e) {
+		return this.handleEvent(W, e);
+	}
+	onCapture(e) {
+		return this.handleEvent(G, e);
+	}
+	onMove(e) {
+		return this.handleEvent(Ae, e);
+	}
+	onConnectorsUpdate(e) {
+		return this.handleEvent(Y, e);
+	}
+	update() {
+		let e = this.connectors.reduce((e, t) => (e[t.port] = t, e), {});
+		for (let t of this.data.inputs) {
+			let n = e[t.port];
+			n && (n.nodes = t.nodes);
+		}
+		for (let t of this.data.outputs) {
+			let n = e[t.port];
+			n && (n.nodes = t.nodes);
+		}
+		this.placeConnectors();
+	}
+}, Fe = {
+	x: 0,
+	y: 0
+}, Ie = (e, t) => e.cell.x === t.cell.x && e.cell.y === t.cell.y && e.count.x === t.count.x && e.count.y === t.count.y && e.size.width === t.size.width && e.size.height === t.size.height, X = (e, t, n) => e > t ? e < n ? e : n : t, Z = (e, t, n, r, i) => X(e - t / 2, n + i, r - t - i), Le = (e) => {
+	let t = Math.ceil(e);
+	return t % 2 ? t + 1 : t;
+}, Re = class e extends F.Graphics {
+	static text = H.factory("GridBoundary", {
+		fontSize: 24,
+		fill: 16777215,
+		stroke: 0,
+		dropShadow: !0,
+		dropShadowDistance: 2
+	}, { chars: [["0", "9"], "+-."] });
+	cellSize;
+	colors;
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a = new F.Rectangle(0, 0, 0, 0);
+	#o = {
+		cell: Fe,
+		count: Fe,
+		size: {
+			width: 0,
+			height: 0
+		}
+	};
+	#s;
+	#c;
+	constructor(t, n, r = 5) {
+		super(), this.cellSize = t, this.colors = n, this.#e = r, this.#s = this.addChild(new F.Container()), this.#c = this.addChild(new F.Container()), this.#n = e.text("", { fontSize: 12 }), this.#t = e.text("", { fontSize: 12 }), this.#i = e.text("", { fontSize: 12 }), this.#r = e.text("", { fontSize: 12 });
+	}
+	get lods() {
+		return this.colors.length;
+	}
+	snapSize({ width: e, height: t }, n) {
+		let { x: r, y: i } = this.cellSize, a = n ? 2 ** (n - 1) * this.#e : 1, o = a * r, s = a * i, c = Le(e / o), l = Le(t / s);
+		return {
+			cell: {
+				x: o,
+				y: s
+			},
+			count: {
+				x: c,
+				y: l
+			},
+			size: {
+				width: o * c,
+				height: s * l
+			}
+		};
+	}
+	toMaxSnap(e) {
+		return this.snapSize(e, this.lods - 1);
+	}
+	viewport(e) {
+		this.makeRullers(e);
+		let t = this.toMaxSnap(this.#a), n = this.toMaxSnap(e);
+		this.#s.x = (e.left + e.width) % n.cell.x, this.#s.y = (e.top + e.height) % n.cell.y, !Ie(t, n) && (this.#a.copyFrom(e), this.#o = n, this.update());
+	}
+	makeRullers(e) {
+		this.#c.removeChildren();
+		let t = this.#c.addChild(new F.Graphics()), { left: n, top: r, width: i, height: a } = e, o = n + i, s = r + a, c = X(o, 1, i - 1), l = X(s, 1, a - 1);
+		t.lineStyle(2, 16711680, 1), t.moveTo(0, l), t.lineTo(i, l), t.moveTo(c, 0), t.lineTo(c, a), this.#c.addChild(this.#n, this.#t, this.#i, this.#r), this.#n.text = ~~(-(i + n) / this.cellSize.x), this.#i.text = ~~(-(a + r) / this.cellSize.y), this.#t.text = ~~(-n / this.cellSize.x), this.#r.text = ~~(-r / this.cellSize.y);
+		let u = this.#n.height, d = this.#n.width, f = this.#t.width, p = this.#i.width, m = this.#r.width, h = Z(l, u, 0, a, 2), g = Z(c, p, d + 5, i - f - 5, 2), _ = Z(c, m, d + 5, i - f - 5, 2);
+		this.#n.x = 2, this.#n.y = h, this.#t.x = i - f - 2, this.#t.y = h, this.#i.x = g, this.#i.y = 2, this.#r.x = _, this.#r.y = a - u - 2;
+	}
+	makeLOD(e) {
+		let t = this.colors[e], { cell: { x: n, y: r }, count: { x: i, y: a }, size: { width: o, height: s } } = this.snapSize(this.#o.size, e), c = new F.Graphics();
+		c.lineStyle(.25 * (e + 1), t, 1);
+		for (let e = 0; e < i; e++) c.moveTo(n * e, 0), c.lineTo(n * e, s);
+		for (let e = 0; e < a; e++) c.moveTo(0, r * e), c.lineTo(o, r * e);
+		return c;
+	}
+	makeGrid() {
+		let e = new F.Container();
+		for (let t of this.colors.keys()) e.addChild(this.makeLOD(t));
+		return e;
+	}
+	update() {
+		let { width: e, height: t } = this.#o.size;
+		this.#s.removeChildren();
+		for (let n = -1; n <= 1; n++) for (let r = -1; r <= 1; r++) {
+			let i = this.makeGrid();
+			i.x = n * e, i.y = r * t, this.#s.addChild(i);
+		}
+	}
+}, ze = 24, Q = 12, Be = class e extends F.Container {
+	static label = H.factory("menuItem", {
+		fontSize: 24,
+		align: "center",
+		fill: 16777215
+	});
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = 0;
+	#a = ze;
+	#o = !1;
+	#s = !1;
+	#c = !1;
+	index;
+	constructor(t, n, r) {
+		super(), this.index = t, this.#n = n, this.#s = !!n.separator, this.#r = !!n.group, this.#c = !!n.disabled || this.#r, this.#e = this.addChild(new F.Graphics()), this.#t = this.addChild(e.label(this.label, { fontSize: 12 })), this.eventMode = "static", this.addEventListener("pointerdown", (e) => {
+			this.#c || (e.stopPropagation(), e.preventDefault(), r());
+		});
+	}
+	resize(e) {
+		this.#i = e, this.update();
+	}
+	get separator() {
+		return this.#s;
+	}
+	set separator(e) {
+		this.#s !== e && (this.#s = e, this.update());
+	}
+	get hover() {
+		return this.#o;
+	}
+	set hover(e) {
+		e &&= !this.#c, this.#o !== e && (this.#o = e, this.update());
+	}
+	get label() {
+		return this.#n.label;
+	}
+	get labelWidth() {
+		return this.#t.width + Q * 2;
+	}
+	get width() {
+		return this.#i;
+	}
+	get height() {
+		return this.#s ? 2 : this.#a;
+	}
+	get disabled() {
+		return this.#c;
+	}
+	set disabled(e) {
+		this.#c === e && (this.#c = e, this.update());
+	}
+	update() {
+		let e = this.width, t = this.height, n = this.#e;
+		this.separator ? (n.lineStyle(1, 1638, 1), n.moveTo(Q, 1), n.lineTo(e - Q, 1)) : this.#r ? (n.lineStyle(0, 0, 1), n.beginFill(3355443), n.drawRect(-1, 1, e + 2, t - 2), n.endFill()) : this.hover ? (n.lineStyle(0, 0, 1), n.beginFill(4473924), n.drawRoundedRect(0, 0, e, t, 4), n.endFill()) : n.clear(), this.#t.text = this.#n.label, this.#t.x = Q, this.#t.y = (t - this.#t.height) / 2, this.#t.alpha = this.#c && !this.#r ? .3 : 1, this.#t.tint = this.#r || this.hover ? 16777215 : 0;
+	}
+}, Ve = Symbol.for("E_ITEM_SELECT"), He = Symbol.for("E_CLOSE_MENU"), Ue = new F.Point(), We = class extends F.Container {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a = -1;
+	constructor(t) {
+		super(), this.#i = new e(), this.#n = this.addChild(new F.Graphics()), this.#e = this.addChild(new F.Graphics()), this.#t = this.addChild(new F.Container()), this.#r = t.items.map((e, t) => this.#t.addChild(new Be(t, e, () => this.handleSelect(e)))), this.#t.mask = this.#n, this.eventMode = "static", this.addEventListener("pointermove", (e) => {
+			this.hoverIndex = this.getItemAtY(e.getLocalPosition(this, Ue).y);
+		}), this.addEventListener("pointerleave", () => {
+			this.hoverIndex = -1;
+		}), this.update();
+	}
+	getItemAtY(e) {
+		if (e >= 0) {
+			for (let t of this.#r) if (e -= t.height, e <= 2) return t.index;
+		}
+		return -1;
+	}
+	get hoverIndex() {
+		return this.#a;
+	}
+	set hoverIndex(e) {
+		this.#a !== e && (this.changeHover(this.#a, !1), this.changeHover(e, !0), this.#a = e);
+	}
+	changeHover(e, t) {
+		let n = e >= 0 && this.#r[e];
+		n && (n.hover = t);
+	}
+	handleSelect(e) {
+		this.#i.dispatchEvent(Ve, e);
+	}
+	close() {
+		this.visible = !1, this.#i.dispatchEvent(He);
+	}
+	onSelect(e) {
+		return this.#i.handleEvent(Ve, e);
+	}
+	onClose(e) {
+		return this.#i.handleEvent(He, e);
+	}
+	get width() {
+		return Math.max(...this.#r.map((e) => e.labelWidth));
+	}
+	get height() {
+		return this.#r.reduce((e, t) => e + t.height, 0);
+	}
+	update() {
+		let e = this.width, t = this.height, n = this.#e;
+		n.lineStyle(0, 0, 1), n.beginFill(0, .3), n.drawRoundedRect(2, 2, e + 2, t + 2, 4), n.endFill(), n.lineStyle(1, 3355443, 1), n.beginFill(16645629), n.drawRoundedRect(-1, -1, e + 2, t + 2, 4), n.endFill();
+		let r = this.#n;
+		r.clear(), r.beginFill(16777215), r.drawRoundedRect(-1, -1, e + 2, t + 2, 4), r.endFill();
+		let i = 0;
+		for (let t of this.#r) t.y = i, t.resize(e), i += t.height;
+	}
+}, Ge = class {
+	ticker;
+	nodes = /* @__PURE__ */ new Map();
+	connectors = /* @__PURE__ */ new Map();
+	_pending = null;
+	_renderer = null;
+	menu;
+	gui;
+	world;
+	root;
+	overlay;
+	grid;
+	capturing;
+	options = { viewport: {
+		width: 1,
+		height: 1,
+		resolution: window.devicePixelRatio,
+		backgroundColor: 2368548,
+		antialias: !0,
+		transparent: !1
+	} };
+	#e = t(() => this.ticker.speed = .05, 1e3);
+	#t = (e) => this.nodes.get(e);
+	constructor({ maxFPS: e, grid: t, gui: n = [] }) {
+		this.ticker = new F.Ticker(), this.world = new F.Container(), this.root = new F.Container(), this.overlay = new F.Container(), this.grid = new Re(t.cellSize, t.colors), this.world.sortableChildren = !0, this.ticker.maxFPS = e, this.world.__drag_root = !0, this.gui = n, this.root.addChild(this.grid), this.root.addChild(this.world), this.root.addChild(this.overlay), this.root.addChild(...n), this.ticker.add(this.render.bind(this)), this.world.eventMode = "static", this.world.hitArea = { contains: () => !0 }, this.world.addEventListener("pointermove", (e) => {
+			this.handlePointerMove(this.fromGlobal(e.global));
+		}), this.world.addEventListener("pointerdown", (e) => {
+			this.handlePointerDown(this.fromGlobal(e.global), e);
+		}), this.fullSpeed();
+	}
+	fullSpeed() {
+		this.ticker.speed = 1, this.#e();
+	}
+	get renderer() {
+		if (!this._renderer) {
+			let { viewport: e } = this.options;
+			this._renderer = (0, F.autoDetectRenderer)({
+				width: e.width,
+				height: e.height,
+				antialias: e.antialias,
+				backgroundColor: e.backgroundColor,
+				backgroundAlpha: +!e.transparent,
+				resolution: e.resolution,
+				autoDensity: !0
+			}), this.ticker.start();
+		}
+		return this._renderer;
+	}
+	set renderer(e) {
+		this._renderer !== e && (this._renderer && (this.ticker.stop(), this._renderer.destroy(!0)), this._renderer = e, e && this.ticker.start());
+	}
+	get width() {
+		return this.renderer.width / this.options.viewport.resolution;
+	}
+	get height() {
+		return this.renderer.height / this.options.viewport.resolution;
+	}
+	get center() {
+		let { width: e, height: t } = this;
+		return {
+			x: e / 2,
+			y: t / 2
+		};
+	}
+	get translation() {
+		let { x: e, y: t } = this.center, { x: n, y: r } = this.world.transform.position;
+		return {
+			x: ~~(n - e),
+			y: ~~(r - t)
+		};
+	}
+	fromGlobal(e) {
+		return E(e, this.world.transform.position, -1);
+	}
+	fromLocal(e) {
+		return E(E(e, this.world.transform.position, -2), this.center);
+	}
+	offsetPos(e, t = 1) {
+		return E(e, this.center, t);
+	}
+	translate(e) {
+		this.world.transform.position.copyFrom(this.offsetPos(e)), this.overlay.transform.position.copyFrom(this.offsetPos(e)), this.updateViewport();
+	}
+	closeMenu() {
+		this.menu?.close();
+	}
+	showMenu(e, t, n) {
+		this.closeMenu();
+		let r = e.getMenu(t, n);
+		if (r) {
+			let t = this.overlay.addChild(Object.assign(new We(r), n));
+			return t.onSelect((t) => {
+				!1 !== e.handleMenu(t.data) && this.closeMenu();
+			}), t.onClose(() => {
+				this.menu === t && (this.menu = null), t.removeFromParent();
+			}), this.menu = t;
+		}
+	}
+	addNode(e) {
+		if (this.#t(e.id)) return;
+		let t = new Pe(e, this.#t);
+		t.onMove((t) => {
+			this._pending || this.moveNodeTo(e.id, t);
+		}), t.onCapture((t) => {
+			if (t) {
+				if (this.capturing = e, !this._pending) {
+					this.moveToForeground(e);
+					return;
+				}
+			} else this.capturing = void 0;
+		}), t.onContext(({ event: t, tag: n }) => this.showMenu(e, n, this.fromGlobal(t.global))), t.onPortClick((e) => {
+			if (!(e.remove && !e.point.nodes.length)) {
+				if (this.pending) {
+					let t = this.pending.connect(e);
+					t && (this.connectNodes(t), this.pending = null);
+					return;
+				}
+				this.pending = new Oe(e);
+			}
+		}), t.onPortHover((e) => this.pending?.hoverPort(e)), t.onConnectorsUpdate(({ add: e, remove: t }) => {
+			if (e) for (let { uid: t, connector: n } of e) this.addConnector(t, n);
+			if (t) for (let e of t) this.removeConnector(e);
+		}), t.onDispose(() => {
+			this.nodes.delete(e.id);
+		}), this.nodes.set(e.id, t), this.world.addChild(t.renderable);
+	}
+	removeNode(e) {
+		let t = this.nodes.get(e.id);
+		t && t.dispose();
+	}
+	clear() {
+		let e = [...this.nodes.values()];
+		this.connectors.clear(), this.nodes.clear(), this.world.removeChildren();
+		for (let t of e) t.dispose();
+	}
+	get pending() {
+		return this._pending;
+	}
+	set pending(e) {
+		!e && this._pending && this._pending.removeFromParent(), this._pending = e, e && this.overlay.addChild(e);
+	}
+	handlePointerMove(e) {
+		this.fullSpeed(), !(this.capturing || !this.pending) && this.pending.flail(e);
+	}
+	handlePointerDown(e, t) {
+		if (this.pending && !t.shiftKey && (this.pending = null), this.closeMenu(), t.buttons & 2) {
+			for (let n of this.gui) if (this.showMenu(n, void 0, e)) {
+				t.stopPropagation(), t.preventDefault();
+				return;
+			}
+		}
+	}
+	connectNodes({ connect: e, output: { port: t, parent: n }, input: { port: r, parent: i } }) {
+		let a = this.#t(n), o = this.#t(i);
+		a.data.connect({
+			connect: e,
+			input: !1,
+			port: t,
+			nodes: [{
+				node: o.data,
+				port: r
+			}]
+		}), o.placeConnectors();
+	}
+	buildConnectors() {
+		for (let e of this.nodes.values()) e.placeConnectors();
+	}
+	addConnector(e, t) {
+		if (this.connectors.has(e)) return;
+		let n = t;
+		n.zIndex++, this.world.addChild(n), this.connectors.set(e, n);
+	}
+	removeConnector(e) {
+		let t = this.connectors.get(e);
+		t && (this.connectors.delete(e), this.world.removeChild(t));
+	}
+	moveToForeground(e) {
+		let t = this.nodes.get(e.id);
+		t && this.world.setChildIndex(t.renderable, this.world.children.length - 1);
+	}
+	hitTest({ x: e, y: t }) {
+		let n = {
+			x: e - this.translation.x,
+			y: t - this.translation.y
+		};
+		for (let e of this.nodes.values()) if (e.hitTest(n)) return {
+			node: e.data,
+			x: e.renderable.x,
+			y: e.renderable.y,
+			width: e.width,
+			height: e.height
+		};
+	}
+	getNodePos(e) {
+		return e.position;
+	}
+	moveNodeTo(e, t) {
+		let n = this.nodes.get(e);
+		n && n.move(t);
+	}
+	layout() {
+		this.buildConnectors();
+	}
+	mount(e, t) {
+		return this.options = t, this.renderer = null, this.renderer.resize(t.viewport.width, t.viewport.height), this.translate({
+			x: 0,
+			y: 0
+		}), e.appendChild(this.renderer.view), () => {
+			this.unmount();
+		};
+	}
+	unmount() {
+		this.renderer = null;
+	}
+	resize(e, t) {
+		this.renderer.resize(e, t), this.updateViewport();
+	}
+	updateViewport() {
+		let { width: e, height: t, translation: { x: n, y: r } } = this;
+		e && t && this.grid.viewport(new F.Rectangle(n - e / 2, r - t / 2, e, t));
+	}
+	render() {
+		this.renderer?.render(this.root);
+	}
+	update() {
+		this.ticker.update();
+	}
+}, Ke = "\nPort:\n  LMB - start connecting\n  LMB + (Meta | Ctrl) - start disconnecting\nCanvas:\n  LMB + Shift - drag while connecting/disconnecting", $ = class e extends F.Container {
+	static text = H.factory("GUIText", {
+		fontSize: 16,
+		align: "left",
+		fill: "#efefef",
+		dropShadow: !0,
+		dropShadowDistance: 1
+	}, { chars: [
+		["a", "z"],
+		["A", "Z"],
+		["0", "9"],
+		" 	\n+-|()/:;."
+	] });
+	static makeText = (e) => this.text(e, { fontSize: 8 });
+	#e;
+	#t = new F.Text("ℹ️", {
+		fontSize: 8,
+		lineHeight: 14
+	});
+	#n = e.makeText("");
+	#r = !1;
+	#i = "";
+	#a;
+	constructor(e, t = Ke) {
+		super(), this.#a = t, this.addChild(this.#t), this.addChild(this.#n), this.#t.eventMode = "static", this.#t.addEventListener("pointerdown", () => this.legend = !this.legend), this.#n.x = 8, this.#n.y = 8, this.#e = e;
+	}
+	getMenu(e, t) {
+		return this.#e.getMenu(e, t);
+	}
+	handleMenu(e) {
+		return this.#e.handleMenu(e);
+	}
+	get legendText() {
+		return this.#a;
+	}
+	set legendText(e) {
+		this.#a = e;
+	}
+	set text(e) {
+		this.#i = e, this.#n.text = e + (this.#r ? this.#a : "");
+	}
+	get legend() {
+		return this.#r;
+	}
+	set legend(e) {
+		this.#r = e, this.#n.text = this.#i + (this.#r ? this.#a : "");
+	}
+}, qe = class extends F.Container {
+	first;
+	constructor(e, ...t) {
+		super(), this.first = e, this.addChild(e, ...t);
+	}
+	hotSwap(...e) {
+		this.removeChildren(), this.addChild(this.first, ...e);
+	}
+}, Je = class extends F.Graphics {
+	#e;
+	#t;
+	constructor(e) {
+		super(), this.#e = e;
+	}
+	get active() {
+		return !!this.#t;
+	}
+	set active(e) {
+		if (e !== !!this.#t && (this.#t = e, this.clear(), e)) {
+			let { lineSize: e, color: t, x: n = 0, y: r = 0, width: i, height: a, radius: o } = this.#e;
+			this.lineStyle({
+				width: e,
+				color: t
+			}).drawRoundedRect(n - 2, r - 2, i + 4, a + 4, o);
+		}
+	}
+};
+T(/* @__PURE__ */ ne({
+	Batch: () => I,
+	E_CONNECTORS_UPDATE: () => Y,
+	E_NODE_CONTEXT: () => J,
+	LANE_HEIGHT: () => 16,
+	LANE_WIDTH: () => 16,
+	NODE_WIDTH: () => 64,
+	PIXIGUI: () => $,
+	PIXINode: () => Pe,
+	PIXIOutlined: () => Je,
+	PIXIRenderer: () => Ge,
+	PIXIStacked: () => qe,
+	PORT_SIZE: () => 8,
+	RectSpinner: () => z
+}), F);
+//#endregion
+//#region src/graph/GraphAdapter.ts
+var Ye = class extends I {
+	renderer;
+	nodes = [];
+	constructor(e) {
+		super(), this.renderer = new Ge(e), this.and(() => this.renderer.render());
+	}
+	[Symbol.iterator]() {
+		return this.nodes[Symbol.iterator]();
+	}
+	clear() {
+		this.renderer.clear(), this.nodes.splice(0);
+	}
+	update() {
+		this.renderer.update();
+	}
+	moveToForeground(e) {
+		this.renderer.moveToForeground(e);
+	}
+	hitTest(e) {
+		return this.renderer.hitTest(e);
+	}
+	getNodePos(e) {
+		return this.renderer.getNodePos(e);
+	}
+	moveNodeTo(e, t) {
+		e.position = t;
+	}
+	addNode(e) {
+		return this.nodes.indexOf(e) < 0 && (this.nodes.push(e), this.renderer.addNode(e)), e;
+	}
+	removeNode(e) {
+		let t = this.nodes.indexOf(e);
+		return t >= 0 && (this.nodes.splice(t, 1), this.renderer.removeNode(e)), e;
+	}
+	get capturing() {
+		return this.renderer.capturing;
+	}
+	releaseNode() {
+		this.renderer.capturing = void 0;
+	}
+	get translation() {
+		return this.renderer.translation;
+	}
+	translate(e) {
+		this.renderer.translate(e);
+	}
+	resize(e, t) {
+		this.renderer.resize(e, t);
+	}
+	fromGlobal(e) {
+		return this.renderer.fromGlobal(e);
+	}
+	fromLocal(e) {
+		return this.renderer.fromLocal(e);
+	}
+	mount(e, t) {
+		return this.renderer.mount(e, t);
+	}
+	unmount() {
+		this.renderer.unmount();
+	}
+	layout() {
+		this.renderer.layout();
+	}
+};
+//#endregion
+//#region src/graph/NodeGroups.tsx
+function Xe(e, t) {
+	let n = [];
+	for (let r of e) {
+		let e = t(r);
+		e && n.push(e);
+	}
+	return n.sort((e, t) => e.label.localeCompare(t.label)).concat([{
+		value: "all",
+		ids: e.map(({ id: e }) => e),
+		label: `All nodes (${e.length})`
+	}]);
+}
+var Ze = (e, t) => {
+	let n = e.length;
+	if (n !== t.length) return !1;
+	for (let r = 0; r < n; r++) if (e[r] !== t[r]) return !1;
+	return !0;
+}, Qe = (e) => {
+	let t = String(e);
+	return (e) => String(e.value) === t;
+}, $e = y(function({ items: e, resolver: t, onSelect: n, children: r, ...i }) {
+	let o = c(() => Xe(e, t), [e, t]), [l, d] = u(o.find(({ value: e }) => e === "all")), f = String(l.value), p = h(({ target: { value: e } }) => {
+		let t = o.find(Qe(e));
+		t && d(t);
+	});
+	return a(() => void n(l), [l, n]), s(() => {
+		let e = o.find(Qe(l.value));
+		if (e) {
+			if (e === l) return;
+			(e.label !== l.label || !Ze(e.ids, l.ids)) && d(e);
+		} else d(o[0]);
+	}, [o, l]), /* @__PURE__ */ x("select", {
+		multiple: !0,
+		size: o.length,
+		onChange: p,
+		...i,
+		children: [r, o.map(({ value: e, label: t }) => /* @__PURE__ */ b("option", {
+			value: String(e),
+			selected: String(e) === f,
+			children: t
+		}, String(e)))]
+	});
+}), et = i(y(({ handlers: e, onResize: t, ...n }, r) => {
+	let [i, s] = g(), { bind: c, reset: l } = P(e);
+	return o(r, () => ({
+		reset: l,
+		get element() {
+			return c.ref.current;
+		}
+	})), a(() => {
+		i && t({
+			width: ~~i.width,
+			height: ~~i.height
+		});
+	}, [i, t]), /* @__PURE__ */ b("div", {
+		ref: s,
+		style: tt.root,
+		children: /* @__PURE__ */ b("div", {
+			style: tt.root,
+			...c,
+			...n
+		})
+	});
+})), tt = d.of({ root: {
+	flex: 1,
+	display: "flex",
+	minWidth: 0,
+	minHeight: 0
+} }), nt = y(({ onSelect: e, ...t }) => /* @__PURE__ */ b($e, {
+	resolver: rt,
+	onSelect: h((t) => e(t.ids)),
+	...t
+})), rt = (e) => {
+	if (!e.item.isolator) return;
+	let t = [e.id];
+	return {
+		value: e.id,
+		label: e.title,
+		ids: t
+	};
+}, it = (e, t, { onEdit: n, onConnect: r, onMove: i, onAddPort: a, onDisconnectPort: o, onDeletePort: s, onDelete: c, onSelect: l, onContextMenu: u } = {}) => ({
+	canvas: {
+		onSelectNode: (t, n) => l?.(t?.item || null, e.toData(n)),
+		onContextMenu: (t, n) => u?.(t?.item || null, e.toData(n))
+	},
+	loader: {
+		onEdit: (e) => n?.(e.item),
+		onConnect: async ({ connect: e, input: n, source: i, target: a }) => {
+			if (r) return r({
+				connect: e,
+				input: n,
+				source: {
+					node: t.get(i.node).item,
+					port: i.port
+				},
+				target: a?.map(({ node: e, port: n }) => {
+					let r = t.get(e);
+					if (r) return {
+						node: r.item,
+						port: n
+					};
+				}).filter((e) => !!e)
+			});
+		},
+		onMove: async (t, n) => i?.(t.item, e.toData(n)),
+		onAddPort: async (e, t) => a?.(e.item, t),
+		onDisconnectPort: async (e, t) => o?.(e.item, t),
+		onDeletePort: async (e, t) => s?.(e.item, t),
+		onDelete: async (e) => c?.(e.item)
+	}
+}), at = {
+	x: 0,
+	y: 0
+}, ot = y(function({ innerRef: e, nodes: t, subset: n, coordinator: r, menu: i, onSelectNode: u, onContextMenu: d, ...f }) {
+	let p = l(at), m = l(null), g = c(() => new $(i), [i]), _ = c(() => new Ye({
+		maxFPS: 120,
+		grid: {
+			cellSize: r.gridSize,
+			colors: [
+				2236962,
+				3355443,
+				6710886,
+				10066329
+			]
+		},
+		gui: [g]
+	}), [r]);
+	o(e, () => ({
+		graph: _,
+		get element() {
+			return m.current?.element;
+		}
+	}));
+	let v = h(({ width: e, height: t }) => _.resize(e, t)), y = h(() => {
+		let { x: e, y: t } = r.toData(_.translation), { x: n, y: i } = r.toData(p.current);
+		g.text = `Pos: ${-(e - 1)} x ${-(t - 1)}\nCursor: ${~~(n - 1)} x ${~~(i - 1)}`;
+	}), x = h((e) => {
+		p.current = _.fromLocal(e), y();
+	}), S = h((e) => {
+		p.current = _.fromLocal(e), _.releaseNode(), y();
+	}), C = h((e, t) => {
+		if (x(e), _.capturing && !t?.shiftKey && u(null, r.toData(p.current)), !1 === u(_.capturing || null, r.toData(p.current))) return _.releaseNode(), !1;
+	}), w = h((e) => {
+		_.capturing || (_.translate(e), y());
+	}), ee = h((e) => {
+		if (!1 === C(e)) return !1;
+		if (!1 === d(_.capturing || null, r.toData(p.current))) return _.releaseNode(), !1;
+	}), te = c(() => ({
+		get position() {
+			return _.translation;
+		},
+		onDrag: w,
+		onPointer: x,
+		onClick: C,
+		onUp: S,
+		onContext: ee
+	}), [_]);
+	return a(() => {
+		if (!m.current) return;
+		let e = n || t.map(({ id: e }) => e);
+		_.batch(() => {
+			for (let t of _) e.includes(t.id) || _.removeNode(t);
+			for (let n of t) e.includes(n.id) && (_.addNode(n), _.moveNodeTo(n, n.position));
+			_.layout();
+		});
+	}, [n, t]), s(() => {
+		let e = m.current?.element;
+		if (e) return _.mount(e, { viewport: {
+			width: e.clientWidth,
+			height: e.clientHeight,
+			resolution: window.devicePixelRatio,
+			backgroundColor: 1315860,
+			antialias: !0,
+			transparent: !1
+		} });
+	}, [_]), /* @__PURE__ */ b(et, {
+		ref: m,
+		handlers: te,
+		onResize: v,
+		...f
+	});
+}), st = (e, { onEdit: t, onMove: n, onConnect: r, onDelete: i, onAddPort: a, onDisconnectPort: o, onDeletePort: s }) => {
+	e.onConnect(r), e.onMove((t) => n(e, t)), e.onEditAction(() => t(e)), e.onDeleteAction(() => i(e)), e.onAddPortAction((t) => a(e, t)), e.onDisconnectPortAction(({ port: t }) => o(e, t)), e.onDeletePortAction(({ port: t }) => s(e, t));
+}, ct = (e, t, { added: n, removed: r }) => {
+	if (n.length) {
+		let r = n.reduce((e, t) => (e[t.id] = t, e), {}), i = (t) => r[t] || e.find((e) => e.id === t);
+		for (let e of n) {
+			let t = e.item.ports;
+			if (!t.length) continue;
+			let n = e.item.id;
+			for (let { id: r, to: a, port: o, input: s } of t) {
+				if (!a) continue;
+				let t = i(a.id);
+				if (t) {
+					let i = t.getItemPort(({ to: e, name: t }) => e?.id === n && t === o);
+					i && e.connect({
+						connect: !0,
+						input: s,
+						port: r,
+						nodes: [{
+							node: t,
+							port: i.id
+						}]
+					});
+				}
+			}
+		}
+		if (t) for (let e of n) st(e, t);
+		e.add(n);
+	}
+	if (r.length) for (let t of r) e.remove(t);
+}, lt = () => [{
+	label: "Add node",
+	items: [{
+		label: "+ Call",
+		data: {
+			title: "Call",
+			args: {
+				ports: JSON.stringify({
+					in: ["input"],
+					out: ["output"]
+				}),
+				system: "You are helpful assistant",
+				instructions: "Summarize following input:\n{|input|}",
+				llm: "Result:\n"
+			}
+		}
+	}]
+}, {
+	label: "Add specific node",
+	items: [
+		{
+			label: "+ Splitter (2)",
+			data: {
+				title: "Splitter",
+				args: {
+					ports: JSON.stringify({
+						in: ["i"],
+						out: ["o1", "o2"]
+					}),
+					js: "const value = get($i);\nset($o1, value);\nset($o2, value);\n"
+				}
+			}
+		},
+		{
+			label: "",
+			separator: !0
+		},
+		{
+			label: "+ JSON → Ports",
+			data: {
+				title: "From JSON",
+				args: {
+					ports: JSON.stringify({
+						in: ["json"],
+						out: [
+							"o1",
+							"o2",
+							"o3"
+						]
+					}),
+					js: "const value = get($json);\ntry {\n  set(JSON.parse(value));\n} catch (e) {\nset({}); // default\n}\n"
+				}
+			}
+		}
+	]
+}], ut = (e, t) => ({
+	getMenu(t, n) {
+		let r = {
+			action: "add",
+			...e.toData(n)
+		};
+		return { items: lt().map(({ label: e, items: t }) => [{
+			label: e,
+			group: !0
+		}, ...t.map(({ label: e, data: t, ...n }) => ({
+			label: e,
+			data: t && {
+				...r,
+				...t
+			},
+			...n
+		}))]).flat() };
+	},
+	handleMenu({ action: e, ...n }) {
+		switch (e) {
+			case "add":
+				t?.(n);
+				return;
+		}
+	}
+}), dt = (e, t) => {
+	let n = l([]);
+	m(() => {
+		let i = t?.filter((e) => !n.current.some(r(e.id))), a = n.current.filter((e) => !t?.some(r(e.id)));
+		if (a) for (let { id: t } of a) e.find(r(t))?.setSelected(!1);
+		if (i) for (let { id: t } of i) e.find(r(t))?.setSelected(!0);
+		n.current = t || [];
+	}, [t, e]);
+}, ft = (e) => e.startsWith("channel_"), pt = (e) => ft(e) ? e.slice(8) : "", mt = (e) => ({ id: t, name: n, input: r, to: i, port: a }) => {
+	let o = pt(n);
+	o && (n = `${r ? "> " : ""}@${o}${r ? "" : " >"}`);
+	let s = [];
+	if (i) {
+		let t = e(i.id)?.ports.find(({ name: e }) => e === a);
+		t && s.push({
+			node: i.id,
+			port: t.id
+		});
+	}
+	return {
+		port: t,
+		name: n,
+		nodes: s
+	};
+}, ht = /* @__PURE__ */ function(e) {
+	return e[e.Idle = 1] = "Idle", e[e.Processing = 2] = "Processing", e[e.Done = 4] = "Done", e[e.Error = 8] = "Error", e[e.Selected = 16] = "Selected", e;
+}({}), gt = /* @__PURE__ */ function(e) {
+	return e[e.EDIT_NODE = 1] = "EDIT_NODE", e[e.ADD_PORT = 2] = "ADD_PORT", e[e.DISCONNECT_PORT = 3] = "DISCONNECT_PORT", e[e.DELETE_PORT = 4] = "DELETE_PORT", e[e.DELETE_NODE = 5] = "DELETE_NODE", e;
+}({}), _t = class extends ce {
+	#e;
+	#t;
+	constructor({ finder: e, item: t, coordinator: n, toTitle: r }) {
+		super({
+			coordinator: n,
+			item: t,
+			status: 1,
+			progress: 0,
+			id: t.id,
+			title: r(t),
+			inputs: t.ports.filter(({ input: e }) => !!e).map(mt(e)),
+			outputs: t.ports.filter(({ input: e }) => !e).map(mt(e))
+		}), this.position = this.coordinator.toGraph(t);
+	}
+	dispose() {
+		super.dispose(), this.#t &&= (this.#t.destroy({}), void 0), this.#e &&= (this.#e.destroy({}), void 0);
+	}
+	getMenu(e) {
+		switch (e?.type) {
+			case "node": return { items: [
+				{
+					label: this.title,
+					group: !0
+				},
+				{
+					label: "Edit",
+					data: { action: 1 }
+				},
+				{
+					label: "",
+					separator: !0
+				},
+				{
+					label: "Add input port",
+					data: {
+						action: 2,
+						input: !0
+					}
+				},
+				{
+					label: "Add output port",
+					data: {
+						action: 2,
+						input: !1
+					}
+				},
+				{
+					label: "",
+					separator: !0
+				},
+				{
+					label: "Delete node",
+					data: { action: 5 }
+				}
+			] };
+			case "port":
+				let t = this.inputs.find((t) => t.port === e.id), n = this.outputs.find((t) => t.port === e.id), r = t || n, i = !!(r && r.nodes.length);
+				return { items: [
+					{
+						label: `Port "${r?.name || "<?>"}"`,
+						group: !0
+					},
+					{
+						label: "Disconnect",
+						disabled: !i,
+						data: {
+							action: 3,
+							port: r
+						}
+					},
+					{
+						label: "",
+						separator: !0
+					},
+					{
+						label: "Delete",
+						disabled: !r,
+						data: {
+							action: 4,
+							port: r
+						}
+					}
+				] };
+		}
+	}
+	handleMenu(e) {
+		switch (e?.action) {
+			case 2: return this.dispatchEvent(e?.action, e.input);
+			case 3:
+			case 4: return e.port && this.dispatchEvent(e?.action, e.port);
+			case 1:
+			case 5: return this.dispatchEvent(e?.action, this.id);
+		}
+	}
+	onAddPortAction(e) {
+		return this.handleEvent(2, e);
+	}
+	onDisconnectPortAction(e) {
+		return this.handleEvent(3, e);
+	}
+	onDeletePortAction(e) {
+		return this.handleEvent(4, e);
+	}
+	onEditAction(e) {
+		return this.handleEvent(1, e);
+	}
+	onDeleteAction(e) {
+		return this.handleEvent(5, e);
+	}
+	setStatus(e) {
+		this.description.status = e, e !== 2 && this.setProgress(0);
+	}
+	setProgress(e) {
+		this.description.progress = e, this.#e?.setActive(this.isInProgress);
+	}
+	setSelected(e) {
+		e !== this.isSelected && (this.description.status = e ? this.description.status | 16 : this.description.status ^ 16, this.#t && (this.#t.first.active = e));
+	}
+	get item() {
+		return this.description.item;
+	}
+	getItemPort(e) {
+		return this.item.ports.find(e);
+	}
+	get isSelected() {
+		return !!(this.description.status & 16);
+	}
+	get isInProgress() {
+		return !!(this.description.status & 2) || this.description.progress > 0;
+	}
+	render(e) {
+		let t = ~~e.width - 1, n = ~~e.height - 2;
+		return this.#t ? this.#t.hotSwap(e) : this.#t = new qe(new Je({
+			width: t,
+			height: n,
+			color: 3407871,
+			lineSize: 1,
+			radius: 4
+		}), e), this.#t.first.active = this.isSelected, this.#e ? this.#e.hotSwap(this.#t) : this.#e = new z(this.#t, {
+			sizeX: t,
+			sizeY: n,
+			color: 3355647,
+			lineSize: 3,
+			radius: 4
+		}), this.#e.setActive(this.isInProgress), this.#e;
+	}
+}, vt = ({ coordinator: e, sync: t, onUpdate: n, store: r, toTitle: i }) => {
+	let a = l(t), o = c(() => ({
+		subscribe: (e) => r.onChange(e),
+		getSnapshot: () => r.get(),
+		selector: (e) => e.sort((e, t) => e.id.localeCompare(t.id)),
+		is: N
+	}), [r]), s = v(o.subscribe, o.getSnapshot, o.getSnapshot, o.selector, o.is), u = _(s), d = h((e) => s.find((t) => t.id === e));
+	a.current = t, m(() => {
+		let t = (t) => new _t({
+			finder: d,
+			item: t,
+			coordinator: e,
+			toTitle: i
+		});
+		if (u) {
+			let e = u.reduce((e, { id: t }) => (e[t] = !0, e), {}), n = s.filter((t) => !e[t.id]).map(t), r = Object.keys(e).filter((e) => !d(e));
+			(n.length || r.length) && a.current({
+				added: n,
+				removed: r
+			});
+		} else a.current({
+			added: s.map(t),
+			removed: []
+		});
+	}, [s, i]), m(() => S(() => s, n), []);
+}, yt = class {
+	grid;
+	gridSize;
+	sizes;
+	constructor(e) {
+		this.grid = e, this.gridSize = {
+			x: e,
+			y: e
+		}, this.sizes = {
+			grid: this.gridSize,
+			port: 8,
+			lane: 16,
+			space: 32
+		};
+	}
+	snap(e) {
+		let t = e < 0 ? -1 : 1;
+		return t * (Math.round(t * e / this.grid + .5) - .5) * this.grid;
+	}
+	toGraph({ x: e, y: t }) {
+		return {
+			x: (e - .5) * this.grid,
+			y: (t - .5) * this.grid
+		};
+	}
+	toData({ x: e, y: t }) {
+		return {
+			x: ~~(this.snap(e) / this.grid + .5),
+			y: ~~(this.snap(t) / this.grid + .5)
+		};
+	}
+}, bt = y(({ innerRef: e, graph: t, selected: n, handlers: r, children: i, onExport: a, ...s }) => {
+	let d = l(null), p = c(() => new yt(16), []), m = ut(p, r?.onCreate), [g, _] = me(() => new M()), [v, y] = u(), { canvas: S, loader: C } = it(p, g, r), w = h(() => a?.(t));
+	return o(e, () => ({
+		get graph() {
+			return d.current?.graph;
+		},
+		get element() {
+			return d.current?.element;
+		}
+	})), vt({
+		store: c(() => {
+			let e = new M(t.items);
+			return {
+				items: e,
+				get: () => e.all,
+				onChange: (t) => e.onChange(t)
+			};
+		}, [t.items]),
+		coordinator: p,
+		toTitle: (e) => e.title,
+		sync: (e) => ct(g, C, e),
+		onUpdate: () => e?.current?.graph.layout()
+	}), dt(_, n), /* @__PURE__ */ x("div", {
+		onContextMenu: f,
+		style: xt.root,
+		...s,
+		children: [/* @__PURE__ */ x("div", {
+			style: xt.selector,
+			children: [
+				i,
+				/* @__PURE__ */ b(nt, {
+					items: _,
+					onSelect: y
+				}),
+				/* @__PURE__ */ b("button", {
+					onClick: () => y(void 0),
+					children: "Update"
+				}),
+				a && /* @__PURE__ */ b("button", {
+					onClick: w,
+					children: "Export"
+				})
+			]
+		}), /* @__PURE__ */ b(ot, {
+			innerRef: d,
+			coordinator: p,
+			nodes: _,
+			subset: v,
+			menu: m,
+			...S
+		})]
+	});
+}), xt = d.of({
+	root: {
+		flex: 1,
+		display: "flex",
+		alignSelf: "stretch",
+		gap: 10
+	},
+	selector: {
+		display: "flex",
+		flexDirection: "column",
+		gap: 10
+	}
+});
+//#endregion
+export { ue as ClusteredLayout, fe as EdgesSort, Ye as GraphAdapter, ot as GraphCanvas, ce as GraphNode, k as GraphNodeJoints, le as LayeredLayout, pe as Layouter, bt as ManagedGraph, _t as ManagedGraphNode, gt as MenuActions, $e as NodeGroups, ht as NodeStatus, A as NodesGraph, de as NodesSort, $ as PIXIGUI, M as Store, et as Viewport, pt as getChannelName, ft as isChannelName, N as isEqualIdentifiables, P as useDraggable, me as useStore };
+
+//# sourceMappingURL=index.js.map