@burdenoff/microfe-vibecontrols 2026.601.12 → 2026.601.13

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"}

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

@@ -0,0 +1,34 @@
+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/order/sort.js
+var r = /* @__PURE__ */ e(((e, r) => {
+	var i = t(), a = n();
+	r.exports = o;
+	function o(e, t) {
+		var n = a.partition(e, function(e) {
+			return i.has(e, "barycenter");
+		}), r = n.lhs, o = i.sortBy(n.rhs, function(e) {
+			return -e.i;
+		}), l = [], u = 0, d = 0, f = 0;
+		r.sort(c(!!t)), f = s(l, o, f), i.forEach(r, function(e) {
+			f += e.vs.length, l.push(e.vs), u += e.barycenter * e.weight, d += e.weight, f = s(l, o, f);
+		});
+		var p = { vs: i.flatten(l, !0) };
+		return d && (p.barycenter = u / d, p.weight = d), p;
+	}
+	function s(e, t, n) {
+		for (var r; t.length && (r = i.last(t)).i <= n;) t.pop(), e.push(r.vs), n++;
+		return n;
+	}
+	function c(e) {
+		return function(t, n) {
+			return t.barycenter < n.barycenter ? -1 : t.barycenter > n.barycenter ? 1 : e ? n.i - t.i : t.i - n.i;
+		};
+	}
+}));
+//#endregion
+export default r();
+export { r as require_sort };
+
+//# sourceMappingURL=sort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","names":[],"sources":["../../../../../node_modules/dagre/lib/order/sort.js"],"sourcesContent":["var _ = require(\"../lodash\");\nvar util = require(\"../util\");\n\nmodule.exports = sort;\n\nfunction sort(entries, biasRight) {\n  var parts = util.partition(entries, function(entry) {\n    return _.has(entry, \"barycenter\");\n  });\n  var sortable = parts.lhs,\n    unsortable = _.sortBy(parts.rhs, function(entry) { return -entry.i; }),\n    vs = [],\n    sum = 0,\n    weight = 0,\n    vsIndex = 0;\n\n  sortable.sort(compareWithBias(!!biasRight));\n\n  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n\n  _.forEach(sortable, function (entry) {\n    vsIndex += entry.vs.length;\n    vs.push(entry.vs);\n    sum += entry.barycenter * entry.weight;\n    weight += entry.weight;\n    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n  });\n\n  var result = { vs: _.flatten(vs, true) };\n  if (weight) {\n    result.barycenter = sum / weight;\n    result.weight = weight;\n  }\n  return result;\n}\n\nfunction consumeUnsortable(vs, unsortable, index) {\n  var last;\n  while (unsortable.length && (last = _.last(unsortable)).i <= index) {\n    unsortable.pop();\n    vs.push(last.vs);\n    index++;\n  }\n  return index;\n}\n\nfunction compareWithBias(bias) {\n  return function(entryV, entryW) {\n    if (entryV.barycenter < entryW.barycenter) {\n      return -1;\n    } else if (entryV.barycenter > entryW.barycenter) {\n      return 1;\n    }\n\n    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;\n  };\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;CAAA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA;AAEJ,GAAO,UAAU;CAEjB,SAAS,EAAK,GAAS,GAAW;EAChC,IAAI,IAAQ,EAAK,UAAU,GAAS,SAAS,GAAO;AAClD,UAAO,EAAE,IAAI,GAAO,aAAa;IACjC,EACE,IAAW,EAAM,KACnB,IAAa,EAAE,OAAO,EAAM,KAAK,SAAS,GAAO;AAAE,UAAO,CAAC,EAAM;IAAK,EACtE,IAAK,EAAE,EACP,IAAM,GACN,IAAS,GACT,IAAU;AAMZ,EAJA,EAAS,KAAK,EAAgB,CAAC,CAAC,EAAU,CAAC,EAE3C,IAAU,EAAkB,GAAI,GAAY,EAAQ,EAEpD,EAAE,QAAQ,GAAU,SAAU,GAAO;AAKnC,GAJA,KAAW,EAAM,GAAG,QACpB,EAAG,KAAK,EAAM,GAAG,EACjB,KAAO,EAAM,aAAa,EAAM,QAChC,KAAU,EAAM,QAChB,IAAU,EAAkB,GAAI,GAAY,EAAQ;IACpD;EAEF,IAAI,IAAS,EAAE,IAAI,EAAE,QAAQ,GAAI,GAAK,EAAE;AAKxC,SAJI,MACF,EAAO,aAAa,IAAM,GAC1B,EAAO,SAAS,IAEX;;CAGT,SAAS,EAAkB,GAAI,GAAY,GAAO;AAEhD,OADA,IAAI,GACG,EAAW,WAAW,IAAO,EAAE,KAAK,EAAW,EAAE,KAAK,GAG3D,CAFA,EAAW,KAAK,EAChB,EAAG,KAAK,EAAK,GAAG,EAChB;AAEF,SAAO;;CAGT,SAAS,EAAgB,GAAM;AAC7B,SAAO,SAAS,GAAQ,GAAQ;AAO9B,UANI,EAAO,aAAa,EAAO,aACtB,KACE,EAAO,aAAa,EAAO,aAC7B,IAGD,IAA6B,EAAO,IAAI,EAAO,IAAxC,EAAO,IAAI,EAAO"}

