@burdenoff/microfe-vibecontrols 2026.601.11 → 2026.601.13

package/dist/node_modules/dagre/lib/lodash.js

@@ -0,0 +1,67 @@
+import { __commonJSMin as e, __require as t } from "../../../_virtual/_rolldown/runtime.js";
+import { require_constant as n } from "../../lodash/constant.js";
+import { require_sortBy as r } from "../../lodash/sortBy.js";
+import { require_now as i } from "../../lodash/now.js";
+import { require_max as a } from "../../lodash/max.js";
+import { require_min as o } from "../../lodash/min.js";
+import { require_map as s } from "../../lodash/map.js";
+import { require_last as c } from "../../lodash/last.js";
+import { require_minBy as l } from "../../lodash/minBy.js";
+import { require_range as u } from "../../lodash/range.js";
+import { require_mapValues as d } from "../../lodash/mapValues.js";
+import { require_find as f } from "../../lodash/find.js";
+import { require_flatten as p } from "../../lodash/flatten.js";
+import { require_forEach as m } from "../../lodash/forEach.js";
+import { require_each as h } from "../../lodash/each.js";
+import { require_filter as g } from "../../lodash/filter.js";
+import { require_has as _ } from "../../lodash/has.js";
+import { require_isUndefined as v } from "../../lodash/isUndefined.js";
+import { require_reduce as y } from "../../lodash/reduce.js";
+import { require_values as b } from "../../lodash/values.js";
+import { require_cloneDeep as x } from "../../lodash/cloneDeep.js";
+import { require_defaults as S } from "../../lodash/defaults.js";
+import { require_forIn as C } from "../../lodash/forIn.js";
+import { require_merge as w } from "../../lodash/merge.js";
+import { require_pick as T } from "../../lodash/pick.js";
+import { require_uniqueId as E } from "../../lodash/uniqueId.js";
+import { require_zipObject as D } from "../../lodash/zipObject.js";
+//#region node_modules/dagre/lib/lodash.js
+var O = /* @__PURE__ */ e(((e, O) => {
+	var k;
+	if (typeof t == "function") try {
+		k = {
+			cloneDeep: x(),
+			constant: n(),
+			defaults: S(),
+			each: h(),
+			filter: g(),
+			find: f(),
+			flatten: p(),
+			forEach: m(),
+			forIn: C(),
+			has: _(),
+			isUndefined: v(),
+			last: c(),
+			map: s(),
+			mapValues: d(),
+			max: a(),
+			merge: w(),
+			min: o(),
+			minBy: l(),
+			now: i(),
+			pick: T(),
+			range: u(),
+			reduce: y(),
+			sortBy: r(),
+			uniqueId: E(),
+			values: b(),
+			zipObject: D()
+		};
+	} catch {}
+	k ||= window._, O.exports = k;
+}));
+//#endregion
+export default O();
+export { O as require_lodash };
+
+//# sourceMappingURL=lodash.js.map

package/dist/node_modules/dagre/lib/lodash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lodash.js","names":[],"sources":["../../../../node_modules/dagre/lib/lodash.js"],"sourcesContent":["/* global window */\n\nvar lodash;\n\nif (typeof require === \"function\") {\n  try {\n    lodash = {\n      cloneDeep: require(\"lodash/cloneDeep\"),\n      constant: require(\"lodash/constant\"),\n      defaults: require(\"lodash/defaults\"),\n      each: require(\"lodash/each\"),\n      filter: require(\"lodash/filter\"),\n      find: require(\"lodash/find\"),\n      flatten: require(\"lodash/flatten\"),\n      forEach: require(\"lodash/forEach\"),\n      forIn: require(\"lodash/forIn\"),\n      has:  require(\"lodash/has\"),\n      isUndefined: require(\"lodash/isUndefined\"),\n      last: require(\"lodash/last\"),\n      map: require(\"lodash/map\"),\n      mapValues: require(\"lodash/mapValues\"),\n      max: require(\"lodash/max\"),\n      merge: require(\"lodash/merge\"),\n      min: require(\"lodash/min\"),\n      minBy: require(\"lodash/minBy\"),\n      now: require(\"lodash/now\"),\n      pick: require(\"lodash/pick\"),\n      range: require(\"lodash/range\"),\n      reduce: require(\"lodash/reduce\"),\n      sortBy: require(\"lodash/sortBy\"),\n      uniqueId: require(\"lodash/uniqueId\"),\n      values: require(\"lodash/values\"),\n      zipObject: require(\"lodash/zipObject\"),\n    };\n  } catch (e) {\n    // continue regardless of error\n  }\n}\n\nif (!lodash) {\n  lodash = window._;\n}\n\nmodule.exports = lodash;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEA,IAAI;AAEJ,KAAI,OAAA,KAAmB,WACrB,KAAI;AACF,MAAS;GACP,WAAA,GAAA;GACA,UAAA,GAAA;GACA,UAAA,GAAA;GACA,MAAA,GAAA;GACA,QAAA,GAAA;GACA,MAAA,GAAA;GACA,SAAA,GAAA;GACA,SAAA,GAAA;GACA,OAAA,GAAA;GACA,KAAA,GAAA;GACA,aAAA,GAAA;GACA,MAAA,GAAA;GACA,KAAA,GAAA;GACA,WAAA,GAAA;GACA,KAAA,GAAA;GACA,OAAA,GAAA;GACA,KAAA,GAAA;GACA,OAAA,GAAA;GACA,KAAA,GAAA;GACA,MAAA,GAAA;GACA,OAAA,GAAA;GACA,QAAA,GAAA;GACA,QAAA,GAAA;GACA,UAAA,GAAA;GACA,QAAA,GAAA;GACA,WAAA,GAAA;GACD;SACS;AASd,CAJA,AACE,MAAS,OAAO,GAGlB,EAAO,UAAU"}

package/dist/node_modules/dagre/lib/nesting-graph.js

@@ -0,0 +1,76 @@
+import { __commonJSMin as e } from "../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "./lodash.js";
+import { require_util as n } from "./util.js";
+//#region node_modules/dagre/lib/nesting-graph.js
+var r = /* @__PURE__ */ e(((e, r) => {
+	var i = t(), a = n();
+	r.exports = {
+		run: o,
+		cleanup: u
+	};
+	function o(e) {
+		var t = a.addDummyNode(e, "root", {}, "_root"), n = c(e), r = i.max(i.values(n)) - 1, o = 2 * r + 1;
+		e.graph().nestingRoot = t, i.forEach(e.edges(), function(t) {
+			e.edge(t).minlen *= o;
+		});
+		var u = l(e) + 1;
+		i.forEach(e.children(), function(i) {
+			s(e, t, o, u, r, n, i);
+		}), e.graph().nodeRankFactor = o;
+	}
+	function s(e, t, n, r, o, c, l) {
+		var u = e.children(l);
+		if (!u.length) {
+			l !== t && e.setEdge(t, l, {
+				weight: 0,
+				minlen: n
+			});
+			return;
+		}
+		var d = a.addBorderNode(e, "_bt"), f = a.addBorderNode(e, "_bb"), p = e.node(l);
+		e.setParent(d, l), p.borderTop = d, e.setParent(f, l), p.borderBottom = f, i.forEach(u, function(i) {
+			s(e, t, n, r, o, c, i);
+			var a = e.node(i), u = a.borderTop ? a.borderTop : i, p = a.borderBottom ? a.borderBottom : i, m = a.borderTop ? r : 2 * r, h = u === p ? o - c[l] + 1 : 1;
+			e.setEdge(d, u, {
+				weight: m,
+				minlen: h,
+				nestingEdge: !0
+			}), e.setEdge(p, f, {
+				weight: m,
+				minlen: h,
+				nestingEdge: !0
+			});
+		}), e.parent(l) || e.setEdge(t, d, {
+			weight: 0,
+			minlen: o + c[l]
+		});
+	}
+	function c(e) {
+		var t = {};
+		function n(r, a) {
+			var o = e.children(r);
+			o && o.length && i.forEach(o, function(e) {
+				n(e, a + 1);
+			}), t[r] = a;
+		}
+		return i.forEach(e.children(), function(e) {
+			n(e, 1);
+		}), t;
+	}
+	function l(e) {
+		return i.reduce(e.edges(), function(t, n) {
+			return t + e.edge(n).weight;
+		}, 0);
+	}
+	function u(e) {
+		var t = e.graph();
+		e.removeNode(t.nestingRoot), delete t.nestingRoot, i.forEach(e.edges(), function(t) {
+			e.edge(t).nestingEdge && e.removeEdge(t);
+		});
+	}
+}));
+//#endregion
+export default r();
+export { r as require_nesting_graph };
+
+//# sourceMappingURL=nesting-graph.js.map

