@yuneta/gobj-ui 7.23.156 → 7.23.157

package/dist/gobj-ui.es.js

@@ -6,7 +6,7 @@ import { createJSONEditor } from "vanilla-jsoneditor";
 import { TabulatorFull } from "tabulator-tables";
 import * as maplibregl from "maplibre-gl";
 import uPlot from "uplot";
-import { BaseLayout, BrushSelect, CanvasEvent, Circle, CommonEvent, Cubic, CubicHorizontal, DragCanvas, EdgeEvent, ExtensionCategory, Graph, HTML, HistoryEvent, NodeEvent, Polyline, Toolbar, ZoomCanvas, register } from "@antv/g6";
+import { BaseLayout, BrushSelect, CanvasEvent, Circle, CommonEvent, DragCanvas, EdgeEvent, ExtensionCategory, Graph, HTML, HistoryEvent, NodeEvent, Polyline, Toolbar, ZoomCanvas, register } from "@antv/g6";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -29309,321 +29309,6 @@ function tidy_tree_lr(nodes, edges, o) {
 	}
 	return pos;
 }
-/************************************************************
-*  The compact tree.
-*
-*  The tidy tree above gives every subtree its whole BLOCK: open a
-*  hall with twenty-four devices and its block widens, and with it
-*  every block above it, so the siblings of its ancestors move apart
-*  at depths where nothing of theirs touches. This one keeps the
-*  CONTOUR of each subtree instead -- its outline on each side, depth
-*  by depth -- and slides every sibling against the outline of the
-*  ones before it. A folded region then sits as close to an open one
-*  as their cards allow at each depth, which is what a folded treedb
-*  is: one branch open among closed ones.
-*
-*  Same spanning tree, same order, same rows as the tidy tree: only
-*  the packing across the depths differs, so switching between the
-*  two moves cards sideways and never reorders them.
-*
-*  And a run of three or more LEAF children -- a hall's devices, a
-*  region's places when none is open -- is STACKED: two columns
-*  under the parent with a corridor between them, row after row.
-*  That is what makes it compact when a whole level is open, where
-*  the contour alone gains nothing: every parent needed the whole
-*  row of its children beside it. The tree grows taller instead of
-*  wider. Its elbow edges run down the corridor (elbow_combs).
-*
-*  The contour arithmetic is Moen's ("Drawing dynamic trees", IEEE
-*  Software, 1990) in the form mxGraph gave it in mxCompactTreeLayout
-*  -- Copyright (c) 2006-2015 JGraph Ltd, Apache License 2.0 -- read in
-*  maxGraph's CompactTreeLayout.ts: leaf, join, merge, offset and
-*  bridge below follow that form. What is ours: it runs on the
-*  spanning tree of a FOREST, every depth is a row as wide as its
-*  widest card (mxGraph's `alignRanks`), several roots sit side by
-*  side, and there is no recursion.
-************************************************************/
-function layout_compact(nodes, edges, opts) {
-	let o = Object.assign({}, DEFAULTS, opts || {});
-	if (o.direction === "LR") return compact_tree_lr(nodes, edges, o);
-	let lr = compact_tree_lr(nodes.map((n) => Object.assign({}, n, {
-		w: n.h,
-		h: n.w
-	})), edges, o);
-	let pos = /* @__PURE__ */ new Map();
-	for (let [id, p] of lr) pos.set(id, {
-		x: p.y,
-		y: p.x
-	});
-	return pos;
-}
-function contour_line(dx, dy, next) {
-	return {
-		dx,
-		dy,
-		next: next || null
-	};
-}
-function contour_offset(p1, p2, a1, a2, b1, b2) {
-	if (b1 <= p1 || p1 + a1 <= 0) return 0;
-	let d;
-	if (b1 * a2 - a1 * b2 > 0) {
-		if (p1 < 0) d = p1 * a2 / a1 - p2;
-		else if (p1 > 0) d = p1 * b2 / b1 - p2;
-		else d = -p2;
-	} else if (b1 < p1 + a1) d = b2 - (p2 + (b1 - p1) * a2 / a1);
-	else if (b1 > p1 + a1) d = (a1 + p1) * b2 / b1 - (p2 + a2);
-	else d = b2 - (p2 + a2);
-	return d > 0 ? d : 0;
-}
-function contour_bridge(line1, x1, y1, line2, x2, y2) {
-	let dx = x2 + line2.dx - x1;
-	let dy = line2.dx === 0 ? line2.dy : dx * line2.dy / line2.dx;
-	let r = contour_line(dx, dy, line2.next);
-	line1.next = contour_line(0, y2 + line2.dy - dy - y1, r);
-	return r;
-}
-function contour_merge(p1, p2) {
-	let x = 0;
-	let y = 0;
-	let total = 0;
-	let upper = p1.lower_head;
-	let lower = p2.upper_head;
-	while (lower && upper) {
-		let d = contour_offset(x, y, lower.dx, lower.dy, upper.dx, upper.dy);
-		y += d;
-		total += d;
-		if (x + lower.dx <= upper.dx) {
-			x += lower.dx;
-			y += lower.dy;
-			lower = lower.next;
-		} else {
-			x -= upper.dx;
-			y -= upper.dy;
-			upper = upper.next;
-		}
-	}
-	if (lower) {
-		let b = contour_bridge(p1.upper_tail, 0, 0, lower, x, y);
-		p1.upper_tail = b.next ? p2.upper_tail : b;
-		p1.lower_tail = p2.lower_tail;
-	} else {
-		let b = contour_bridge(p2.lower_tail, x, y, upper, 0, 0);
-		if (!b.next) p1.lower_tail = b;
-	}
-	p1.lower_head = p2.lower_head;
-	return total;
-}
-function stack_trunk_width(k) {
-	let lanes = Math.max(0, k - 2);
-	return Math.max(36, 20 + Math.max(0, lanes - 1) * 6);
-}
-/************************************************************
-*  The children of every node, with each run of STACK_MIN_RUN or
-*  more consecutive LEAF children replaced by one STACK. Runs, not
-*  all the leaves of a parent: the children keep their order. A
-*  stack's key is an OBJECT, so it can never be taken for a node id,
-*  which is a string. Shared by the compact tree and the radial.
-*
-*  Returns {kids_of: Map<id, [id | stack]>, stacks: Map<stack, {ids, depth}>}
-************************************************************/
-function leaf_runs(t) {
-	let kids_of = /* @__PURE__ */ new Map();
-	let stacks = /* @__PURE__ */ new Map();
-	for (let [id, kids] of t.children) {
-		let out = [];
-		let run = [];
-		let flush = () => {
-			if (run.length >= 3) {
-				let key = { stack: stacks.size };
-				stacks.set(key, {
-					ids: run,
-					depth: t.depth.get(run[0])
-				});
-				out.push(key);
-			} else out.push(...run);
-			run = [];
-		};
-		for (let kid of kids) if ((t.children.get(kid) || []).length === 0) run.push(kid);
-		else {
-			flush();
-			out.push(kid);
-		}
-		flush();
-		kids_of.set(id, out);
-	}
-	return {
-		kids_of,
-		stacks
-	};
-}
-function stacked_order(t, kids_of) {
-	let order = [];
-	let todo = t.roots.slice().reverse();
-	while (todo.length) {
-		let id = todo.pop();
-		order.push(id);
-		let kids = kids_of.get(id) || [];
-		for (let i = kids.length - 1; i >= 0; i--) todo.push(kids[i]);
-	}
-	return order;
-}
-function stack_geometry(t, st, col_x, col_w) {
-	let d = st.depth;
-	let k = st.ids.length;
-	let rows = Math.ceil(k / 2);
-	let side = [0, 0];
-	let row_len = [];
-	for (let i = 0; i < k; i++) {
-		let n = t.by_id.get(st.ids[i]);
-		let r = Math.floor(i / 2);
-		side[i % 2] = Math.max(side[i % 2], n.h);
-		row_len[r] = Math.max(row_len[r] || 0, n.w);
-	}
-	row_len[0] = col_w[d];
-	let trunk = stack_trunk_width(k);
-	let starts = [col_x[d]];
-	for (let r = 1; r < rows; r++) starts[r] = starts[r - 1] + row_len[r - 1] + 40;
-	return {
-		side,
-		trunk,
-		starts,
-		row_len,
-		len: starts[rows - 1] + row_len[rows - 1] - col_x[d],
-		ext: side[0] + trunk + side[1]
-	};
-}
-function place_stack(t, st, g, top, pos) {
-	for (let i = 0; i < st.ids.length; i++) {
-		let n = t.by_id.get(st.ids[i]);
-		let r = Math.floor(i / 2);
-		let across = i % 2 === 0 ? top + g.side[0] - n.h / 2 : top + g.side[0] + g.trunk + n.h / 2;
-		pos.set(st.ids[i], {
-			x: g.starts[r] + g.row_len[r] / 2,
-			y: across
-		});
-	}
-}
-function compact_tree_lr(nodes, edges, o) {
-	let t = spanning_tree(nodes, edges);
-	let pos = /* @__PURE__ */ new Map();
-	let { kids_of, stacks } = leaf_runs(t);
-	let order = stacked_order(t, kids_of);
-	let col_w = [];
-	for (let [id, d] of t.depth) col_w[d] = Math.max(col_w[d] || 0, t.by_id.get(id).w);
-	let col_x = [];
-	let x = 0;
-	for (let d = 0; d < col_w.length; d++) {
-		col_x[d] = x;
-		x += (col_w[d] || 0) + o.ranksep;
-	}
-	let pad = o.nodesep / 2;
-	let dist = o.nodesep;
-	let level_distance = o.ranksep - pad;
-	let tn = /* @__PURE__ */ new Map();
-	for (let id of order) {
-		let st = stacks.get(id);
-		if (st) {
-			let g = stack_geometry(t, st, col_x, col_w);
-			tn.set(id, {
-				len: g.len,
-				ext: g.ext,
-				geom: g,
-				off_x: 0,
-				off_y: 0,
-				y: 0,
-				contour: null
-			});
-		} else tn.set(id, {
-			len: col_w[t.depth.get(id)],
-			ext: t.by_id.get(id).h,
-			off_x: 0,
-			off_y: 0,
-			y: 0,
-			contour: null
-		});
-	}
-	for (let i = order.length - 1; i >= 0; i--) {
-		let id = order[i];
-		let n = tn.get(id);
-		let kids = kids_of.get(id) || [];
-		if (!kids.length) {
-			let upper = contour_line(n.len + dist, 0);
-			let lower_tail = contour_line(0, -n.ext - dist);
-			n.contour = {
-				upper_head: upper,
-				upper_tail: upper,
-				lower_tail,
-				lower_head: contour_line(n.len + dist, 0, lower_tail)
-			};
-			continue;
-		}
-		let first = tn.get(kids[0]);
-		n.contour = first.contour;
-		let h = first.ext + dist;
-		let span = h;
-		for (let k = 1; k < kids.length; k++) {
-			let kid = tn.get(kids[k]);
-			let d = contour_merge(n.contour, kid.contour);
-			kid.off_y = d + h;
-			kid.off_x = 0;
-			h = kid.ext + dist;
-			span += d + h;
-		}
-		let gap = pad + level_distance;
-		let y2 = (span - n.ext) / 2 - pad;
-		let y1 = y2 + n.ext + 2 * pad - span;
-		first.off_x = gap + n.len;
-		first.off_y = y1;
-		n.contour.upper_head = contour_line(n.len, 0, contour_line(gap, y1, n.contour.upper_head));
-		n.contour.lower_head = contour_line(n.len, 0, contour_line(gap, y2, n.contour.lower_head));
-	}
-	let root_of = /* @__PURE__ */ new Map();
-	for (let id of order) {
-		let n = tn.get(id);
-		if (!root_of.has(id)) root_of.set(id, id);
-		let kids = kids_of.get(id) || [];
-		if (!kids.length) continue;
-		let running = n.y + tn.get(kids[0]).off_y;
-		tn.get(kids[0]).y = running;
-		root_of.set(kids[0], root_of.get(id));
-		for (let k = 1; k < kids.length; k++) {
-			let kid = tn.get(kids[k]);
-			kid.y = running + kid.off_y;
-			running = kid.y;
-			root_of.set(kids[k], root_of.get(id));
-		}
-	}
-	let lo = /* @__PURE__ */ new Map();
-	let hi = /* @__PURE__ */ new Map();
-	for (let id of order) {
-		let r = root_of.get(id);
-		let n = tn.get(id);
-		lo.set(r, Math.min(lo.has(r) ? lo.get(r) : Infinity, n.y));
-		hi.set(r, Math.max(hi.has(r) ? hi.get(r) : -Infinity, n.y + n.ext));
-	}
-	let shift = /* @__PURE__ */ new Map();
-	let top = 0;
-	for (let r of t.roots) {
-		shift.set(r, top - lo.get(r));
-		top += hi.get(r) - lo.get(r) + o.nodesep * 2;
-	}
-	for (let id of order) {
-		let n = tn.get(id);
-		let y = n.y + shift.get(root_of.get(id));
-		let st = stacks.get(id);
-		if (st) {
-			place_stack(t, st, n.geom, y, pos);
-			continue;
-		}
-		let d = t.depth.get(id);
-		pos.set(id, {
-			x: col_x[d] + col_w[d] / 2,
-			y: y + n.ext / 2
-		});
-	}
-	return pos;
-}
 function extent_at(n, a) {
 	if (!n) return 0;
 	return Math.abs(n.w * Math.cos(a)) + Math.abs(n.h * Math.sin(a));
@@ -29645,103 +29330,56 @@ function extent_at(n, a) {
 *
 *      ranksep   the step between rings
 *      nodesep   the gap between neighbours on a ring
-*      stack     (default true) a run of three or more LEAF children
-*                is a STACK, as in the compact tree: it asks its
-*                ring for one row of about the square root of its
-*                cards, not for every leaf -- a hall with a hundred
-*                devices no longer blows the ring up -- and lays
-*                them in rows going OUTWARD, each row as full as
-*                the room it has: rings round the parent when it is
-*                alone, a fan inside its sector when it is not.
-*                false keeps every leaf on the ring.
 ************************************************************/
 function layout_radial(nodes, edges, opts) {
-	let o = Object.assign({}, DEFAULTS, { stack: true }, opts || {});
+	let o = Object.assign({}, DEFAULTS, opts || {});
 	let t = spanning_tree(nodes, edges);
 	let pos = /* @__PURE__ */ new Map();
 	if (!t.roots.length) return pos;
-	let runs = o.stack ? leaf_runs(t) : {
-		kids_of: t.children,
-		stacks: /* @__PURE__ */ new Map()
-	};
-	let kids_of = runs.kids_of;
-	let stacks = runs.stacks;
-	let order = stacked_order(t, kids_of);
-	for (let st of stacks.values()) {
-		st.per_row = Math.ceil(Math.sqrt(st.ids.length));
-		st.cards = st.ids.map((id) => t.by_id.get(id));
-	}
-	let stack_across = (st, a) => {
-		let w = 0;
-		for (let c of st.cards) w = Math.max(w, extent_at(c, a + Math.PI / 2));
-		return {
-			card: w,
-			row: st.per_row * w + (st.per_row - 1) * o.nodesep
-		};
-	};
-	let widest_along = (cards, a, half) => {
-		let e = 0;
-		for (let k = 0; k <= 16; k++) {
-			let th = a - half + 2 * half * k / 16;
-			for (let c of cards) e = Math.max(e, extent_at(c, th));
-		}
-		return e;
-	};
-	let depth_of = (id) => stacks.has(id) ? stacks.get(id).depth : t.depth.get(id);
-	let circ = (a, b) => {
-		let d = Math.abs(a - b) % (2 * Math.PI);
-		return d > Math.PI ? 2 * Math.PI - d : d;
-	};
-	let weight = /* @__PURE__ */ new Map();
+	let order = walk_order(t);
+	let leaves = /* @__PURE__ */ new Map();
 	for (let i = order.length - 1; i >= 0; i--) {
 		let id = order[i];
-		let st = stacks.get(id);
-		if (st) {
-			weight.set(id, st.per_row);
-			continue;
-		}
-		let kids = kids_of.get(id) || [];
+		let kids = t.children.get(id) || [];
 		if (!kids.length) {
-			weight.set(id, 1);
+			leaves.set(id, 1);
 			continue;
 		}
 		let n = 0;
-		for (let kid of kids) n += weight.get(kid);
-		weight.set(id, n);
+		for (let kid of kids) n += leaves.get(kid);
+		leaves.set(id, n);
 	}
 	let total = 0;
-	for (let root of t.roots) total += weight.get(root);
+	for (let root of t.roots) total += leaves.get(root);
 	let single = t.roots.length === 1;
-	let ring_of = (id) => depth_of(id) + (single ? 0 : 1);
+	let ring_of = (id) => t.depth.get(id) + (single ? 0 : 1);
 	let angle = /* @__PURE__ */ new Map();
 	let rings = [];
 	let sector = (root_id, root_from, root_span, root_parent) => {
-		let todo = [{
+		let stack = [{
 			id: root_id,
 			from: root_from,
 			span: root_span,
 			parent: root_parent
 		}];
-		while (todo.length) {
-			let { id, from, span, parent } = todo.pop();
+		while (stack.length) {
+			let { id, from, span, parent } = stack.pop();
 			let a = from + span / 2;
 			angle.set(id, a);
 			let ring = ring_of(id);
 			if (!rings[ring]) rings[ring] = [];
-			let st = stacks.get(id);
-			let n = st ? null : t.by_id.get(id);
+			let n = t.by_id.get(id);
 			rings[ring].push({
 				id,
 				angle: a,
-				span,
-				diag: st ? stack_across(st, a).row : Math.hypot(n.w, n.h),
-				ext: st ? widest_along(st.cards, a, Math.min(span / 2, Math.PI)) : extent_at(n, a),
-				parent_ext: !parent ? 0 : st ? widest_along([t.by_id.get(parent)], a, Math.min(span / 2, Math.PI)) : extent_at(t.by_id.get(parent), a)
+				diag: Math.hypot(n.w, n.h),
+				ext: extent_at(n, a),
+				parent_ext: parent ? extent_at(t.by_id.get(parent), a) : 0
 			});
 			let cursor = from;
-			for (let kid of kids_of.get(id) || []) {
-				let part = span * weight.get(kid) / weight.get(id);
-				todo.push({
+			for (let kid of t.children.get(id) || []) {
+				let part = span * leaves.get(kid) / leaves.get(id);
+				stack.push({
 					id: kid,
 					from: cursor,
 					span: part,
@@ -29755,120 +29393,38 @@ function layout_radial(nodes, edges, opts) {
 		let root = t.roots[0];
 		angle.set(root, 0);
 		let cursor = -Math.PI / 2;
-		for (let kid of kids_of.get(root) || []) {
-			let part = 2 * Math.PI * weight.get(kid) / weight.get(root);
+		for (let kid of t.children.get(root) || []) {
+			let part = 2 * Math.PI * leaves.get(kid) / leaves.get(root);
 			sector(kid, cursor, part, root);
 			cursor += part;
 		}
 	} else {
 		let cursor = -Math.PI / 2;
 		for (let root of t.roots) {
-			let part = 2 * Math.PI * weight.get(root) / total;
+			let part = 2 * Math.PI * leaves.get(root) / total;
 			sector(root, cursor, part, null);
 			cursor += part;
 		}
 	}
-	let fit = (list, r0) => {
-		let r = r0;
-		let sorted = list.slice().sort((a, b) => a.angle - b.angle);
-		for (let i = 0; i < sorted.length && sorted.length > 1; i++) {
-			let a = sorted[i];
-			let b = sorted[(i + 1) % sorted.length];
-			let gap = i + 1 < sorted.length ? b.angle - a.angle : b.angle + 2 * Math.PI - a.angle;
-			if (gap > 1e-9) r = Math.max(r, (a.diag / 2 + b.diag / 2 + o.nodesep) / gap);
-		}
-		return r;
-	};
 	let radius = [0];
-	let reaching = [];
 	for (let ring = 1; ring < rings.length; ring++) {
-		let members = rings[ring] || [];
 		let r = radius[ring - 1] + o.ranksep;
-		let band = 0;
-		for (let n of members) {
-			r = Math.max(r, radius[ring - 1] + (n.parent_ext + n.ext) / 2 + o.nodesep);
-			band = Math.max(band, n.ext);
-		}
-		r = fit(members, r);
-		for (let pass = 0; pass < 2; pass++) for (let g of reaching) {
-			if (g.reach < r - band / 2 - o.nodesep) continue;
-			for (let m of members) {
-				let d = circ(g.angle, m.angle);
-				if (d > g.half + 1e-9) r = Math.max(r, (m.diag / 2 + o.nodesep) / (d - g.half));
-				else r = Math.max(r, g.reach + m.ext / 2 + o.nodesep);
-			}
+		for (let n of rings[ring] || []) r = Math.max(r, radius[ring - 1] + (n.parent_ext + n.ext) / 2 + o.nodesep);
+		let list = (rings[ring] || []).slice().sort((a, b) => a.angle - b.angle);
+		for (let i = 0; i < list.length && list.length > 1; i++) {
+			let a = list[i];
+			let b = list[(i + 1) % list.length];
+			let gap = i + 1 < list.length ? b.angle - a.angle : b.angle + 2 * Math.PI - a.angle;
+			if (gap > 1e-9) r = Math.max(r, (a.diag / 2 + b.diag / 2 + o.nodesep) / gap);
 		}
 		radius[ring] = r;
-		let sorted = members.slice().sort((a, b) => a.angle - b.angle);
-		for (let i = 0; i < sorted.length; i++) {
-			let m = sorted[i];
-			let st = stacks.get(m.id);
-			if (!st) continue;
-			let room = m.span / 2;
-			if (sorted.length > 1) {
-				let left = sorted[(i - 1 + sorted.length) % sorted.length];
-				let right = sorted[(i + 1) % sorted.length];
-				room = Math.min(room, circ(m.angle, left.angle) - (left.diag / 2 + o.nodesep) / r, circ(m.angle, right.angle) - (right.diag / 2 + o.nodesep) / r);
-			}
-			room = Math.min(room, Math.PI);
-			let across = 0;
-			let along = 0;
-			for (let k = 0; k <= 16; k++) {
-				let th = m.angle - room + 2 * room * k / 16;
-				for (let c of st.cards) {
-					across = Math.max(across, extent_at(c, th + Math.PI / 2));
-					along = Math.max(along, extent_at(c, th));
-				}
-			}
-			let rows = [];
-			let left_to_place = st.ids.length;
-			let rr = r;
-			let half = 0;
-			while (left_to_place > 0) {
-				let fits = Math.floor(2 * room * rr / (across + o.nodesep));
-				let cnt = Math.max(1, Math.min(left_to_place, fits));
-				rows.push({
-					rr,
-					cnt
-				});
-				half = Math.max(half, (cnt * (across + o.nodesep) - o.nodesep) / 2 / rr);
-				left_to_place -= cnt;
-				rr += along + 40;
-			}
-			st.plan = {
-				angle: m.angle,
-				across,
-				rows
-			};
-			reaching.push({
-				angle: m.angle,
-				half,
-				reach: rows[rows.length - 1].rr + along / 2
-			});
-		}
 	}
 	for (let [id, a] of angle) {
-		let st = stacks.get(id);
-		if (!st) {
-			let r0 = radius[ring_of(id)] || 0;
-			pos.set(id, {
-				x: r0 * Math.cos(a),
-				y: r0 * Math.sin(a)
-			});
-			continue;
-		}
-		let i = 0;
-		for (let row of st.plan.rows) {
-			let step = (st.plan.across + o.nodesep) / row.rr;
-			for (let j = 0; j < row.cnt; j++) {
-				let th = a + (j - (row.cnt - 1) / 2) * step;
-				pos.set(st.ids[i], {
-					x: row.rr * Math.cos(th),
-					y: row.rr * Math.sin(th)
-				});
-				i++;
-			}
-		}
+		let r = radius[ring_of(id)] || 0;
+		pos.set(id, {
+			x: r * Math.cos(a),
+			y: r * Math.sin(a)
+		});
 	}
 	return pos;
 }
@@ -29882,23 +29438,6 @@ function elbow_lane(ids, id) {
 	if (k <= 0) return 0;
 	return (k % 2 ? 1 : -1) * Math.ceil(k / 2);
 }
-/************************************************************
-*  The rank of `id` among `items` ([{id, span}]): the forward
-*  edges that share one end with it, each with how far it runs
-*  ACROSS. Farthest first; a tie goes to the edge made first.
-*  Returns {rank, count}.
-************************************************************/
-function elbow_rank(items, id) {
-	let sorted = items.slice().sort((a, b) => {
-		if (b.span !== a.span) return b.span - a.span;
-		return String(a.id).localeCompare(String(b.id), void 0, { numeric: true });
-	});
-	let rank = sorted.findIndex((it) => it.id === id);
-	return {
-		rank: rank < 0 ? 0 : rank,
-		count: sorted.length
-	};
-}
 function swap(p) {
 	return [p[1], p[0]];
 }
@@ -29910,136 +29449,6 @@ function swap_box(b) {
 		y2: b.x2
 	};
 }
-function staggered_turn(lo, hi, st) {
-	let mid = (lo + hi) / 2;
-	let group = null;
-	let k = 0;
-	if (st.dep && st.dep.count > 1) {
-		group = st.dep;
-		k = st.dep.rank;
-	} else if (st.arr && st.arr.count > 1) {
-		group = st.arr;
-		k = st.arr.count - 1 - st.arr.rank;
-	}
-	if (group) {
-		let room = Math.max(0, hi - lo - 12);
-		let step = Math.min(10, room / (group.count - 1));
-		mid = mid - (group.count - 1) * step / 2 + k * step;
-	}
-	return mid;
-}
-/************************************************************
-*  The combs of the stacks under one card.
-*
-*  treedb_layout.js lays a run of leaf children out as two columns
-*  with a corridor between them. A card in the first row is reached
-*  from the channel like any other; one in a lower row cannot be --
-*  the card above it stands in the way -- so its edge runs down
-*  the corridor in a LANE of its own and turns into the gap above
-*  its card, which it shares only with the other card of its row,
-*  reached from the other side.
-*
-*      targets     [{id, box}]: the forward edges leaving one card,
-*                  each with the box of the card it reaches
-*      vertical    as in elbow_points; false swaps the boxes
-*
-*  Returns Map id -> {lane, z, top}: the lane, the height of the
-*  gap it turns into, and the top of the stack's first row (where
-*  the channel over the stack ends). Only for a card that stands
-*  under another of the group, within a stack gap and lined up
-*  with it on the corridor side -- what a stack looks like.
-*
-*  Lanes go outermost first, row by row: a line into a higher row
-*  keeps outside the lines going deeper, and none crosses another.
-************************************************************/
-function elbow_combs(targets, vertical) {
-	let list = vertical ? targets : targets.map((it) => ({
-		id: it.id,
-		box: swap_box(it.box)
-	}));
-	let cy = (b) => (b.y1 + b.y2) / 2;
-	let near = (a, b) => Math.abs(a - b) < 1.5;
-	let under = [];
-	for (let it of list) {
-		let b = it.box;
-		let above = null;
-		for (let o of list) {
-			let a = o.box;
-			if (o === it || a.y2 > b.y1 || b.y1 - a.y2 > 40) continue;
-			if (!(near(a.x2, b.x2) || near(a.x1, b.x1))) continue;
-			if (!above || a.y2 > above.y2) above = a;
-		}
-		if (!above) continue;
-		let side;
-		if (near(above.x2, b.x2) && !near(above.x1, b.x1)) side = 0;
-		else if (near(above.x1, b.x1) && !near(above.x2, b.x2)) side = 1;
-		else side = list.some((o) => o !== it && near(cy(o.box), cy(b)) && o.box.x2 <= b.x1) ? 1 : 0;
-		under.push({
-			id: it.id,
-			box: b,
-			above,
-			side
-		});
-	}
-	let corridor = (u) => {
-		if (u.side === 0) {
-			let l = u.box.x2;
-			let col = list.filter((o) => near(o.box.x2, l));
-			let r = Infinity;
-			for (let c of col) for (let o of list) if (o !== c && near(cy(o.box), cy(c.box)) && o.box.x1 >= l - .5) r = Math.min(r, o.box.x1);
-			return {
-				l,
-				r: isFinite(r) ? r : l + 36,
-				col
-			};
-		}
-		let r = u.box.x1;
-		let col = list.filter((o) => near(o.box.x1, r));
-		let l = -Infinity;
-		for (let c of col) for (let o of list) if (o !== c && near(cy(o.box), cy(c.box)) && o.box.x2 <= r + .5) l = Math.max(l, o.box.x2);
-		return {
-			l: isFinite(l) ? l : r - 36,
-			r,
-			col
-		};
-	};
-	let groups = /* @__PURE__ */ new Map();
-	for (let u of under) {
-		let c = corridor(u);
-		u.top = Math.min(...c.col.map((o) => o.box.y1));
-		let key = `${Math.round(c.l)}|${Math.round(c.r)}`;
-		if (!groups.has(key)) groups.set(key, {
-			l: c.l,
-			r: c.r,
-			left: [],
-			right: []
-		});
-		groups.get(key)[u.side === 0 ? "left" : "right"].push(u);
-	}
-	let out = /* @__PURE__ */ new Map();
-	for (let g of groups.values()) {
-		g.left.sort((a, b) => a.box.y1 - b.box.y1);
-		g.right.sort((a, b) => a.box.y1 - b.box.y1);
-		let n = g.left.length + g.right.length;
-		let room = g.r - g.l - 20;
-		let step = n > 1 ? Math.max(0, Math.min(6, room / (n - 1))) : 0;
-		g.left.forEach((u, i) => {
-			out.set(u.id, {
-				lane: g.l + 10 + i * step,
-				z: (u.above.y2 + u.box.y1) / 2,
-				top: u.top
-			});
-		});
-		g.right.forEach((u, j) => {
-			out.set(u.id, {
-				lane: g.r - 10 - j * step,
-				z: (u.above.y2 + u.box.y1) / 2,
-				top: u.top
-			});
-		});
-	}
-	return out;
-}
 /************************************************************
 *  The control points of an elbow from the port `s` to the port
 *  `t` ([x, y] each), knowing the boxes of the two cards
@@ -30047,33 +29456,13 @@ function elbow_combs(targets, vertical) {
 *
 *      vertical    the rows are stacked (top to bottom); false
 *                  when they are side by side (left to right)
-*      stagger     {dep, arr, comb}: the edge's rank among the
-*                  forward edges leaving its source card and among
-*                  those reaching its target card (elbow_rank), and
-*                  its comb when the target is in a lower row of a
-*                  stack (elbow_combs). Absent, the channel is the
-*                  middle.
-************************************************************/
-function elbow_points(s, t, box_s, box_t, lane, vertical, stagger) {
-	if (!vertical) return elbow_points(swap(s), swap(t), swap_box(box_s), swap_box(box_t), lane, true, stagger).map(swap);
+************************************************************/
+function elbow_points(s, t, box_s, box_t, lane, vertical) {
+	if (!vertical) return elbow_points(swap(s), swap(t), swap_box(box_s), swap_box(box_t), lane, true).map(swap);
 	let shift = lane * 10;
 	if (t[1] - s[1] > 20) {
-		let st = stagger || {};
-		let lo = Math.max(s[1], box_s.y2);
-		if (st.comb) {
-			let c = st.comb;
-			let turn = staggered_turn(lo, c.top, { dep: st.dep }) + shift;
-			turn = Math.min(Math.max(turn, lo + 4), c.top - 4);
-			return [
-				[s[0], turn],
-				[c.lane, turn],
-				[c.lane, c.z],
-				[t[0], c.z]
-			];
-		}
-		let hi = Math.min(t[1], box_t.y1);
-		let mid = staggered_turn(lo, hi, st) + shift;
-		mid = Math.min(Math.max(mid, lo + 4), hi - 4);
+		let mid = (s[1] + t[1]) / 2 + shift;
+		mid = Math.min(Math.max(mid, s[1] + 10), t[1] - 10);
 		return [[s[0], mid], [t[0], mid]];
 	}
 	let out = 16 + Math.abs(shift);
@@ -30167,12 +29556,8 @@ function heap_pop(h) {
 /************************************************************
 *  The shortest orthogonal line from `a` to `z` that enters none
 *  of `boxes` (already expanded by the clearance), a turn costing
-*  ROUTE_BEND. The line leaves `a` SIDEWAYS and reaches `z`
-*  SIDEWAYS: the column straight under a port and the one straight
-*  over it belong to the forward edges that share that port, which
-*  run along them to their staggered turns -- a route going down
-*  that column lay on top of them. So a routed line shares only
-*  the stub between the port and `a` (or `z`).
+*  ROUTE_BEND. The line leaves `a` going down and ends at `z`
+*  going down, since after `z` it drops into a port.
 *
 *  The grid is SPARSE: only the lines of the boxes' borders and
 *  of the two ends, which is all an orthogonal shortest path ever
@@ -30238,8 +29623,7 @@ function orth_search(a, z, boxes) {
 		let k = state >> 2;
 		let dir = state & 3;
 		if (k === goal) {
-			if (dir >= 2) continue;
-			let total = cost + 40;
+			let total = cost + (dir === 2 ? 0 : 40);
 			if (total < found_cost) {
 				found_cost = total;
 				found = state;
@@ -30247,7 +29631,6 @@ function orth_search(a, z, boxes) {
 			continue;
 		}
 		for (let [nk, nd, len] of moves(k)) {
-			if (k === start && nd >= 2) continue;
 			let c = cost + len + (nd === dir ? 0 : 40);
 			let ns = nk * 4 + nd;
 			if (c < best[ns]) {
@@ -30288,11 +29671,10 @@ function orth_search(a, z, boxes) {
 *  coincide. Nearby cards first; all of them if that finds no way;
 *  the simple elbow if nothing does.
 ************************************************************/
-function elbow_route(s, t, box_s, box_t, lane, vertical, boxes, stagger) {
+function elbow_route(s, t, box_s, box_t, lane, vertical, boxes) {
 	let others = boxes || [];
-	if (!vertical) return elbow_route(swap(s), swap(t), swap_box(box_s), swap_box(box_t), lane, true, others.map(swap_box), stagger).map(swap);
-	if (stagger && stagger.comb) return elbow_points(s, t, box_s, box_t, lane, true, stagger);
-	let simple = elbow_points(s, t, box_s, box_t, lane, true, stagger);
+	if (!vertical) return elbow_route(swap(s), swap(t), swap_box(box_s), swap_box(box_t), lane, true, others.map(swap_box)).map(swap);
+	let simple = elbow_points(s, t, box_s, box_t, lane, true);
 	if (!elbow_path_hits([
 		s,
 		...simple,
@@ -30312,112 +29694,6 @@ function elbow_route(s, t, box_s, box_t, lane, vertical, boxes, stagger) {
 	if (!route && near.length < others.length) route = orth_search(a, z, others.map((b) => box_expand(b, m)));
 	return route || simple;
 }
-function path_points(path) {
-	let pts = [];
-	let cur = null;
-	for (let c of path) if (c[0] === "M" || c[0] === "L") {
-		cur = [c[1], c[2]];
-		pts.push(cur);
-	} else if (c[0] === "C" && cur) {
-		let [x0, y0] = cur;
-		for (let k = 1; k <= 16; k++) {
-			let u = k / 16;
-			let v = 1 - u;
-			pts.push([v * v * v * x0 + 3 * v * v * u * c[1] + 3 * v * u * u * c[3] + u * u * u * c[5], v * v * v * y0 + 3 * v * v * u * c[2] + 3 * v * u * u * c[4] + u * u * u * c[6]]);
-		}
-		cur = [c[5], c[6]];
-	} else if (c[0] === "Q" && cur) {
-		let [x0, y0] = cur;
-		for (let k = 1; k <= 16; k++) {
-			let u = k / 16;
-			let v = 1 - u;
-			pts.push([v * v * x0 + 2 * v * u * c[1] + u * u * c[3], v * v * y0 + 2 * v * u * c[2] + u * u * c[4]]);
-		}
-		cur = [c[3], c[4]];
-	}
-	return pts;
-}
-/************************************************************
-*  Does the G6 path `path` of a curved edge cross a card other than
-*  its own two? Measured on the curve itself -- the path G6 would
-*  draw, sampled -- and not on the rectangle round it, which took
-*  every card the curve merely passed near: the ports of a row
-*  stick well into the space above it. Its own two cards are left
-*  out: the curve starts and ends on their ports.
-************************************************************/
-function curve_hits(path, boxes, box_s, box_t) {
-	let pts = path_points(path);
-	if (pts.length < 2) return false;
-	let bb = {
-		x1: Infinity,
-		y1: Infinity,
-		x2: -Infinity,
-		y2: -Infinity
-	};
-	for (let p of pts) {
-		bb.x1 = Math.min(bb.x1, p[0]);
-		bb.y1 = Math.min(bb.y1, p[1]);
-		bb.x2 = Math.max(bb.x2, p[0]);
-		bb.y2 = Math.max(bb.y2, p[1]);
-	}
-	for (let b of boxes || []) {
-		if (same_box(b, box_s) || same_box(b, box_t) || !box_overlaps(b, box_expand(bb, 1))) continue;
-		let inner = box_expand(b, -1);
-		for (let k = 0; k + 1 < pts.length; k++) if (segment_hits(pts[k], pts[k + 1], inner)) return true;
-	}
-	return false;
-}
-/************************************************************
-*  A G6 path (['M'|'L'|'Q', ...]) along `points` with every corner
-*  rounded -- by `radius`, or by half the shorter of its two
-*  segments, so a short run is never overshot. The rounding is the
-*  quadratic G6's own polyline uses.
-************************************************************/
-function rounded_path(points, radius) {
-	let path = [[
-		"M",
-		points[0][0],
-		points[0][1]
-	]];
-	for (let i = 1; i + 1 < points.length; i++) {
-		let a = points[i - 1];
-		let m = points[i];
-		let b = points[i + 1];
-		let len_in = Math.hypot(m[0] - a[0], m[1] - a[1]);
-		let len_out = Math.hypot(b[0] - m[0], b[1] - m[1]);
-		let r = Math.min(radius, len_in / 2, len_out / 2);
-		let collinear = Math.abs((m[0] - a[0]) * (b[1] - m[1]) - (m[1] - a[1]) * (b[0] - m[0])) < 1e-9;
-		if (r <= 0 || collinear) {
-			path.push([
-				"L",
-				m[0],
-				m[1]
-			]);
-			continue;
-		}
-		let p1 = [m[0] - (m[0] - a[0]) / len_in * r, m[1] - (m[1] - a[1]) / len_in * r];
-		let p2 = [m[0] + (b[0] - m[0]) / len_out * r, m[1] + (b[1] - m[1]) / len_out * r];
-		path.push([
-			"L",
-			p1[0],
-			p1[1]
-		]);
-		path.push([
-			"Q",
-			m[0],
-			m[1],
-			p2[0],
-			p2[1]
-		]);
-	}
-	let last = points[points.length - 1];
-	path.push([
-		"L",
-		last[0],
-		last[1]
-	]);
-	return path;
-}
 //#endregion
 //#region node_modules/@babel/runtime/helpers/esm/typeof.js
 function _typeof(o) {
@@ -55305,7 +54581,7 @@ Easing Functions from anime.js, they are tried and true, so, its better to use t
 var Quad = function Quad(t) {
 	return Math.pow(t, 2);
 };
-var Cubic$1 = function Cubic(t) {
+var Cubic = function Cubic(t) {
 	return Math.pow(t, 3);
 };
 var Quart = function Quart(t) {
@@ -55442,10 +54718,10 @@ var EasingFunctions = {
 	"out-quad": EaseOut(Quad),
 	"in-out-quad": EaseInOut(Quad),
 	"out-in-quad": EaseOutIn(Quad),
-	"in-cubic": Cubic$1,
-	"out-cubic": EaseOut(Cubic$1),
-	"in-out-cubic": EaseInOut(Cubic$1),
-	"out-in-cubic": EaseOutIn(Cubic$1),
+	"in-cubic": Cubic,
+	"out-cubic": EaseOut(Cubic),
+	"in-out-cubic": EaseInOut(Cubic),
+	"out-in-cubic": EaseOutIn(Cubic),
 	"in-quart": Quart,
 	"out-quart": EaseOut(Quart),
 	"in-out-quart": EaseInOut(Quart),
@@ -57282,12 +56558,6 @@ var _layouts = {
 		nodesep: 18,
 		ranksep: 90
 	},
-	"compact-tree": {
-		type: "treedb-compact",
-		direction: "TB",
-		nodesep: 18,
-		ranksep: 90
-	},
 	"dagre": {
 		type: "dagre",
 		rankdir: "LR",
@@ -57615,11 +56885,8 @@ function register_layouts(gobj) {
 		_g6_extensions_registered = true;
 		register(ExtensionCategory.LAYOUT, "manual", ManualLayout);
 		register(ExtensionCategory.LAYOUT, "treedb-tree", TreedbTreeLayout);
-		register(ExtensionCategory.LAYOUT, "treedb-compact", TreedbCompactLayout);
 		register(ExtensionCategory.EDGE, "treedb-elbow-v", TreedbElbowV);
 		register(ExtensionCategory.EDGE, "treedb-elbow-h", TreedbElbowH);
-		register(ExtensionCategory.EDGE, "treedb-curve-v", TreedbCurveV);
-		register(ExtensionCategory.EDGE, "treedb-curve-h", TreedbCurveH);
 		register(ExtensionCategory.LAYOUT, "treedb-radial", TreedbRadialLayout);
 		register(ExtensionCategory.NODE, "light", LightNode);
 		register(ExtensionCategory.NODE, "treedb-card", TreedbCard);
@@ -58314,9 +57581,7 @@ function layout_direction(gobj) {
 function edge_type_for(gobj) {
 	let lr = layout_direction(gobj) === "LR";
 	let rowless = gobj_read_attr(gobj, "rowless_layouts") || [];
-	let rows = !str_in_list(rowless, gobj.priv.layout);
-	if (rows && gobj_read_str_attr(gobj, "edge_shape") === "elbow") return lr ? "treedb-elbow-h" : "treedb-elbow-v";
-	if (rows) return lr ? "treedb-curve-h" : "treedb-curve-v";
+	if (gobj_read_str_attr(gobj, "edge_shape") === "elbow" && !str_in_list(rowless, gobj.priv.layout)) return lr ? "treedb-elbow-h" : "treedb-elbow-v";
 	return lr ? "cubic-horizontal" : "cubic";
 }
 /************************************************************
@@ -59803,9 +59068,8 @@ var TreedbTreeLayout = class extends BaseLayout {
 *  dragged card, a fold or a layout needs nothing else. `-v` runs
 *  between rows (top to bottom), `-h` between columns. An edge that
 *  does not run forward goes round the two cards, the edges joining
-*  the same two cards take lanes, the edges sharing an end turn at
-*  staggered heights, and a line that would cross any other card is
-*  routed round it (treedb_elbow.js).
+*  the same two cards take lanes, and a line that would cross any
+*  other card is routed round it (treedb_elbow.js).
 ************************************************************/
 var ELBOW_RADIUS = 6;
 function elbow_box(node) {
@@ -59857,55 +59121,10 @@ function elbow_lane_of(edge) {
 		return 0;
 	}
 }
-function elbow_stagger_of(edge, vertical) {
-	let graph = edge.context && edge.context.graph;
-	let element = edge.context && edge.context.element;
-	let s = edge.sourceNode && edge.sourceNode.id;
-	let t = edge.targetNode && edge.targetNode.id;
-	if (!graph || !element || s === void 0 || t === void 0) return null;
-	let across = vertical ? 0 : 1;
-	let along = vertical ? 1 : 0;
-	let pos = (id) => graph.getElementPosition(id);
-	let port_of = (node_id, key) => {
-		let node = element.getElement(node_id);
-		let ports = node && typeof node.getPorts === "function" ? node.getPorts() : {};
-		let port = key ? ports[key] : null;
-		return port ? port.getPosition() : pos(node_id);
-	};
-	try {
-		let ps = pos(s);
-		let pt = pos(t);
-		let leaving = graph.getRelatedEdgesData(s, "out").filter((d) => d.source === s && pos(d.target)[along] > ps[along]);
-		let combs = elbow_combs(leaving.map((d) => ({
-			id: d.id,
-			box: elbow_box(element.getElement(d.target))
-		})), vertical);
-		let dep = leaving.map((d) => {
-			let comb = combs.get(d.id);
-			let far = comb ? comb.lane : pos(d.target)[across];
-			return {
-				id: d.id,
-				span: Math.abs(far - port_of(s, d.style && d.style.sourcePort)[across])
-			};
-		});
-		let arr = graph.getRelatedEdgesData(t, "in").filter((d) => d.target === t && pos(d.source)[along] < pt[along]).map((d) => ({
-			id: d.id,
-			span: Math.abs(port_of(d.source, d.style && d.style.sourcePort)[across] - pt[across])
-		}));
-		return {
-			dep: elbow_rank(dep, edge.id),
-			arr: elbow_rank(arr, edge.id),
-			comb: combs.get(edge.id) || null
-		};
-	} catch (e) {
-		log_error(`elbow edge ${edge.id}: cannot read the edges sharing its ends: ${e}`);
-		return null;
-	}
-}
 var TreedbElbowV = class extends Polyline {
 	getControlPoints(attributes) {
 		let [s, t] = this.getEndpoints(attributes, false);
-		return elbow_route(s, t, elbow_box(this.sourceNode), elbow_box(this.targetNode), elbow_lane_of(this), true, elbow_obstacles(this), elbow_stagger_of(this, true));
+		return elbow_route(s, t, elbow_box(this.sourceNode), elbow_box(this.targetNode), elbow_lane_of(this), true, elbow_obstacles(this));
 	}
 	getKeyPath(attributes) {
 		return super.getKeyPath(Object.assign({}, attributes, { radius: attributes.radius || ELBOW_RADIUS }));
@@ -59914,52 +59133,12 @@ var TreedbElbowV = class extends Polyline {
 var TreedbElbowH = class extends Polyline {
 	getControlPoints(attributes) {
 		let [s, t] = this.getEndpoints(attributes, false);
-		return elbow_route(s, t, elbow_box(this.sourceNode), elbow_box(this.targetNode), elbow_lane_of(this), false, elbow_obstacles(this), elbow_stagger_of(this, false));
+		return elbow_route(s, t, elbow_box(this.sourceNode), elbow_box(this.targetNode), elbow_lane_of(this), false, elbow_obstacles(this));
 	}
 	getKeyPath(attributes) {
 		return super.getKeyPath(Object.assign({}, attributes, { radius: attributes.radius || ELBOW_RADIUS }));
 	}
 };
-/************************************************************
-*  A CURVED edge that keeps off the cards. G6's cubic, as before,
-*  unless that very curve -- sampled, not guessed from the
-*  rectangle round it -- would cross a card other than its own two,
-*  or when it does not run forward and so would cross its own:
-*  the card above a lower row of a stack, a row between a parent
-*  and a far child. Then it goes the way an elbow would (the comb,
-*  the detour, the route: the same lanes and staggered turns) with
-*  round corners, so it still reads as a curve. `-v` for rows
-*  stacked top to bottom, `-h` for columns.
-************************************************************/
-function curve_key_path(edge, attributes, vertical, plain) {
-	let [s, t] = edge.getEndpoints(attributes, false);
-	let along = vertical ? 1 : 0;
-	let box_s = elbow_box(edge.sourceNode);
-	let box_t = elbow_box(edge.targetNode);
-	let boxes = elbow_obstacles(edge);
-	if (t[along] - s[along] > 20 && !curve_hits(plain, boxes, box_s, box_t)) return plain;
-	return rounded_path([
-		s,
-		...elbow_route(s, t, box_s, box_t, elbow_lane_of(edge), vertical, boxes, elbow_stagger_of(edge, vertical)),
-		t
-	], 24);
-}
-var TreedbCurveV = class extends Cubic {
-	getKeyPath(attributes) {
-		return curve_key_path(this, attributes, true, super.getKeyPath(attributes));
-	}
-};
-var TreedbCurveH = class extends CubicHorizontal {
-	getKeyPath(attributes) {
-		return curve_key_path(this, attributes, false, super.getKeyPath(attributes));
-	}
-};
-var TreedbCompactLayout = class extends BaseLayout {
-	async execute(data, options) {
-		let input = treedb_layout_input(data);
-		return treedb_layout_output(layout_compact(input.nodes, input.edges, options));
-	}
-};
 var TreedbRadialLayout = class extends BaseLayout {
 	async execute(data, options) {
 		let input = treedb_layout_input(data);
@@ -65453,7 +64632,6 @@ function option_label(name) {
 		case "edition": return t("edition");
 		case "manual": return t("manual");
 		case "treedb-tree": return t("treedb-tree");
-		case "compact-tree": return t("compact-tree");
 		case "radial": return t("radial");
 		case "dagre": return t("dagre");
 		case "antv-dagre": return t("antv-dagre");