package/dist/node_modules/dagre/lib/parent-dummy-chains.js

@@ -0,0 +1,50 @@
+import { __commonJSMin as e } from "../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "./lodash.js";
+//#region node_modules/dagre/lib/parent-dummy-chains.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = i;
+	function i(e) {
+		var t = o(e);
+		r.forEach(e.graph().dummyChains, function(n) {
+			for (var r = e.node(n), i = r.edgeObj, o = a(e, t, i.v, i.w), s = o.path, c = o.lca, l = 0, u = s[l], d = !0; n !== i.w;) {
+				if (r = e.node(n), d) {
+					for (; (u = s[l]) !== c && e.node(u).maxRank < r.rank;) l++;
+					u === c && (d = !1);
+				}
+				if (!d) {
+					for (; l < s.length - 1 && e.node(u = s[l + 1]).minRank <= r.rank;) l++;
+					u = s[l];
+				}
+				e.setParent(n, u), n = e.successors(n)[0];
+			}
+		});
+	}
+	function a(e, t, n, r) {
+		var i = [], a = [], o = Math.min(t[n].low, t[r].low), s = Math.max(t[n].lim, t[r].lim), c = n, l;
+		do
+			c = e.parent(c), i.push(c);
+		while (c && (t[c].low > o || s > t[c].lim));
+		for (l = c, c = r; (c = e.parent(c)) !== l;) a.push(c);
+		return {
+			path: i.concat(a.reverse()),
+			lca: l
+		};
+	}
+	function o(e) {
+		var t = {}, n = 0;
+		function i(a) {
+			var o = n;
+			r.forEach(e.children(a), i), t[a] = {
+				low: o,
+				lim: n++
+			};
+		}
+		return r.forEach(e.children(), i), t;
+	}
+}));
+//#endregion
+export default n();
+export { n as require_parent_dummy_chains };
+
+//# sourceMappingURL=parent-dummy-chains.js.map