package/dist/node_modules/dagre/lib/nesting-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nesting-graph.js","names":[],"sources":["../../../../node_modules/dagre/lib/nesting-graph.js"],"sourcesContent":["var _ = require(\"./lodash\");\nvar util = require(\"./util\");\n\nmodule.exports = {\n  run: run,\n  cleanup: cleanup\n};\n\n/*\n * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,\n * adds appropriate edges to ensure that all cluster nodes are placed between\n * these boundries, and ensures that the graph is connected.\n *\n * In addition we ensure, through the use of the minlen property, that nodes\n * and subgraph border nodes to not end up on the same rank.\n *\n * Preconditions:\n *\n *    1. Input graph is a DAG\n *    2. Nodes in the input graph has a minlen attribute\n *\n * Postconditions:\n *\n *    1. Input graph is connected.\n *    2. Dummy nodes are added for the tops and bottoms of subgraphs.\n *    3. The minlen attribute for nodes is adjusted to ensure nodes do not\n *       get placed on the same rank as subgraph border nodes.\n *\n * The nesting graph idea comes from Sander, \"Layout of Compound Directed\n * Graphs.\"\n */\nfunction run(g) {\n  var root = util.addDummyNode(g, \"root\", {}, \"_root\");\n  var depths = treeDepths(g);\n  var height = _.max(_.values(depths)) - 1; // Note: depths is an Object not an array\n  var nodeSep = 2 * height + 1;\n\n  g.graph().nestingRoot = root;\n\n  // Multiply minlen by nodeSep to align nodes on non-border ranks.\n  _.forEach(g.edges(), function(e) { g.edge(e).minlen *= nodeSep; });\n\n  // Calculate a weight that is sufficient to keep subgraphs vertically compact\n  var weight = sumWeights(g) + 1;\n\n  // Create border nodes and link them up\n  _.forEach(g.children(), function(child) {\n    dfs(g, root, nodeSep, weight, height, depths, child);\n  });\n\n  // Save the multiplier for node layers for later removal of empty border\n  // layers.\n  g.graph().nodeRankFactor = nodeSep;\n}\n\nfunction dfs(g, root, nodeSep, weight, height, depths, v) {\n  var children = g.children(v);\n  if (!children.length) {\n    if (v !== root) {\n      g.setEdge(root, v, { weight: 0, minlen: nodeSep });\n    }\n    return;\n  }\n\n  var top = util.addBorderNode(g, \"_bt\");\n  var bottom = util.addBorderNode(g, \"_bb\");\n  var label = g.node(v);\n\n  g.setParent(top, v);\n  label.borderTop = top;\n  g.setParent(bottom, v);\n  label.borderBottom = bottom;\n\n  _.forEach(children, function(child) {\n    dfs(g, root, nodeSep, weight, height, depths, child);\n\n    var childNode = g.node(child);\n    var childTop = childNode.borderTop ? childNode.borderTop : child;\n    var childBottom = childNode.borderBottom ? childNode.borderBottom : child;\n    var thisWeight = childNode.borderTop ? weight : 2 * weight;\n    var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;\n\n    g.setEdge(top, childTop, {\n      weight: thisWeight,\n      minlen: minlen,\n      nestingEdge: true\n    });\n\n    g.setEdge(childBottom, bottom, {\n      weight: thisWeight,\n      minlen: minlen,\n      nestingEdge: true\n    });\n  });\n\n  if (!g.parent(v)) {\n    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });\n  }\n}\n\nfunction treeDepths(g) {\n  var depths = {};\n  function dfs(v, depth) {\n    var children = g.children(v);\n    if (children && children.length) {\n      _.forEach(children, function(child) {\n        dfs(child, depth + 1);\n      });\n    }\n    depths[v] = depth;\n  }\n  _.forEach(g.children(), function(v) { dfs(v, 1); });\n  return depths;\n}\n\nfunction sumWeights(g) {\n  return _.reduce(g.edges(), function(acc, e) {\n    return acc + g.edge(e).weight;\n  }, 0);\n}\n\nfunction cleanup(g) {\n  var graphLabel = g.graph();\n  g.removeNode(graphLabel.nestingRoot);\n  delete graphLabel.nestingRoot;\n  _.forEach(g.edges(), function(e) {\n    var edge = g.edge(e);\n    if (edge.nestingEdge) {\n      g.removeEdge(e);\n    }\n  });\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;CAAA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA;AAEJ,GAAO,UAAU;EACV;EACI;EACV;CAyBD,SAAS,EAAI,GAAG;EACd,IAAI,IAAO,EAAK,aAAa,GAAG,QAAQ,EAAE,EAAE,QAAQ,EAChD,IAAS,EAAW,EAAE,EACtB,IAAS,EAAE,IAAI,EAAE,OAAO,EAAO,CAAC,GAAG,GACnC,IAAU,IAAI,IAAS;AAK3B,EAHA,EAAE,OAAO,CAAC,cAAc,GAGxB,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,GAAG;AAAE,KAAE,KAAK,EAAE,CAAC,UAAU;IAAW;EAGlE,IAAI,IAAS,EAAW,EAAE,GAAG;AAS7B,EANA,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,GAAO;AACtC,KAAI,GAAG,GAAM,GAAS,GAAQ,GAAQ,GAAQ,EAAM;IACpD,EAIF,EAAE,OAAO,CAAC,iBAAiB;;CAG7B,SAAS,EAAI,GAAG,GAAM,GAAS,GAAQ,GAAQ,GAAQ,GAAG;EACxD,IAAI,IAAW,EAAE,SAAS,EAAE;AAC5B,MAAI,CAAC,EAAS,QAAQ;AACpB,GAAI,MAAM,KACR,EAAE,QAAQ,GAAM,GAAG;IAAE,QAAQ;IAAG,QAAQ;IAAS,CAAC;AAEpD;;EAGF,IAAI,IAAM,EAAK,cAAc,GAAG,MAAM,EAClC,IAAS,EAAK,cAAc,GAAG,MAAM,EACrC,IAAQ,EAAE,KAAK,EAAE;AA6BrB,EA3BA,EAAE,UAAU,GAAK,EAAE,EACnB,EAAM,YAAY,GAClB,EAAE,UAAU,GAAQ,EAAE,EACtB,EAAM,eAAe,GAErB,EAAE,QAAQ,GAAU,SAAS,GAAO;AAClC,KAAI,GAAG,GAAM,GAAS,GAAQ,GAAQ,GAAQ,EAAM;GAEpD,IAAI,IAAY,EAAE,KAAK,EAAM,EACzB,IAAW,EAAU,YAAY,EAAU,YAAY,GACvD,IAAc,EAAU,eAAe,EAAU,eAAe,GAChE,IAAa,EAAU,YAAY,IAAS,IAAI,GAChD,IAAS,MAAa,IAAkB,IAAS,EAAO,KAAK,IAAzB;AAQxC,GANA,EAAE,QAAQ,GAAK,GAAU;IACvB,QAAQ;IACA;IACR,aAAa;IACd,CAAC,EAEF,EAAE,QAAQ,GAAa,GAAQ;IAC7B,QAAQ;IACA;IACR,aAAa;IACd,CAAC;IACF,EAEG,EAAE,OAAO,EAAE,IACd,EAAE,QAAQ,GAAM,GAAK;GAAE,QAAQ;GAAG,QAAQ,IAAS,EAAO;GAAI,CAAC;;CAInE,SAAS,EAAW,GAAG;EACrB,IAAI,IAAS,EAAE;EACf,SAAS,EAAI,GAAG,GAAO;GACrB,IAAI,IAAW,EAAE,SAAS,EAAE;AAM5B,GALI,KAAY,EAAS,UACvB,EAAE,QAAQ,GAAU,SAAS,GAAO;AAClC,MAAI,GAAO,IAAQ,EAAE;KACrB,EAEJ,EAAO,KAAK;;AAGd,SADA,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,GAAG;AAAE,KAAI,GAAG,EAAE;IAAI,EAC5C;;CAGT,SAAS,EAAW,GAAG;AACrB,SAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,GAAK,GAAG;AAC1C,UAAO,IAAM,EAAE,KAAK,EAAE,CAAC;KACtB,EAAE;;CAGP,SAAS,EAAQ,GAAG;EAClB,IAAI,IAAa,EAAE,OAAO;AAG1B,EAFA,EAAE,WAAW,EAAW,YAAY,EACpC,OAAO,EAAW,aAClB,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,GAAG;AAE/B,GADW,EAAE,KAAK,EAAE,CACX,eACP,EAAE,WAAW,EAAE;IAEjB"}

package/dist/node_modules/dagre/lib/normalize.js

@@ -0,0 +1,45 @@
+import { __commonJSMin as e } from "../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "./lodash.js";
+import { require_util as n } from "./util.js";
+//#region node_modules/dagre/lib/normalize.js
+var r = /* @__PURE__ */ e(((e, r) => {
+	var i = t(), a = n();
+	r.exports = {
+		run: o,
+		undo: c
+	};
+	function o(e) {
+		e.graph().dummyChains = [], i.forEach(e.edges(), function(t) {
+			s(e, t);
+		});
+	}
+	function s(e, t) {
+		var n = t.v, r = e.node(n).rank, i = t.w, o = e.node(i).rank, s = t.name, c = e.edge(t), l = c.labelRank;
+		if (o !== r + 1) {
+			e.removeEdge(t);
+			var u, d, f;
+			for (f = 0, ++r; r < o; ++f, ++r) c.points = [], d = {
+				width: 0,
+				height: 0,
+				edgeLabel: c,
+				edgeObj: t,
+				rank: r
+			}, u = a.addDummyNode(e, "edge", d, "_d"), r === l && (d.width = c.width, d.height = c.height, d.dummy = "edge-label", d.labelpos = c.labelpos), e.setEdge(n, u, { weight: c.weight }, s), f === 0 && e.graph().dummyChains.push(u), n = u;
+			e.setEdge(n, i, { weight: c.weight }, s);
+		}
+	}
+	function c(e) {
+		i.forEach(e.graph().dummyChains, function(t) {
+			var n = e.node(t), r = n.edgeLabel, i;
+			for (e.setEdge(n.edgeObj, r); n.dummy;) i = e.successors(t)[0], e.removeNode(t), r.points.push({
+				x: n.x,
+				y: n.y
+			}), n.dummy === "edge-label" && (r.x = n.x, r.y = n.y, r.width = n.width, r.height = n.height), t = i, n = e.node(t);
+		});
+	}
+}));
+//#endregion
+export default r();
+export { r as require_normalize };
+
+//# sourceMappingURL=normalize.js.map

package/dist/node_modules/dagre/lib/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","names":[],"sources":["../../../../node_modules/dagre/lib/normalize.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"./lodash\");\nvar util = require(\"./util\");\n\nmodule.exports = {\n  run: run,\n  undo: undo\n};\n\n/*\n * Breaks any long edges in the graph into short segments that span 1 layer\n * each. This operation is undoable with the denormalize function.\n *\n * Pre-conditions:\n *\n *    1. The input graph is a DAG.\n *    2. Each node in the graph has a \"rank\" property.\n *\n * Post-condition:\n *\n *    1. All edges in the graph have a length of 1.\n *    2. Dummy nodes are added where edges have been split into segments.\n *    3. The graph is augmented with a \"dummyChains\" attribute which contains\n *       the first dummy in each chain of dummy nodes produced.\n */\nfunction run(g) {\n  g.graph().dummyChains = [];\n  _.forEach(g.edges(), function(edge) { normalizeEdge(g, edge); });\n}\n\nfunction normalizeEdge(g, e) {\n  var v = e.v;\n  var vRank = g.node(v).rank;\n  var w = e.w;\n  var wRank = g.node(w).rank;\n  var name = e.name;\n  var edgeLabel = g.edge(e);\n  var labelRank = edgeLabel.labelRank;\n\n  if (wRank === vRank + 1) return;\n\n  g.removeEdge(e);\n\n  var dummy, attrs, i;\n  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {\n    edgeLabel.points = [];\n    attrs = {\n      width: 0, height: 0,\n      edgeLabel: edgeLabel, edgeObj: e,\n      rank: vRank\n    };\n    dummy = util.addDummyNode(g, \"edge\", attrs, \"_d\");\n    if (vRank === labelRank) {\n      attrs.width = edgeLabel.width;\n      attrs.height = edgeLabel.height;\n      attrs.dummy = \"edge-label\";\n      attrs.labelpos = edgeLabel.labelpos;\n    }\n    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);\n    if (i === 0) {\n      g.graph().dummyChains.push(dummy);\n    }\n    v = dummy;\n  }\n\n  g.setEdge(v, w, { weight: edgeLabel.weight }, name);\n}\n\nfunction undo(g) {\n  _.forEach(g.graph().dummyChains, function(v) {\n    var node = g.node(v);\n    var origLabel = node.edgeLabel;\n    var w;\n    g.setEdge(node.edgeObj, origLabel);\n    while (node.dummy) {\n      w = g.successors(v)[0];\n      g.removeNode(v);\n      origLabel.points.push({ x: node.x, y: node.y });\n      if (node.dummy === \"edge-label\") {\n        origLabel.x = node.x;\n        origLabel.y = node.y;\n        origLabel.width = node.width;\n        origLabel.height = node.height;\n      }\n      v = w;\n      node = g.node(v);\n    }\n  });\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;CAEA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA;AAEJ,GAAO,UAAU;EACV;EACC;EACP;CAkBD,SAAS,EAAI,GAAG;AAEd,EADA,EAAE,OAAO,CAAC,cAAc,EAAE,EAC1B,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,GAAM;AAAE,KAAc,GAAG,EAAK;IAAI;;CAGlE,SAAS,EAAc,GAAG,GAAG;EAC3B,IAAI,IAAI,EAAE,GACN,IAAQ,EAAE,KAAK,EAAE,CAAC,MAClB,IAAI,EAAE,GACN,IAAQ,EAAE,KAAK,EAAE,CAAC,MAClB,IAAO,EAAE,MACT,IAAY,EAAE,KAAK,EAAE,EACrB,IAAY,EAAU;AAEtB,YAAU,IAAQ,GAEtB;KAAE,WAAW,EAAE;GAEf,IAAI,GAAO,GAAO;AAClB,QAAK,IAAI,GAAG,EAAE,GAAO,IAAQ,GAAO,EAAE,GAAG,EAAE,EAkBzC,CAjBA,EAAU,SAAS,EAAE,EACrB,IAAQ;IACN,OAAO;IAAG,QAAQ;IACP;IAAW,SAAS;IAC/B,MAAM;IACP,EACD,IAAQ,EAAK,aAAa,GAAG,QAAQ,GAAO,KAAK,EAC7C,MAAU,MACZ,EAAM,QAAQ,EAAU,OACxB,EAAM,SAAS,EAAU,QACzB,EAAM,QAAQ,cACd,EAAM,WAAW,EAAU,WAE7B,EAAE,QAAQ,GAAG,GAAO,EAAE,QAAQ,EAAU,QAAQ,EAAE,EAAK,EACnD,MAAM,KACR,EAAE,OAAO,CAAC,YAAY,KAAK,EAAM,EAEnC,IAAI;AAGN,KAAE,QAAQ,GAAG,GAAG,EAAE,QAAQ,EAAU,QAAQ,EAAE,EAAK;;;CAGrD,SAAS,EAAK,GAAG;AACf,IAAE,QAAQ,EAAE,OAAO,CAAC,aAAa,SAAS,GAAG;GAC3C,IAAI,IAAO,EAAE,KAAK,EAAE,EAChB,IAAY,EAAK,WACjB;AAEJ,QADA,EAAE,QAAQ,EAAK,SAAS,EAAU,EAC3B,EAAK,OAWV,CAVA,IAAI,EAAE,WAAW,EAAE,CAAC,IACpB,EAAE,WAAW,EAAE,EACf,EAAU,OAAO,KAAK;IAAE,GAAG,EAAK;IAAG,GAAG,EAAK;IAAG,CAAC,EAC3C,EAAK,UAAU,iBACjB,EAAU,IAAI,EAAK,GACnB,EAAU,IAAI,EAAK,GACnB,EAAU,QAAQ,EAAK,OACvB,EAAU,SAAS,EAAK,SAE1B,IAAI,GACJ,IAAO,EAAE,KAAK,EAAE;IAElB"}

package/dist/node_modules/dagre/lib/order/add-subgraph-constraints.js

@@ -0,0 +1,24 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/order/add-subgraph-constraints.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e, t, n) {
+		var i = {}, a;
+		r.forEach(n, function(n) {
+			for (var r = e.parent(n), o, s; r;) {
+				if (o = e.parent(r), o ? (s = i[o], i[o] = r) : (s = a, a = r), s && s !== r) {
+					t.setEdge(s, r);
+					return;
+				}
+				r = o;
+			}
+		});
+	}
+}));
+//#endregion
+export default n();
+export { n as require_add_subgraph_constraints };
+
+//# sourceMappingURL=add-subgraph-constraints.js.map