package/dist/node_modules/dagre/lib/parent-dummy-chains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-dummy-chains.js","names":[],"sources":["../../../../node_modules/dagre/lib/parent-dummy-chains.js"],"sourcesContent":["var _ = require(\"./lodash\");\n\nmodule.exports = parentDummyChains;\n\nfunction parentDummyChains(g) {\n  var postorderNums = postorder(g);\n\n  _.forEach(g.graph().dummyChains, function(v) {\n    var node = g.node(v);\n    var edgeObj = node.edgeObj;\n    var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);\n    var path = pathData.path;\n    var lca = pathData.lca;\n    var pathIdx = 0;\n    var pathV = path[pathIdx];\n    var ascending = true;\n\n    while (v !== edgeObj.w) {\n      node = g.node(v);\n\n      if (ascending) {\n        while ((pathV = path[pathIdx]) !== lca &&\n               g.node(pathV).maxRank < node.rank) {\n          pathIdx++;\n        }\n\n        if (pathV === lca) {\n          ascending = false;\n        }\n      }\n\n      if (!ascending) {\n        while (pathIdx < path.length - 1 &&\n               g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {\n          pathIdx++;\n        }\n        pathV = path[pathIdx];\n      }\n\n      g.setParent(v, pathV);\n      v = g.successors(v)[0];\n    }\n  });\n}\n\n// Find a path from v to w through the lowest common ancestor (LCA). Return the\n// full path and the LCA.\nfunction findPath(g, postorderNums, v, w) {\n  var vPath = [];\n  var wPath = [];\n  var low = Math.min(postorderNums[v].low, postorderNums[w].low);\n  var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);\n  var parent;\n  var lca;\n\n  // Traverse up from v to find the LCA\n  parent = v;\n  do {\n    parent = g.parent(parent);\n    vPath.push(parent);\n  } while (parent &&\n           (postorderNums[parent].low > low || lim > postorderNums[parent].lim));\n  lca = parent;\n\n  // Traverse from w to LCA\n  parent = w;\n  while ((parent = g.parent(parent)) !== lca) {\n    wPath.push(parent);\n  }\n\n  return { path: vPath.concat(wPath.reverse()), lca: lca };\n}\n\nfunction postorder(g) {\n  var result = {};\n  var lim = 0;\n\n  function dfs(v) {\n    var low = lim;\n    _.forEach(g.children(v), dfs);\n    result[v] = { low: low, lim: lim++ };\n  }\n  _.forEach(g.children(), dfs);\n\n  return result;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAAA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;CAEjB,SAAS,EAAkB,GAAG;EAC5B,IAAI,IAAgB,EAAU,EAAE;AAEhC,IAAE,QAAQ,EAAE,OAAO,CAAC,aAAa,SAAS,GAAG;AAU3C,QATA,IAAI,IAAO,EAAE,KAAK,EAAE,EAChB,IAAU,EAAK,SACf,IAAW,EAAS,GAAG,GAAe,EAAQ,GAAG,EAAQ,EAAE,EAC3D,IAAO,EAAS,MAChB,IAAM,EAAS,KACf,IAAU,GACV,IAAQ,EAAK,IACb,IAAY,IAET,MAAM,EAAQ,IAAG;AAGtB,QAFA,IAAO,EAAE,KAAK,EAAE,EAEZ,GAAW;AACb,aAAQ,IAAQ,EAAK,QAAc,KAC5B,EAAE,KAAK,EAAM,CAAC,UAAU,EAAK,MAClC;AAGF,KAAI,MAAU,MACZ,IAAY;;AAIhB,QAAI,CAAC,GAAW;AACd,YAAO,IAAU,EAAK,SAAS,KACxB,EAAE,KAAK,IAAQ,EAAK,IAAU,GAAG,CAAC,WAAW,EAAK,MACvD;AAEF,SAAQ,EAAK;;AAIf,IADA,EAAE,UAAU,GAAG,EAAM,EACrB,IAAI,EAAE,WAAW,EAAE,CAAC;;IAEtB;;CAKJ,SAAS,EAAS,GAAG,GAAe,GAAG,GAAG;EACxC,IAAI,IAAQ,EAAE,EACV,IAAQ,EAAE,EACV,IAAM,KAAK,IAAI,EAAc,GAAG,KAAK,EAAc,GAAG,IAAI,EAC1D,IAAM,KAAK,IAAI,EAAc,GAAG,KAAK,EAAc,GAAG,IAAI,EAC1D,IAIK,GAHL;AAIJ;AAEE,GADA,IAAS,EAAE,OAAO,EAAO,EACzB,EAAM,KAAK,EAAO;SACX,MACC,EAAc,GAAQ,MAAM,KAAO,IAAM,EAAc,GAAQ;AAKzE,OAJA,IAAM,GAGN,IAAS,IACD,IAAS,EAAE,OAAO,EAAO,MAAM,GACrC,GAAM,KAAK,EAAO;AAGpB,SAAO;GAAE,MAAM,EAAM,OAAO,EAAM,SAAS,CAAC;GAAO;GAAK;;CAG1D,SAAS,EAAU,GAAG;EACpB,IAAI,IAAS,EAAE,EACX,IAAM;EAEV,SAAS,EAAI,GAAG;GACd,IAAI,IAAM;AAEV,GADA,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAI,EAC7B,EAAO,KAAK;IAAO;IAAK,KAAK;IAAO;;AAItC,SAFA,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAI,EAErB"}