package/dist/node_modules/dagre/lib/order/add-subgraph-constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-subgraph-constraints.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/add-subgraph-constraints.js"],"sourcesContent":["var _ = require(\"../lodash\");\n\nmodule.exports = addSubgraphConstraints;\n\nfunction addSubgraphConstraints(g, cg, vs) {\n  var prev = {},\n    rootPrev;\n\n  _.forEach(vs, function(v) {\n    var child = g.parent(v),\n      parent,\n      prevChild;\n    while (child) {\n      parent = g.parent(child);\n      if (parent) {\n        prevChild = prev[parent];\n        prev[parent] = child;\n      } else {\n        prevChild = rootPrev;\n        rootPrev = child;\n      }\n      if (prevChild && prevChild !== child) {\n        cg.setEdge(prevChild, child);\n        return;\n      }\n      child = parent;\n    }\n  });\n\n  /*\n  function dfs(v) {\n    var children = v ? g.children(v) : g.children();\n    if (children.length) {\n      var min = Number.POSITIVE_INFINITY,\n          subgraphs = [];\n      _.each(children, function(child) {\n        var childMin = dfs(child);\n        if (g.children(child).length) {\n          subgraphs.push({ v: child, order: childMin });\n        }\n        min = Math.min(min, childMin);\n      });\n      _.reduce(_.sortBy(subgraphs, \"order\"), function(prev, curr) {\n        cg.setEdge(prev.v, curr.v);\n        return curr;\n      });\n      return min;\n    }\n    return g.node(v).order;\n  }\n  dfs(undefined);\n  */\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAAA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CAEjB,SAAS,EAAuB,GAAG,GAAI,GAAI;EACzC,IAAI,IAAO,EAAE,EACX;AAEF,IAAE,QAAQ,GAAI,SAAS,GAAG;AAIxB,QAHA,IAAI,IAAQ,EAAE,OAAO,EAAE,EACrB,GACA,GACK,IAAO;AASZ,QARA,IAAS,EAAE,OAAO,EAAM,EACpB,KACF,IAAY,EAAK,IACjB,EAAK,KAAU,MAEf,IAAY,GACZ,IAAW,IAET,KAAa,MAAc,GAAO;AACpC,OAAG,QAAQ,GAAW,EAAM;AAC5B;;AAEF,QAAQ;;IAEV"}

package/dist/node_modules/dagre/lib/order/barycenter.js

@@ -0,0 +1,34 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/order/barycenter.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e, t) {
+		return r.map(t, function(t) {
+			var n = e.inEdges(t);
+			if (n.length) {
+				var i = r.reduce(n, function(t, n) {
+					var r = e.edge(n), i = e.node(n.v);
+					return {
+						sum: t.sum + r.weight * i.order,
+						weight: t.weight + r.weight
+					};
+				}, {
+					sum: 0,
+					weight: 0
+				});
+				return {
+					v: t,
+					barycenter: i.sum / i.weight,
+					weight: i.weight
+				};
+			} else return { v: t };
+		});
+	}
+}));
+//#endregion
+export default n();
+export { n as require_barycenter };
+
+//# sourceMappingURL=barycenter.js.map

package/dist/node_modules/dagre/lib/order/barycenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"barycenter.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/barycenter.js"],"sourcesContent":["var _ = require(\"../lodash\");\n\nmodule.exports = barycenter;\n\nfunction barycenter(g, movable) {\n  return _.map(movable, function(v) {\n    var inV = g.inEdges(v);\n    if (!inV.length) {\n      return { v: v };\n    } else {\n      var result = _.reduce(inV, function(acc, e) {\n        var edge = g.edge(e),\n          nodeU = g.node(e.v);\n        return {\n          sum: acc.sum + (edge.weight * nodeU.order),\n          weight: acc.weight + edge.weight\n        };\n      }, { sum: 0, weight: 0 });\n\n      return {\n        v: v,\n        barycenter: result.sum / result.weight,\n        weight: result.weight\n      };\n    }\n  });\n}\n\n"],"x_google_ignoreList":[0],"mappings":";;;;CAAA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CAEjB,SAAS,EAAW,GAAG,GAAS;AAC9B,SAAO,EAAE,IAAI,GAAS,SAAS,GAAG;GAChC,IAAI,IAAM,EAAE,QAAQ,EAAE;AACtB,OAAK,EAAI,QAEF;IACL,IAAI,IAAS,EAAE,OAAO,GAAK,SAAS,GAAK,GAAG;KAC1C,IAAI,IAAO,EAAE,KAAK,EAAE,EAClB,IAAQ,EAAE,KAAK,EAAE,EAAE;AACrB,YAAO;MACL,KAAK,EAAI,MAAO,EAAK,SAAS,EAAM;MACpC,QAAQ,EAAI,SAAS,EAAK;MAC3B;OACA;KAAE,KAAK;KAAG,QAAQ;KAAG,CAAC;AAEzB,WAAO;KACF;KACH,YAAY,EAAO,MAAM,EAAO;KAChC,QAAQ,EAAO;KAChB;SAfD,QAAO,EAAK,MAAG;IAiBjB"}

package/dist/node_modules/dagre/lib/order/build-layer-graph.js

@@ -0,0 +1,32 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_graphlib as t } from "../graphlib.js";
+import { require_lodash as n } from "../lodash.js";
+//#region node_modules/dagre/lib/order/build-layer-graph.js
+var r = /* @__PURE__ */ e(((e, r) => {
+	var i = n(), a = t().Graph;
+	r.exports = o;
+	function o(e, t, n) {
+		var r = s(e), o = new a({ compound: !0 }).setGraph({ root: r }).setDefaultNodeLabel(function(t) {
+			return e.node(t);
+		});
+		return i.forEach(e.nodes(), function(a) {
+			var s = e.node(a), c = e.parent(a);
+			(s.rank === t || s.minRank <= t && t <= s.maxRank) && (o.setNode(a), o.setParent(a, c || r), i.forEach(e[n](a), function(t) {
+				var n = t.v === a ? t.w : t.v, r = o.edge(n, a), s = i.isUndefined(r) ? 0 : r.weight;
+				o.setEdge(n, a, { weight: e.edge(t).weight + s });
+			}), i.has(s, "minRank") && o.setNode(a, {
+				borderLeft: s.borderLeft[t],
+				borderRight: s.borderRight[t]
+			}));
+		}), o;
+	}
+	function s(e) {
+		for (var t; e.hasNode(t = i.uniqueId("_root")););
+		return t;
+	}
+}));
+//#endregion
+export default r();
+export { r as require_build_layer_graph };
+
+//# sourceMappingURL=build-layer-graph.js.map

package/dist/node_modules/dagre/lib/order/build-layer-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-layer-graph.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/build-layer-graph.js"],"sourcesContent":["var _ = require(\"../lodash\");\nvar Graph = require(\"../graphlib\").Graph;\n\nmodule.exports = buildLayerGraph;\n\n/*\n * Constructs a graph that can be used to sort a layer of nodes. The graph will\n * contain all base and subgraph nodes from the request layer in their original\n * hierarchy and any edges that are incident on these nodes and are of the type\n * requested by the \"relationship\" parameter.\n *\n * Nodes from the requested rank that do not have parents are assigned a root\n * node in the output graph, which is set in the root graph attribute. This\n * makes it easy to walk the hierarchy of movable nodes during ordering.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG\n *    2. Base nodes in the input graph have a rank attribute\n *    3. Subgraph nodes in the input graph has minRank and maxRank attributes\n *    4. Edges have an assigned weight\n *\n * Post-conditions:\n *\n *    1. Output graph has all nodes in the movable rank with preserved\n *       hierarchy.\n *    2. Root nodes in the movable layer are made children of the node\n *       indicated by the root attribute of the graph.\n *    3. Non-movable nodes incident on movable nodes, selected by the\n *       relationship parameter, are included in the graph (without hierarchy).\n *    4. Edges incident on movable nodes, selected by the relationship\n *       parameter, are added to the output graph.\n *    5. The weights for copied edges are aggregated as need, since the output\n *       graph is not a multi-graph.\n */\nfunction buildLayerGraph(g, rank, relationship) {\n  var root = createRootNode(g),\n    result = new Graph({ compound: true }).setGraph({ root: root })\n      .setDefaultNodeLabel(function(v) { return g.node(v); });\n\n  _.forEach(g.nodes(), function(v) {\n    var node = g.node(v),\n      parent = g.parent(v);\n\n    if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {\n      result.setNode(v);\n      result.setParent(v, parent || root);\n\n      // This assumes we have only short edges!\n      _.forEach(g[relationship](v), function(e) {\n        var u = e.v === v ? e.w : e.v,\n          edge = result.edge(u, v),\n          weight = !_.isUndefined(edge) ? edge.weight : 0;\n        result.setEdge(u, v, { weight: g.edge(e).weight + weight });\n      });\n\n      if (_.has(node, \"minRank\")) {\n        result.setNode(v, {\n          borderLeft: node.borderLeft[rank],\n          borderRight: node.borderRight[rank]\n        });\n      }\n    }\n  });\n\n  return result;\n}\n\nfunction createRootNode(g) {\n  var v;\n  while (g.hasNode((v = _.uniqueId(\"_root\"))));\n  return v;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;CAAA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA,CAA+B;AAEnC,GAAO,UAAU;CAgCjB,SAAS,EAAgB,GAAG,GAAM,GAAc;EAC9C,IAAI,IAAO,EAAe,EAAE,EAC1B,IAAS,IAAI,EAAM,EAAE,UAAU,IAAM,CAAC,CAAC,SAAS,EAAQ,SAAM,CAAC,CAC5D,oBAAoB,SAAS,GAAG;AAAE,UAAO,EAAE,KAAK,EAAE;IAAI;AA2B3D,SAzBA,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,GAAG;GAC/B,IAAI,IAAO,EAAE,KAAK,EAAE,EAClB,IAAS,EAAE,OAAO,EAAE;AAEtB,IAAI,EAAK,SAAS,KAAQ,EAAK,WAAW,KAAQ,KAAQ,EAAK,aAC7D,EAAO,QAAQ,EAAE,EACjB,EAAO,UAAU,GAAG,KAAU,EAAK,EAGnC,EAAE,QAAQ,EAAE,GAAc,EAAE,EAAE,SAAS,GAAG;IACxC,IAAI,IAAI,EAAE,MAAM,IAAI,EAAE,IAAI,EAAE,GAC1B,IAAO,EAAO,KAAK,GAAG,EAAE,EACxB,IAAU,EAAE,YAAY,EAAK,GAAiB,IAAd,EAAK;AACvC,MAAO,QAAQ,GAAG,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,SAAS,GAAQ,CAAC;KAC3D,EAEE,EAAE,IAAI,GAAM,UAAU,IACxB,EAAO,QAAQ,GAAG;IAChB,YAAY,EAAK,WAAW;IAC5B,aAAa,EAAK,YAAY;IAC/B,CAAC;IAGN,EAEK;;CAGT,SAAS,EAAe,GAAG;AAEzB,OADA,IAAI,GACG,EAAE,QAAS,IAAI,EAAE,SAAS,QAAQ,CAAE;AAC3C,SAAO"}

package/dist/node_modules/dagre/lib/order/cross-count.js

@@ -0,0 +1,39 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/order/cross-count.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e, t) {
+		for (var n = 0, r = 1; r < t.length; ++r) n += a(e, t[r - 1], t[r]);
+		return n;
+	}
+	function a(e, t, n) {
+		for (var i = r.zipObject(n, r.map(n, function(e, t) {
+			return t;
+		})), a = r.flatten(r.map(t, function(t) {
+			return r.sortBy(r.map(e.outEdges(t), function(t) {
+				return {
+					pos: i[t.w],
+					weight: e.edge(t).weight
+				};
+			}), "pos");
+		}), !0), o = 1; o < n.length;) o <<= 1;
+		var s = 2 * o - 1;
+		--o;
+		var c = r.map(Array(s), function() {
+			return 0;
+		}), l = 0;
+		return r.forEach(a.forEach(function(e) {
+			var t = e.pos + o;
+			c[t] += e.weight;
+			for (var n = 0; t > 0;) t % 2 && (n += c[t + 1]), t = t - 1 >> 1, c[t] += e.weight;
+			l += e.weight * n;
+		})), l;
+	}
+}));
+//#endregion
+export default n();
+export { n as require_cross_count };
+
+//# sourceMappingURL=cross-count.js.map

package/dist/node_modules/dagre/lib/order/cross-count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-count.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/cross-count.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\n\nmodule.exports = crossCount;\n\n/*\n * A function that takes a layering (an array of layers, each with an array of\n * ordererd nodes) and a graph and returns a weighted crossing count.\n *\n * Pre-conditions:\n *\n *    1. Input graph must be simple (not a multigraph), directed, and include\n *       only simple edges.\n *    2. Edges in the input graph must have assigned weights.\n *\n * Post-conditions:\n *\n *    1. The graph and layering matrix are left unchanged.\n *\n * This algorithm is derived from Barth, et al., \"Bilayer Cross Counting.\"\n */\nfunction crossCount(g, layering) {\n  var cc = 0;\n  for (var i = 1; i < layering.length; ++i) {\n    cc += twoLayerCrossCount(g, layering[i-1], layering[i]);\n  }\n  return cc;\n}\n\nfunction twoLayerCrossCount(g, northLayer, southLayer) {\n  // Sort all of the edges between the north and south layers by their position\n  // in the north layer and then the south. Map these edges to the position of\n  // their head in the south layer.\n  var southPos = _.zipObject(southLayer,\n    _.map(southLayer, function (v, i) { return i; }));\n  var southEntries = _.flatten(_.map(northLayer, function(v) {\n    return _.sortBy(_.map(g.outEdges(v), function(e) {\n      return { pos: southPos[e.w], weight: g.edge(e).weight };\n    }), \"pos\");\n  }), true);\n\n  // Build the accumulator tree\n  var firstIndex = 1;\n  while (firstIndex < southLayer.length) firstIndex <<= 1;\n  var treeSize = 2 * firstIndex - 1;\n  firstIndex -= 1;\n  var tree = _.map(new Array(treeSize), function() { return 0; });\n\n  // Calculate the weighted crossings\n  var cc = 0;\n  _.forEach(southEntries.forEach(function(entry) {\n    var index = entry.pos + firstIndex;\n    tree[index] += entry.weight;\n    var weightSum = 0;\n    while (index > 0) {\n      if (index % 2) {\n        weightSum += tree[index + 1];\n      }\n      index = (index - 1) >> 1;\n      tree[index] += entry.weight;\n    }\n    cc += entry.weight * weightSum;\n  }));\n\n  return cc;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAEA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CAkBjB,SAAS,EAAW,GAAG,GAAU;AAE/B,OAAK,IADD,IAAK,GACA,IAAI,GAAG,IAAI,EAAS,QAAQ,EAAE,EACrC,MAAM,EAAmB,GAAG,EAAS,IAAE,IAAI,EAAS,GAAG;AAEzD,SAAO;;CAGT,SAAS,EAAmB,GAAG,GAAY,GAAY;AAcrD,OAVA,IAAI,IAAW,EAAE,UAAU,GACzB,EAAE,IAAI,GAAY,SAAU,GAAG,GAAG;AAAE,UAAO;IAAK,CAAC,EAC/C,IAAe,EAAE,QAAQ,EAAE,IAAI,GAAY,SAAS,GAAG;AACzD,UAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG;AAC/C,WAAO;KAAE,KAAK,EAAS,EAAE;KAAI,QAAQ,EAAE,KAAK,EAAE,CAAC;KAAQ;KACvD,EAAE,MAAM;IACV,EAAE,GAAK,EAGL,IAAa,GACV,IAAa,EAAW,QAAQ,OAAe;EACtD,IAAI,IAAW,IAAI,IAAa;AAChC;EACA,IAAI,IAAO,EAAE,IAAQ,MAAM,EAAS,EAAE,WAAW;AAAE,UAAO;IAAK,EAG3D,IAAK;AAeT,SAdA,EAAE,QAAQ,EAAa,QAAQ,SAAS,GAAO;GAC7C,IAAI,IAAQ,EAAM,MAAM;AACxB,KAAK,MAAU,EAAM;AAErB,QADA,IAAI,IAAY,GACT,IAAQ,GAKb,CAJI,IAAQ,MACV,KAAa,EAAK,IAAQ,KAE5B,IAAS,IAAQ,KAAM,GACvB,EAAK,MAAU,EAAM;AAEvB,QAAM,EAAM,SAAS;IACrB,CAAC,EAEI"}

package/dist/node_modules/dagre/lib/order/index.js

@@ -0,0 +1,50 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_graphlib as t } from "../graphlib.js";
+import { require_lodash as n } from "../lodash.js";
+import { require_util as r } from "../util.js";
+import { require_init_order as i } from "./init-order.js";
+import { require_cross_count as a } from "./cross-count.js";
+import { require_sort_subgraph as o } from "./sort-subgraph.js";
+import { require_build_layer_graph as s } from "./build-layer-graph.js";
+import { require_add_subgraph_constraints as c } from "./add-subgraph-constraints.js";
+//#region node_modules/dagre/lib/order/index.js
+var l = /* @__PURE__ */ e(((e, l) => {
+	var u = n(), d = i(), f = a(), p = o(), m = s(), h = c(), g = t().Graph, _ = r();
+	l.exports = v;
+	function v(e) {
+		var t = _.maxRank(e), n = y(e, u.range(1, t + 1), "inEdges"), r = y(e, u.range(t - 1, -1, -1), "outEdges"), i = d(e);
+		x(e, i);
+		for (var a = Infinity, o, s = 0, c = 0; c < 4; ++s, ++c) {
+			b(s % 2 ? n : r, s % 4 >= 2), i = _.buildLayerMatrix(e);
+			var l = f(e, i);
+			l < a && (c = 0, o = u.cloneDeep(i), a = l);
+		}
+		x(e, o);
+	}
+	function y(e, t, n) {
+		return u.map(t, function(t) {
+			return m(e, t, n);
+		});
+	}
+	function b(e, t) {
+		var n = new g();
+		u.forEach(e, function(e) {
+			var r = e.graph().root, i = p(e, r, n, t);
+			u.forEach(i.vs, function(t, n) {
+				e.node(t).order = n;
+			}), h(e, n, i.vs);
+		});
+	}
+	function x(e, t) {
+		u.forEach(t, function(t) {
+			u.forEach(t, function(t, n) {
+				e.node(t).order = n;
+			});
+		});
+	}
+}));
+//#endregion
+export default l();
+export { l as require_order };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/dagre/lib/order/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/index.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar initOrder = require(\"./init-order\");\nvar crossCount = require(\"./cross-count\");\nvar sortSubgraph = require(\"./sort-subgraph\");\nvar buildLayerGraph = require(\"./build-layer-graph\");\nvar addSubgraphConstraints = require(\"./add-subgraph-constraints\");\nvar Graph = require(\"../graphlib\").Graph;\nvar util = require(\"../util\");\n\nmodule.exports = order;\n\n/*\n * Applies heuristics to minimize edge crossings in the graph and sets the best\n * order solution as an order attribute on each node.\n *\n * Pre-conditions:\n *\n *    1. Graph must be DAG\n *    2. Graph nodes must be objects with a \"rank\" attribute\n *    3. Graph edges must have the \"weight\" attribute\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have an \"order\" attribute based on the results of the\n *       algorithm.\n */\nfunction order(g) {\n  var maxRank = util.maxRank(g),\n    downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank + 1), \"inEdges\"),\n    upLayerGraphs = buildLayerGraphs(g, _.range(maxRank - 1, -1, -1), \"outEdges\");\n\n  var layering = initOrder(g);\n  assignOrder(g, layering);\n\n  var bestCC = Number.POSITIVE_INFINITY,\n    best;\n\n  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {\n    sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);\n\n    layering = util.buildLayerMatrix(g);\n    var cc = crossCount(g, layering);\n    if (cc < bestCC) {\n      lastBest = 0;\n      best = _.cloneDeep(layering);\n      bestCC = cc;\n    }\n  }\n\n  assignOrder(g, best);\n}\n\nfunction buildLayerGraphs(g, ranks, relationship) {\n  return _.map(ranks, function(rank) {\n    return buildLayerGraph(g, rank, relationship);\n  });\n}\n\nfunction sweepLayerGraphs(layerGraphs, biasRight) {\n  var cg = new Graph();\n  _.forEach(layerGraphs, function(lg) {\n    var root = lg.graph().root;\n    var sorted = sortSubgraph(lg, root, cg, biasRight);\n    _.forEach(sorted.vs, function(v, i) {\n      lg.node(v).order = i;\n    });\n    addSubgraphConstraints(lg, cg, sorted.vs);\n  });\n}\n\nfunction assignOrder(g, layering) {\n  _.forEach(layering, function(layer) {\n    _.forEach(layer, function(v, i) {\n      g.node(v).order = i;\n    });\n  });\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;CAEA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,CAA+B,OAC/B,IAAA,GAAA;AAEJ,GAAO,UAAU;CAiBjB,SAAS,EAAM,GAAG;EAChB,IAAI,IAAU,EAAK,QAAQ,EAAE,EAC3B,IAAkB,EAAiB,GAAG,EAAE,MAAM,GAAG,IAAU,EAAE,EAAE,UAAU,EACzE,IAAgB,EAAiB,GAAG,EAAE,MAAM,IAAU,GAAG,IAAI,GAAG,EAAE,WAAW,EAE3E,IAAW,EAAU,EAAE;AAC3B,IAAY,GAAG,EAAS;AAKxB,OAAK,IAHD,IAAS,UACX,GAEO,IAAI,GAAG,IAAW,GAAG,IAAW,GAAG,EAAE,GAAG,EAAE,GAAU;AAG3D,GAFA,EAAiB,IAAI,IAAI,IAAkB,GAAe,IAAI,KAAK,EAAE,EAErE,IAAW,EAAK,iBAAiB,EAAE;GACnC,IAAI,IAAK,EAAW,GAAG,EAAS;AAChC,GAAI,IAAK,MACP,IAAW,GACX,IAAO,EAAE,UAAU,EAAS,EAC5B,IAAS;;AAIb,IAAY,GAAG,EAAK;;CAGtB,SAAS,EAAiB,GAAG,GAAO,GAAc;AAChD,SAAO,EAAE,IAAI,GAAO,SAAS,GAAM;AACjC,UAAO,EAAgB,GAAG,GAAM,EAAa;IAC7C;;CAGJ,SAAS,EAAiB,GAAa,GAAW;EAChD,IAAI,IAAK,IAAI,GAAO;AACpB,IAAE,QAAQ,GAAa,SAAS,GAAI;GAClC,IAAI,IAAO,EAAG,OAAO,CAAC,MAClB,IAAS,EAAa,GAAI,GAAM,GAAI,EAAU;AAIlD,GAHA,EAAE,QAAQ,EAAO,IAAI,SAAS,GAAG,GAAG;AAClC,MAAG,KAAK,EAAE,CAAC,QAAQ;KACnB,EACF,EAAuB,GAAI,GAAI,EAAO,GAAG;IACzC;;CAGJ,SAAS,EAAY,GAAG,GAAU;AAChC,IAAE,QAAQ,GAAU,SAAS,GAAO;AAClC,KAAE,QAAQ,GAAO,SAAS,GAAG,GAAG;AAC9B,MAAE,KAAK,EAAE,CAAC,QAAQ;KAClB;IACF"}

package/dist/node_modules/dagre/lib/order/init-order.js

@@ -0,0 +1,28 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/order/init-order.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e) {
+		var t = {}, n = r.filter(e.nodes(), function(t) {
+			return !e.children(t).length;
+		}), i = r.max(r.map(n, function(t) {
+			return e.node(t).rank;
+		})), a = r.map(r.range(i + 1), function() {
+			return [];
+		});
+		function o(n) {
+			r.has(t, n) || (t[n] = !0, a[e.node(n).rank].push(n), r.forEach(e.successors(n), o));
+		}
+		var s = r.sortBy(n, function(t) {
+			return e.node(t).rank;
+		});
+		return r.forEach(s, o), a;
+	}
+}));
+//#endregion
+export default n();
+export { n as require_init_order };
+
+//# sourceMappingURL=init-order.js.map

package/dist/node_modules/dagre/lib/order/init-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-order.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/init-order.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\n\nmodule.exports = initOrder;\n\n/*\n * Assigns an initial order value for each node by performing a DFS search\n * starting from nodes in the first rank. Nodes are assigned an order in their\n * rank as they are first visited.\n *\n * This approach comes from Gansner, et al., \"A Technique for Drawing Directed\n * Graphs.\"\n *\n * Returns a layering matrix with an array per layer and each layer sorted by\n * the order of its nodes.\n */\nfunction initOrder(g) {\n  var visited = {};\n  var simpleNodes = _.filter(g.nodes(), function(v) {\n    return !g.children(v).length;\n  });\n  var maxRank = _.max(_.map(simpleNodes, function(v) { return g.node(v).rank; }));\n  var layers = _.map(_.range(maxRank + 1), function() { return []; });\n\n  function dfs(v) {\n    if (_.has(visited, v)) return;\n    visited[v] = true;\n    var node = g.node(v);\n    layers[node.rank].push(v);\n    _.forEach(g.successors(v), dfs);\n  }\n\n  var orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v).rank; });\n  _.forEach(orderedVs, dfs);\n\n  return layers;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAEA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CAajB,SAAS,EAAU,GAAG;EACpB,IAAI,IAAU,EAAE,EACZ,IAAc,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,GAAG;AAChD,UAAO,CAAC,EAAE,SAAS,EAAE,CAAC;IACtB,EACE,IAAU,EAAE,IAAI,EAAE,IAAI,GAAa,SAAS,GAAG;AAAE,UAAO,EAAE,KAAK,EAAE,CAAC;IAAQ,CAAC,EAC3E,IAAS,EAAE,IAAI,EAAE,MAAM,IAAU,EAAE,EAAE,WAAW;AAAE,UAAO,EAAE;IAAI;EAEnE,SAAS,EAAI,GAAG;AACV,KAAE,IAAI,GAAS,EAAE,KACrB,EAAQ,KAAK,IAEb,EADW,EAAE,KAAK,EAAE,CACR,MAAM,KAAK,EAAE,EACzB,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,EAAI;;EAGjC,IAAI,IAAY,EAAE,OAAO,GAAa,SAAS,GAAG;AAAE,UAAO,EAAE,KAAK,EAAE,CAAC;IAAQ;AAG7E,SAFA,EAAE,QAAQ,GAAW,EAAI,EAElB"}

package/dist/node_modules/dagre/lib/order/resolve-conflicts.js

@@ -0,0 +1,61 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/order/resolve-conflicts.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e, t) {
+		var n = {};
+		return r.forEach(e, function(e, t) {
+			var i = n[e.v] = {
+				indegree: 0,
+				in: [],
+				out: [],
+				vs: [e.v],
+				i: t
+			};
+			r.isUndefined(e.barycenter) || (i.barycenter = e.barycenter, i.weight = e.weight);
+		}), r.forEach(t.edges(), function(e) {
+			var t = n[e.v], i = n[e.w];
+			!r.isUndefined(t) && !r.isUndefined(i) && (i.indegree++, t.out.push(n[e.w]));
+		}), a(r.filter(n, function(e) {
+			return !e.indegree;
+		}));
+	}
+	function a(e) {
+		var t = [];
+		function n(e) {
+			return function(t) {
+				t.merged || (r.isUndefined(t.barycenter) || r.isUndefined(e.barycenter) || t.barycenter >= e.barycenter) && o(e, t);
+			};
+		}
+		function i(t) {
+			return function(n) {
+				n.in.push(t), --n.indegree === 0 && e.push(n);
+			};
+		}
+		for (; e.length;) {
+			var a = e.pop();
+			t.push(a), r.forEach(a.in.reverse(), n(a)), r.forEach(a.out, i(a));
+		}
+		return r.map(r.filter(t, function(e) {
+			return !e.merged;
+		}), function(e) {
+			return r.pick(e, [
+				"vs",
+				"i",
+				"barycenter",
+				"weight"
+			]);
+		});
+	}
+	function o(e, t) {
+		var n = 0, r = 0;
+		e.weight && (n += e.barycenter * e.weight, r += e.weight), t.weight && (n += t.barycenter * t.weight, r += t.weight), e.vs = t.vs.concat(e.vs), e.barycenter = n / r, e.weight = r, e.i = Math.min(t.i, e.i), t.merged = !0;
+	}
+}));
+//#endregion
+export default n();
+export { n as require_resolve_conflicts };
+
+//# sourceMappingURL=resolve-conflicts.js.map

package/dist/node_modules/dagre/lib/order/resolve-conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-conflicts.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/resolve-conflicts.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\n\nmodule.exports = resolveConflicts;\n\n/*\n * Given a list of entries of the form {v, barycenter, weight} and a\n * constraint graph this function will resolve any conflicts between the\n * constraint graph and the barycenters for the entries. If the barycenters for\n * an entry would violate a constraint in the constraint graph then we coalesce\n * the nodes in the conflict into a new node that respects the contraint and\n * aggregates barycenter and weight information.\n *\n * This implementation is based on the description in Forster, \"A Fast and\n * Simple Hueristic for Constrained Two-Level Crossing Reduction,\" thought it\n * differs in some specific details.\n *\n * Pre-conditions:\n *\n *    1. Each entry has the form {v, barycenter, weight}, or if the node has\n *       no barycenter, then {v}.\n *\n * Returns:\n *\n *    A new list of entries of the form {vs, i, barycenter, weight}. The list\n *    `vs` may either be a singleton or it may be an aggregation of nodes\n *    ordered such that they do not violate constraints from the constraint\n *    graph. The property `i` is the lowest original index of any of the\n *    elements in `vs`.\n */\nfunction resolveConflicts(entries, cg) {\n  var mappedEntries = {};\n  _.forEach(entries, function(entry, i) {\n    var tmp = mappedEntries[entry.v] = {\n      indegree: 0,\n      \"in\": [],\n      out: [],\n      vs: [entry.v],\n      i: i\n    };\n    if (!_.isUndefined(entry.barycenter)) {\n      tmp.barycenter = entry.barycenter;\n      tmp.weight = entry.weight;\n    }\n  });\n\n  _.forEach(cg.edges(), function(e) {\n    var entryV = mappedEntries[e.v];\n    var entryW = mappedEntries[e.w];\n    if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {\n      entryW.indegree++;\n      entryV.out.push(mappedEntries[e.w]);\n    }\n  });\n\n  var sourceSet = _.filter(mappedEntries, function(entry) {\n    return !entry.indegree;\n  });\n\n  return doResolveConflicts(sourceSet);\n}\n\nfunction doResolveConflicts(sourceSet) {\n  var entries = [];\n\n  function handleIn(vEntry) {\n    return function(uEntry) {\n      if (uEntry.merged) {\n        return;\n      }\n      if (_.isUndefined(uEntry.barycenter) ||\n          _.isUndefined(vEntry.barycenter) ||\n          uEntry.barycenter >= vEntry.barycenter) {\n        mergeEntries(vEntry, uEntry);\n      }\n    };\n  }\n\n  function handleOut(vEntry) {\n    return function(wEntry) {\n      wEntry[\"in\"].push(vEntry);\n      if (--wEntry.indegree === 0) {\n        sourceSet.push(wEntry);\n      }\n    };\n  }\n\n  while (sourceSet.length) {\n    var entry = sourceSet.pop();\n    entries.push(entry);\n    _.forEach(entry[\"in\"].reverse(), handleIn(entry));\n    _.forEach(entry.out, handleOut(entry));\n  }\n\n  return _.map(_.filter(entries, function(entry) { return !entry.merged; }),\n    function(entry) {\n      return _.pick(entry, [\"vs\", \"i\", \"barycenter\", \"weight\"]);\n    });\n\n}\n\nfunction mergeEntries(target, source) {\n  var sum = 0;\n  var weight = 0;\n\n  if (target.weight) {\n    sum += target.barycenter * target.weight;\n    weight += target.weight;\n  }\n\n  if (source.weight) {\n    sum += source.barycenter * source.weight;\n    weight += source.weight;\n  }\n\n  target.vs = source.vs.concat(target.vs);\n  target.barycenter = sum / weight;\n  target.weight = weight;\n  target.i = Math.min(source.i, target.i);\n  source.merged = true;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAEA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CA2BjB,SAAS,EAAiB,GAAS,GAAI;EACrC,IAAI,IAAgB,EAAE;AA4BtB,SA3BA,EAAE,QAAQ,GAAS,SAAS,GAAO,GAAG;GACpC,IAAI,IAAM,EAAc,EAAM,KAAK;IACjC,UAAU;IACV,IAAM,EAAE;IACR,KAAK,EAAE;IACP,IAAI,CAAC,EAAM,EAAE;IACV;IACJ;AACD,GAAK,EAAE,YAAY,EAAM,WAAW,KAClC,EAAI,aAAa,EAAM,YACvB,EAAI,SAAS,EAAM;IAErB,EAEF,EAAE,QAAQ,EAAG,OAAO,EAAE,SAAS,GAAG;GAChC,IAAI,IAAS,EAAc,EAAE,IACzB,IAAS,EAAc,EAAE;AAC7B,GAAI,CAAC,EAAE,YAAY,EAAO,IAAI,CAAC,EAAE,YAAY,EAAO,KAClD,EAAO,YACP,EAAO,IAAI,KAAK,EAAc,EAAE,GAAG;IAErC,EAMK,EAJS,EAAE,OAAO,GAAe,SAAS,GAAO;AACtD,UAAO,CAAC,EAAM;IACd,CAEkC;;CAGtC,SAAS,EAAmB,GAAW;EACrC,IAAI,IAAU,EAAE;EAEhB,SAAS,EAAS,GAAQ;AACxB,UAAO,SAAS,GAAQ;AAClB,MAAO,WAGP,EAAE,YAAY,EAAO,WAAW,IAChC,EAAE,YAAY,EAAO,WAAW,IAChC,EAAO,cAAc,EAAO,eAC9B,EAAa,GAAQ,EAAO;;;EAKlC,SAAS,EAAU,GAAQ;AACzB,UAAO,SAAS,GAAQ;AAEtB,IADA,EAAO,GAAM,KAAK,EAAO,EACrB,EAAE,EAAO,aAAa,KACxB,EAAU,KAAK,EAAO;;;AAK5B,SAAO,EAAU,SAAQ;GACvB,IAAI,IAAQ,EAAU,KAAK;AAG3B,GAFA,EAAQ,KAAK,EAAM,EACnB,EAAE,QAAQ,EAAM,GAAM,SAAS,EAAE,EAAS,EAAM,CAAC,EACjD,EAAE,QAAQ,EAAM,KAAK,EAAU,EAAM,CAAC;;AAGxC,SAAO,EAAE,IAAI,EAAE,OAAO,GAAS,SAAS,GAAO;AAAE,UAAO,CAAC,EAAM;IAAU,EACvE,SAAS,GAAO;AACd,UAAO,EAAE,KAAK,GAAO;IAAC;IAAM;IAAK;IAAc;IAAS,CAAC;IACzD;;CAIN,SAAS,EAAa,GAAQ,GAAQ;EACpC,IAAI,IAAM,GACN,IAAS;AAgBb,EAdI,EAAO,WACT,KAAO,EAAO,aAAa,EAAO,QAClC,KAAU,EAAO,SAGf,EAAO,WACT,KAAO,EAAO,aAAa,EAAO,QAClC,KAAU,EAAO,SAGnB,EAAO,KAAK,EAAO,GAAG,OAAO,EAAO,GAAG,EACvC,EAAO,aAAa,IAAM,GAC1B,EAAO,SAAS,GAChB,EAAO,IAAI,KAAK,IAAI,EAAO,GAAG,EAAO,EAAE,EACvC,EAAO,SAAS"}

package/dist/node_modules/dagre/lib/order/sort-subgraph.js

@@ -0,0 +1,50 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+import { require_barycenter as n } from "./barycenter.js";
+import { require_resolve_conflicts as r } from "./resolve-conflicts.js";
+import { require_sort as i } from "./sort.js";
+//#region node_modules/dagre/lib/order/sort-subgraph.js
+var a = /* @__PURE__ */ e(((e, a) => {
+	var o = t(), s = n(), c = r(), l = i();
+	a.exports = u;
+	function u(e, t, n, r) {
+		var i = e.children(t), a = e.node(t), p = a ? a.borderLeft : void 0, m = a ? a.borderRight : void 0, h = {};
+		p && (i = o.filter(i, function(e) {
+			return e !== p && e !== m;
+		}));
+		var g = s(e, i);
+		o.forEach(g, function(t) {
+			if (e.children(t.v).length) {
+				var i = u(e, t.v, n, r);
+				h[t.v] = i, o.has(i, "barycenter") && f(t, i);
+			}
+		});
+		var _ = c(g, n);
+		d(_, h);
+		var v = l(_, r);
+		if (p && (v.vs = o.flatten([
+			p,
+			v.vs,
+			m
+		], !0), e.predecessors(p).length)) {
+			var y = e.node(e.predecessors(p)[0]), b = e.node(e.predecessors(m)[0]);
+			o.has(v, "barycenter") || (v.barycenter = 0, v.weight = 0), v.barycenter = (v.barycenter * v.weight + y.order + b.order) / (v.weight + 2), v.weight += 2;
+		}
+		return v;
+	}
+	function d(e, t) {
+		o.forEach(e, function(e) {
+			e.vs = o.flatten(e.vs.map(function(e) {
+				return t[e] ? t[e].vs : e;
+			}), !0);
+		});
+	}
+	function f(e, t) {
+		o.isUndefined(e.barycenter) ? (e.barycenter = t.barycenter, e.weight = t.weight) : (e.barycenter = (e.barycenter * e.weight + t.barycenter * t.weight) / (e.weight + t.weight), e.weight += t.weight);
+	}
+}));
+//#endregion
+export default a();
+export { a as require_sort_subgraph };
+
+//# sourceMappingURL=sort-subgraph.js.map

package/dist/node_modules/dagre/lib/order/sort-subgraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-subgraph.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/sort-subgraph.js"],"sourcesContent":["var _ = require(\"../lodash\");\nvar barycenter = require(\"./barycenter\");\nvar resolveConflicts = require(\"./resolve-conflicts\");\nvar sort = require(\"./sort\");\n\nmodule.exports = sortSubgraph;\n\nfunction sortSubgraph(g, v, cg, biasRight) {\n  var movable = g.children(v);\n  var node = g.node(v);\n  var bl = node ? node.borderLeft : undefined;\n  var br = node ? node.borderRight: undefined;\n  var subgraphs = {};\n\n  if (bl) {\n    movable = _.filter(movable, function(w) {\n      return w !== bl && w !== br;\n    });\n  }\n\n  var barycenters = barycenter(g, movable);\n  _.forEach(barycenters, function(entry) {\n    if (g.children(entry.v).length) {\n      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);\n      subgraphs[entry.v] = subgraphResult;\n      if (_.has(subgraphResult, \"barycenter\")) {\n        mergeBarycenters(entry, subgraphResult);\n      }\n    }\n  });\n\n  var entries = resolveConflicts(barycenters, cg);\n  expandSubgraphs(entries, subgraphs);\n\n  var result = sort(entries, biasRight);\n\n  if (bl) {\n    result.vs = _.flatten([bl, result.vs, br], true);\n    if (g.predecessors(bl).length) {\n      var blPred = g.node(g.predecessors(bl)[0]),\n        brPred = g.node(g.predecessors(br)[0]);\n      if (!_.has(result, \"barycenter\")) {\n        result.barycenter = 0;\n        result.weight = 0;\n      }\n      result.barycenter = (result.barycenter * result.weight +\n                           blPred.order + brPred.order) / (result.weight + 2);\n      result.weight += 2;\n    }\n  }\n\n  return result;\n}\n\nfunction expandSubgraphs(entries, subgraphs) {\n  _.forEach(entries, function(entry) {\n    entry.vs = _.flatten(entry.vs.map(function(v) {\n      if (subgraphs[v]) {\n        return subgraphs[v].vs;\n      }\n      return v;\n    }), true);\n  });\n}\n\nfunction mergeBarycenters(target, other) {\n  if (!_.isUndefined(target.barycenter)) {\n    target.barycenter = (target.barycenter * target.weight +\n                         other.barycenter * other.weight) /\n                        (target.weight + other.weight);\n    target.weight += other.weight;\n  } else {\n    target.barycenter = other.barycenter;\n    target.weight = other.weight;\n  }\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;CAAA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA;AAEJ,GAAO,UAAU;CAEjB,SAAS,EAAa,GAAG,GAAG,GAAI,GAAW;EACzC,IAAI,IAAU,EAAE,SAAS,EAAE,EACvB,IAAO,EAAE,KAAK,EAAE,EAChB,IAAK,IAAO,EAAK,aAAa,KAAA,GAC9B,IAAK,IAAO,EAAK,cAAa,KAAA,GAC9B,IAAY,EAAE;AAElB,EAAI,MACF,IAAU,EAAE,OAAO,GAAS,SAAS,GAAG;AACtC,UAAO,MAAM,KAAM,MAAM;IACzB;EAGJ,IAAI,IAAc,EAAW,GAAG,EAAQ;AACxC,IAAE,QAAQ,GAAa,SAAS,GAAO;AACrC,OAAI,EAAE,SAAS,EAAM,EAAE,CAAC,QAAQ;IAC9B,IAAI,IAAiB,EAAa,GAAG,EAAM,GAAG,GAAI,EAAU;AAE5D,IADA,EAAU,EAAM,KAAK,GACjB,EAAE,IAAI,GAAgB,aAAa,IACrC,EAAiB,GAAO,EAAe;;IAG3C;EAEF,IAAI,IAAU,EAAiB,GAAa,EAAG;AAC/C,IAAgB,GAAS,EAAU;EAEnC,IAAI,IAAS,EAAK,GAAS,EAAU;AAErC,MAAI,MACF,EAAO,KAAK,EAAE,QAAQ;GAAC;GAAI,EAAO;GAAI;GAAG,EAAE,GAAK,EAC5C,EAAE,aAAa,EAAG,CAAC,SAAQ;GAC7B,IAAI,IAAS,EAAE,KAAK,EAAE,aAAa,EAAG,CAAC,GAAG,EACxC,IAAS,EAAE,KAAK,EAAE,aAAa,EAAG,CAAC,GAAG;AAOxC,GANK,EAAE,IAAI,GAAQ,aAAa,KAC9B,EAAO,aAAa,GACpB,EAAO,SAAS,IAElB,EAAO,cAAc,EAAO,aAAa,EAAO,SAC3B,EAAO,QAAQ,EAAO,UAAU,EAAO,SAAS,IACrE,EAAO,UAAU;;AAIrB,SAAO;;CAGT,SAAS,EAAgB,GAAS,GAAW;AAC3C,IAAE,QAAQ,GAAS,SAAS,GAAO;AACjC,KAAM,KAAK,EAAE,QAAQ,EAAM,GAAG,IAAI,SAAS,GAAG;AAI5C,WAHI,EAAU,KACL,EAAU,GAAG,KAEf;KACP,EAAE,GAAK;IACT;;CAGJ,SAAS,EAAiB,GAAQ,GAAO;AACvC,EAAK,EAAE,YAAY,EAAO,WAAW,IAMnC,EAAO,aAAa,EAAM,YAC1B,EAAO,SAAS,EAAM,WANtB,EAAO,cAAc,EAAO,aAAa,EAAO,SAC3B,EAAM,aAAa,EAAM,WACzB,EAAO,SAAS,EAAM,SAC3C,EAAO,UAAU,EAAM"}