@burdenoff/microfe-vibecontrols 2026.601.12 → 2026.601.13

package/dist/node_modules/dagre/lib/position/bk.js

@@ -0,0 +1,212 @@
+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";
+//#region node_modules/dagre/lib/position/bk.js
+var i = /* @__PURE__ */ e(((e, i) => {
+	var a = n(), o = t().Graph, s = r();
+	i.exports = {
+		positionX: y,
+		findType1Conflicts: c,
+		findType2Conflicts: l,
+		addConflict: d,
+		hasConflict: f,
+		verticalAlignment: p,
+		horizontalCompaction: m,
+		alignCoordinates: _,
+		findSmallestWidthAlignment: g,
+		balance: v
+	};
+	function c(e, t) {
+		var n = {};
+		function r(t, r) {
+			var i = 0, o = 0, s = t.length, c = a.last(r);
+			return a.forEach(r, function(t, l) {
+				var f = u(e, t), p = f ? e.node(f).order : s;
+				(f || t === c) && (a.forEach(r.slice(o, l + 1), function(t) {
+					a.forEach(e.predecessors(t), function(r) {
+						var a = e.node(r), o = a.order;
+						(o < i || p < o) && !(a.dummy && e.node(t).dummy) && d(n, r, t);
+					});
+				}), o = l + 1, i = p);
+			}), r;
+		}
+		return a.reduce(t, r), n;
+	}
+	function l(e, t) {
+		var n = {};
+		function r(t, r, i, o, s) {
+			var c;
+			a.forEach(a.range(r, i), function(r) {
+				c = t[r], e.node(c).dummy && a.forEach(e.predecessors(c), function(t) {
+					var r = e.node(t);
+					r.dummy && (r.order < o || r.order > s) && d(n, t, c);
+				});
+			});
+		}
+		function i(t, n) {
+			var i = -1, o, s = 0;
+			return a.forEach(n, function(a, c) {
+				if (e.node(a).dummy === "border") {
+					var l = e.predecessors(a);
+					l.length && (o = e.node(l[0]).order, r(n, s, c, i, o), s = c, i = o);
+				}
+				r(n, s, n.length, o, t.length);
+			}), n;
+		}
+		return a.reduce(t, i), n;
+	}
+	function u(e, t) {
+		if (e.node(t).dummy) return a.find(e.predecessors(t), function(t) {
+			return e.node(t).dummy;
+		});
+	}
+	function d(e, t, n) {
+		if (t > n) {
+			var r = t;
+			t = n, n = r;
+		}
+		var i = e[t];
+		i || (e[t] = i = {}), i[n] = !0;
+	}
+	function f(e, t, n) {
+		if (t > n) {
+			var r = t;
+			t = n, n = r;
+		}
+		return a.has(e[t], n);
+	}
+	function p(e, t, n, r) {
+		var i = {}, o = {}, s = {};
+		return a.forEach(t, function(e) {
+			a.forEach(e, function(e, t) {
+				i[e] = e, o[e] = e, s[e] = t;
+			});
+		}), a.forEach(t, function(e) {
+			var t = -1;
+			a.forEach(e, function(e) {
+				var c = r(e);
+				if (c.length) {
+					c = a.sortBy(c, function(e) {
+						return s[e];
+					});
+					for (var l = (c.length - 1) / 2, u = Math.floor(l), d = Math.ceil(l); u <= d; ++u) {
+						var p = c[u];
+						o[e] === e && t < s[p] && !f(n, e, p) && (o[p] = e, o[e] = i[e] = i[p], t = s[p]);
+					}
+				}
+			});
+		}), {
+			root: i,
+			align: o
+		};
+	}
+	function m(e, t, n, r, i) {
+		var o = {}, s = h(e, t, n, i), c = i ? "borderLeft" : "borderRight";
+		function l(e, t) {
+			for (var n = s.nodes(), r = n.pop(), i = {}; r;) i[r] ? e(r) : (i[r] = !0, n.push(r), n = n.concat(t(r))), r = n.pop();
+		}
+		function u(e) {
+			o[e] = s.inEdges(e).reduce(function(e, t) {
+				return Math.max(e, o[t.v] + s.edge(t));
+			}, 0);
+		}
+		function d(t) {
+			var n = s.outEdges(t).reduce(function(e, t) {
+				return Math.min(e, o[t.w] - s.edge(t));
+			}, Infinity), r = e.node(t);
+			n !== Infinity && r.borderType !== c && (o[t] = Math.max(o[t], n));
+		}
+		return l(u, s.predecessors.bind(s)), l(d, s.successors.bind(s)), a.forEach(r, function(e) {
+			o[e] = o[n[e]];
+		}), o;
+	}
+	function h(e, t, n, r) {
+		var i = new o(), s = e.graph(), c = b(s.nodesep, s.edgesep, r);
+		return a.forEach(t, function(t) {
+			var r;
+			a.forEach(t, function(t) {
+				var a = n[t];
+				if (i.setNode(a), r) {
+					var o = n[r], s = i.edge(o, a);
+					i.setEdge(o, a, Math.max(c(e, t, r), s || 0));
+				}
+				r = t;
+			});
+		}), i;
+	}
+	function g(e, t) {
+		return a.minBy(a.values(t), function(t) {
+			var n = -Infinity, r = Infinity;
+			return a.forIn(t, function(t, i) {
+				var a = x(e, i) / 2;
+				n = Math.max(t + a, n), r = Math.min(t - a, r);
+			}), n - r;
+		});
+	}
+	function _(e, t) {
+		var n = a.values(t), r = a.min(n), i = a.max(n);
+		a.forEach(["u", "d"], function(n) {
+			a.forEach(["l", "r"], function(o) {
+				var s = n + o, c = e[s], l;
+				if (c !== t) {
+					var u = a.values(c);
+					l = o === "l" ? r - a.min(u) : i - a.max(u), l && (e[s] = a.mapValues(c, function(e) {
+						return e + l;
+					}));
+				}
+			});
+		});
+	}
+	function v(e, t) {
+		return a.mapValues(e.ul, function(n, r) {
+			if (t) return e[t.toLowerCase()][r];
+			var i = a.sortBy(a.map(e, r));
+			return (i[1] + i[2]) / 2;
+		});
+	}
+	function y(e) {
+		var t = s.buildLayerMatrix(e), n = a.merge(c(e, t), l(e, t)), r = {}, i;
+		return a.forEach(["u", "d"], function(o) {
+			i = o === "u" ? t : a.values(t).reverse(), a.forEach(["l", "r"], function(t) {
+				t === "r" && (i = a.map(i, function(e) {
+					return a.values(e).reverse();
+				}));
+				var s = (o === "u" ? e.predecessors : e.successors).bind(e), c = p(e, i, n, s), l = m(e, i, c.root, c.align, t === "r");
+				t === "r" && (l = a.mapValues(l, function(e) {
+					return -e;
+				})), r[o + t] = l;
+			});
+		}), _(r, g(e, r)), v(r, e.graph().align);
+	}
+	function b(e, t, n) {
+		return function(r, i, o) {
+			var s = r.node(i), c = r.node(o), l = 0, u;
+			if (l += s.width / 2, a.has(s, "labelpos")) switch (s.labelpos.toLowerCase()) {
+				case "l":
+					u = -s.width / 2;
+					break;
+				case "r":
+					u = s.width / 2;
+					break;
+			}
+			if (u && (l += n ? u : -u), u = 0, l += (s.dummy ? t : e) / 2, l += (c.dummy ? t : e) / 2, l += c.width / 2, a.has(c, "labelpos")) switch (c.labelpos.toLowerCase()) {
+				case "l":
+					u = c.width / 2;
+					break;
+				case "r":
+					u = -c.width / 2;
+					break;
+			}
+			return u && (l += n ? u : -u), u = 0, l;
+		};
+	}
+	function x(e, t) {
+		return e.node(t).width;
+	}
+}));
+//#endregion
+export default i();
+export { i as require_bk };
+
+//# sourceMappingURL=bk.js.map

package/dist/node_modules/dagre/lib/position/bk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bk.js","names":[],"sources":["../../../../../node_modules/dagre/lib/position/bk.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar Graph = require(\"../graphlib\").Graph;\nvar util = require(\"../util\");\n\n/*\n * This module provides coordinate assignment based on Brandes and Köpf, \"Fast\n * and Simple Horizontal Coordinate Assignment.\"\n */\n\nmodule.exports = {\n  positionX: positionX,\n  findType1Conflicts: findType1Conflicts,\n  findType2Conflicts: findType2Conflicts,\n  addConflict: addConflict,\n  hasConflict: hasConflict,\n  verticalAlignment: verticalAlignment,\n  horizontalCompaction: horizontalCompaction,\n  alignCoordinates: alignCoordinates,\n  findSmallestWidthAlignment: findSmallestWidthAlignment,\n  balance: balance\n};\n\n/*\n * Marks all edges in the graph with a type-1 conflict with the \"type1Conflict\"\n * property. A type-1 conflict is one where a non-inner segment crosses an\n * inner segment. An inner segment is an edge with both incident nodes marked\n * with the \"dummy\" property.\n *\n * This algorithm scans layer by layer, starting with the second, for type-1\n * conflicts between the current layer and the previous layer. For each layer\n * it scans the nodes from left to right until it reaches one that is incident\n * on an inner segment. It then scans predecessors to determine if they have\n * edges that cross that inner segment. At the end a final scan is done for all\n * nodes on the current rank to see if they cross the last visited inner\n * segment.\n *\n * This algorithm (safely) assumes that a dummy node will only be incident on a\n * single node in the layers being scanned.\n */\nfunction findType1Conflicts(g, layering) {\n  var conflicts = {};\n\n  function visitLayer(prevLayer, layer) {\n    var\n      // last visited node in the previous layer that is incident on an inner\n      // segment.\n      k0 = 0,\n      // Tracks the last node in this layer scanned for crossings with a type-1\n      // segment.\n      scanPos = 0,\n      prevLayerLength = prevLayer.length,\n      lastNode = _.last(layer);\n\n    _.forEach(layer, function(v, i) {\n      var w = findOtherInnerSegmentNode(g, v),\n        k1 = w ? g.node(w).order : prevLayerLength;\n\n      if (w || v === lastNode) {\n        _.forEach(layer.slice(scanPos, i +1), function(scanNode) {\n          _.forEach(g.predecessors(scanNode), function(u) {\n            var uLabel = g.node(u),\n              uPos = uLabel.order;\n            if ((uPos < k0 || k1 < uPos) &&\n                !(uLabel.dummy && g.node(scanNode).dummy)) {\n              addConflict(conflicts, u, scanNode);\n            }\n          });\n        });\n        scanPos = i + 1;\n        k0 = k1;\n      }\n    });\n\n    return layer;\n  }\n\n  _.reduce(layering, visitLayer);\n  return conflicts;\n}\n\nfunction findType2Conflicts(g, layering) {\n  var conflicts = {};\n\n  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {\n    var v;\n    _.forEach(_.range(southPos, southEnd), function(i) {\n      v = south[i];\n      if (g.node(v).dummy) {\n        _.forEach(g.predecessors(v), function(u) {\n          var uNode = g.node(u);\n          if (uNode.dummy &&\n              (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {\n            addConflict(conflicts, u, v);\n          }\n        });\n      }\n    });\n  }\n\n\n  function visitLayer(north, south) {\n    var prevNorthPos = -1,\n      nextNorthPos,\n      southPos = 0;\n\n    _.forEach(south, function(v, southLookahead) {\n      if (g.node(v).dummy === \"border\") {\n        var predecessors = g.predecessors(v);\n        if (predecessors.length) {\n          nextNorthPos = g.node(predecessors[0]).order;\n          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);\n          southPos = southLookahead;\n          prevNorthPos = nextNorthPos;\n        }\n      }\n      scan(south, southPos, south.length, nextNorthPos, north.length);\n    });\n\n    return south;\n  }\n\n  _.reduce(layering, visitLayer);\n  return conflicts;\n}\n\nfunction findOtherInnerSegmentNode(g, v) {\n  if (g.node(v).dummy) {\n    return _.find(g.predecessors(v), function(u) {\n      return g.node(u).dummy;\n    });\n  }\n}\n\nfunction addConflict(conflicts, v, w) {\n  if (v > w) {\n    var tmp = v;\n    v = w;\n    w = tmp;\n  }\n\n  var conflictsV = conflicts[v];\n  if (!conflictsV) {\n    conflicts[v] = conflictsV = {};\n  }\n  conflictsV[w] = true;\n}\n\nfunction hasConflict(conflicts, v, w) {\n  if (v > w) {\n    var tmp = v;\n    v = w;\n    w = tmp;\n  }\n  return _.has(conflicts[v], w);\n}\n\n/*\n * Try to align nodes into vertical \"blocks\" where possible. This algorithm\n * attempts to align a node with one of its median neighbors. If the edge\n * connecting a neighbor is a type-1 conflict then we ignore that possibility.\n * If a previous node has already formed a block with a node after the node\n * we're trying to form a block with, we also ignore that possibility - our\n * blocks would be split in that scenario.\n */\nfunction verticalAlignment(g, layering, conflicts, neighborFn) {\n  var root = {},\n    align = {},\n    pos = {};\n\n  // We cache the position here based on the layering because the graph and\n  // layering may be out of sync. The layering matrix is manipulated to\n  // generate different extreme alignments.\n  _.forEach(layering, function(layer) {\n    _.forEach(layer, function(v, order) {\n      root[v] = v;\n      align[v] = v;\n      pos[v] = order;\n    });\n  });\n\n  _.forEach(layering, function(layer) {\n    var prevIdx = -1;\n    _.forEach(layer, function(v) {\n      var ws = neighborFn(v);\n      if (ws.length) {\n        ws = _.sortBy(ws, function(w) { return pos[w]; });\n        var mp = (ws.length - 1) / 2;\n        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {\n          var w = ws[i];\n          if (align[v] === v &&\n              prevIdx < pos[w] &&\n              !hasConflict(conflicts, v, w)) {\n            align[w] = v;\n            align[v] = root[v] = root[w];\n            prevIdx = pos[w];\n          }\n        }\n      }\n    });\n  });\n\n  return { root: root, align: align };\n}\n\nfunction horizontalCompaction(g, layering, root, align, reverseSep) {\n  // This portion of the algorithm differs from BK due to a number of problems.\n  // Instead of their algorithm we construct a new block graph and do two\n  // sweeps. The first sweep places blocks with the smallest possible\n  // coordinates. The second sweep removes unused space by moving blocks to the\n  // greatest coordinates without violating separation.\n  var xs = {},\n    blockG = buildBlockGraph(g, layering, root, reverseSep),\n    borderType = reverseSep ? \"borderLeft\" : \"borderRight\";\n\n  function iterate(setXsFunc, nextNodesFunc) {\n    var stack = blockG.nodes();\n    var elem = stack.pop();\n    var visited = {};\n    while (elem) {\n      if (visited[elem]) {\n        setXsFunc(elem);\n      } else {\n        visited[elem] = true;\n        stack.push(elem);\n        stack = stack.concat(nextNodesFunc(elem));\n      }\n\n      elem = stack.pop();\n    }\n  }\n\n  // First pass, assign smallest coordinates\n  function pass1(elem) {\n    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {\n      return Math.max(acc, xs[e.v] + blockG.edge(e));\n    }, 0);\n  }\n\n  // Second pass, assign greatest coordinates\n  function pass2(elem) {\n    var min = blockG.outEdges(elem).reduce(function(acc, e) {\n      return Math.min(acc, xs[e.w] - blockG.edge(e));\n    }, Number.POSITIVE_INFINITY);\n\n    var node = g.node(elem);\n    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {\n      xs[elem] = Math.max(xs[elem], min);\n    }\n  }\n\n  iterate(pass1, blockG.predecessors.bind(blockG));\n  iterate(pass2, blockG.successors.bind(blockG));\n\n  // Assign x coordinates to all nodes\n  _.forEach(align, function(v) {\n    xs[v] = xs[root[v]];\n  });\n\n  return xs;\n}\n\n\nfunction buildBlockGraph(g, layering, root, reverseSep) {\n  var blockGraph = new Graph(),\n    graphLabel = g.graph(),\n    sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);\n\n  _.forEach(layering, function(layer) {\n    var u;\n    _.forEach(layer, function(v) {\n      var vRoot = root[v];\n      blockGraph.setNode(vRoot);\n      if (u) {\n        var uRoot = root[u],\n          prevMax = blockGraph.edge(uRoot, vRoot);\n        blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));\n      }\n      u = v;\n    });\n  });\n\n  return blockGraph;\n}\n\n/*\n * Returns the alignment that has the smallest width of the given alignments.\n */\nfunction findSmallestWidthAlignment(g, xss) {\n  return _.minBy(_.values(xss), function (xs) {\n    var max = Number.NEGATIVE_INFINITY;\n    var min = Number.POSITIVE_INFINITY;\n\n    _.forIn(xs, function (x, v) {\n      var halfWidth = width(g, v) / 2;\n\n      max = Math.max(x + halfWidth, max);\n      min = Math.min(x - halfWidth, min);\n    });\n\n    return max - min;\n  });\n}\n\n/*\n * Align the coordinates of each of the layout alignments such that\n * left-biased alignments have their minimum coordinate at the same point as\n * the minimum coordinate of the smallest width alignment and right-biased\n * alignments have their maximum coordinate at the same point as the maximum\n * coordinate of the smallest width alignment.\n */\nfunction alignCoordinates(xss, alignTo) {\n  var alignToVals = _.values(alignTo),\n    alignToMin = _.min(alignToVals),\n    alignToMax = _.max(alignToVals);\n\n  _.forEach([\"u\", \"d\"], function(vert) {\n    _.forEach([\"l\", \"r\"], function(horiz) {\n      var alignment = vert + horiz,\n        xs = xss[alignment],\n        delta;\n      if (xs === alignTo) return;\n\n      var xsVals = _.values(xs);\n      delta = horiz === \"l\" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);\n\n      if (delta) {\n        xss[alignment] = _.mapValues(xs, function(x) { return x + delta; });\n      }\n    });\n  });\n}\n\nfunction balance(xss, align) {\n  return _.mapValues(xss.ul, function(ignore, v) {\n    if (align) {\n      return xss[align.toLowerCase()][v];\n    } else {\n      var xs = _.sortBy(_.map(xss, v));\n      return (xs[1] + xs[2]) / 2;\n    }\n  });\n}\n\nfunction positionX(g) {\n  var layering = util.buildLayerMatrix(g);\n  var conflicts = _.merge(\n    findType1Conflicts(g, layering),\n    findType2Conflicts(g, layering));\n\n  var xss = {};\n  var adjustedLayering;\n  _.forEach([\"u\", \"d\"], function(vert) {\n    adjustedLayering = vert === \"u\" ? layering : _.values(layering).reverse();\n    _.forEach([\"l\", \"r\"], function(horiz) {\n      if (horiz === \"r\") {\n        adjustedLayering = _.map(adjustedLayering, function(inner) {\n          return _.values(inner).reverse();\n        });\n      }\n\n      var neighborFn = (vert === \"u\" ? g.predecessors : g.successors).bind(g);\n      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);\n      var xs = horizontalCompaction(g, adjustedLayering,\n        align.root, align.align, horiz === \"r\");\n      if (horiz === \"r\") {\n        xs = _.mapValues(xs, function(x) { return -x; });\n      }\n      xss[vert + horiz] = xs;\n    });\n  });\n\n  var smallestWidth = findSmallestWidthAlignment(g, xss);\n  alignCoordinates(xss, smallestWidth);\n  return balance(xss, g.graph().align);\n}\n\nfunction sep(nodeSep, edgeSep, reverseSep) {\n  return function(g, v, w) {\n    var vLabel = g.node(v);\n    var wLabel = g.node(w);\n    var sum = 0;\n    var delta;\n\n    sum += vLabel.width / 2;\n    if (_.has(vLabel, \"labelpos\")) {\n      switch (vLabel.labelpos.toLowerCase()) {\n      case \"l\": delta = -vLabel.width / 2; break;\n      case \"r\": delta = vLabel.width / 2; break;\n      }\n    }\n    if (delta) {\n      sum += reverseSep ? delta : -delta;\n    }\n    delta = 0;\n\n    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;\n    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;\n\n    sum += wLabel.width / 2;\n    if (_.has(wLabel, \"labelpos\")) {\n      switch (wLabel.labelpos.toLowerCase()) {\n      case \"l\": delta = wLabel.width / 2; break;\n      case \"r\": delta = -wLabel.width / 2; break;\n      }\n    }\n    if (delta) {\n      sum += reverseSep ? delta : -delta;\n    }\n    delta = 0;\n\n    return sum;\n  };\n}\n\nfunction width(g, v) {\n  return g.node(v).width;\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,30 @@
+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";
+import { require_bk as r } from "./bk.js";
+//#region node_modules/dagre/lib/position/index.js
+var i = /* @__PURE__ */ e(((e, i) => {
+	var a = t(), o = n(), s = r().positionX;
+	i.exports = c;
+	function c(e) {
+		e = o.asNonCompoundGraph(e), l(e), a.forEach(s(e), function(t, n) {
+			e.node(n).x = t;
+		});
+	}
+	function l(e) {
+		var t = o.buildLayerMatrix(e), n = e.graph().ranksep, r = 0;
+		a.forEach(t, function(t) {
+			var i = a.max(a.map(t, function(t) {
+				return e.node(t).height;
+			}));
+			a.forEach(t, function(t) {
+				e.node(t).y = r + i / 2;
+			}), r += i + n;
+		});
+	}
+}));
+//#endregion
+export default i();
+export { i as require_position };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../node_modules/dagre/lib/position/index.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar util = require(\"../util\");\nvar positionX = require(\"./bk\").positionX;\n\nmodule.exports = position;\n\nfunction position(g) {\n  g = util.asNonCompoundGraph(g);\n\n  positionY(g);\n  _.forEach(positionX(g), function(x, v) {\n    g.node(v).x = x;\n  });\n}\n\nfunction positionY(g) {\n  var layering = util.buildLayerMatrix(g);\n  var rankSep = g.graph().ranksep;\n  var prevY = 0;\n  _.forEach(layering, function(layer) {\n    var maxHeight = _.max(_.map(layer, function(v) { return g.node(v).height; }));\n    _.forEach(layer, function(v) {\n      g.node(v).y = prevY + maxHeight / 2;\n    });\n    prevY += maxHeight + rankSep;\n  });\n}\n\n"],"x_google_ignoreList":[0],"mappings":";;;;;;CAEA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA,EACA,IAAA,GAAA,CAA4B;AAEhC,GAAO,UAAU;CAEjB,SAAS,EAAS,GAAG;AAInB,EAHA,IAAI,EAAK,mBAAmB,EAAE,EAE9B,EAAU,EAAE,EACZ,EAAE,QAAQ,EAAU,EAAE,EAAE,SAAS,GAAG,GAAG;AACrC,KAAE,KAAK,EAAE,CAAC,IAAI;IACd;;CAGJ,SAAS,EAAU,GAAG;EACpB,IAAI,IAAW,EAAK,iBAAiB,EAAE,EACnC,IAAU,EAAE,OAAO,CAAC,SACpB,IAAQ;AACZ,IAAE,QAAQ,GAAU,SAAS,GAAO;GAClC,IAAI,IAAY,EAAE,IAAI,EAAE,IAAI,GAAO,SAAS,GAAG;AAAE,WAAO,EAAE,KAAK,EAAE,CAAC;KAAU,CAAC;AAI7E,GAHA,EAAE,QAAQ,GAAO,SAAS,GAAG;AAC3B,MAAE,KAAK,EAAE,CAAC,IAAI,IAAQ,IAAY;KAClC,EACF,KAAS,IAAY;IACrB"}

package/dist/node_modules/dagre/lib/rank/feasible-tree.js

@@ -0,0 +1,39 @@
+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";
+//#region node_modules/dagre/lib/rank/feasible-tree.js
+var i = /* @__PURE__ */ e(((e, i) => {
+	var a = n(), o = t().Graph, s = r().slack;
+	i.exports = c;
+	function c(e) {
+		var t = new o({ directed: !1 }), n = e.nodes()[0], r = e.nodeCount();
+		t.setNode(n, {});
+		for (var i, a; l(t, e) < r;) i = u(t, e), a = t.hasNode(i.v) ? s(e, i) : -s(e, i), d(t, e, a);
+		return t;
+	}
+	function l(e, t) {
+		function n(r) {
+			a.forEach(t.nodeEdges(r), function(i) {
+				var a = i.v, o = r === a ? i.w : a;
+				!e.hasNode(o) && !s(t, i) && (e.setNode(o, {}), e.setEdge(r, o, {}), n(o));
+			});
+		}
+		return a.forEach(e.nodes(), n), e.nodeCount();
+	}
+	function u(e, t) {
+		return a.minBy(t.edges(), function(n) {
+			if (e.hasNode(n.v) !== e.hasNode(n.w)) return s(t, n);
+		});
+	}
+	function d(e, t, n) {
+		a.forEach(e.nodes(), function(e) {
+			t.node(e).rank += n;
+		});
+	}
+}));
+//#endregion
+export default i();
+export { i as require_feasible_tree };
+
+//# sourceMappingURL=feasible-tree.js.map

package/dist/node_modules/dagre/lib/rank/feasible-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feasible-tree.js","names":[],"sources":["../../../../../node_modules/dagre/lib/rank/feasible-tree.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar Graph = require(\"../graphlib\").Graph;\nvar slack = require(\"./util\").slack;\n\nmodule.exports = feasibleTree;\n\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nfunction feasibleTree(g) {\n  var t = new Graph({ directed: false });\n\n  // Choose arbitrary node from which to start our tree\n  var start = g.nodes()[0];\n  var size = g.nodeCount();\n  t.setNode(start, {});\n\n  var edge, delta;\n  while (tightTree(t, g) < size) {\n    edge = findMinSlackEdge(t, g);\n    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);\n    shiftRanks(t, g, delta);\n  }\n\n  return t;\n}\n\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nfunction tightTree(t, g) {\n  function dfs(v) {\n    _.forEach(g.nodeEdges(v), function(e) {\n      var edgeV = e.v,\n        w = (v === edgeV) ? e.w : edgeV;\n      if (!t.hasNode(w) && !slack(g, e)) {\n        t.setNode(w, {});\n        t.setEdge(v, w, {});\n        dfs(w);\n      }\n    });\n  }\n\n  _.forEach(t.nodes(), dfs);\n  return t.nodeCount();\n}\n\n/*\n * Finds the edge with the smallest slack that is incident on tree and returns\n * it.\n */\nfunction findMinSlackEdge(t, g) {\n  return _.minBy(g.edges(), function(e) {\n    if (t.hasNode(e.v) !== t.hasNode(e.w)) {\n      return slack(g, e);\n    }\n  });\n}\n\nfunction shiftRanks(t, g, delta) {\n  _.forEach(t.nodes(), function(v) {\n    g.node(v).rank += delta;\n  });\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;CAEA,IAAI,IAAA,GAAA,EACA,IAAA,GAAA,CAA+B,OAC/B,IAAA,GAAA,CAA0B;AAE9B,GAAO,UAAU;CA2BjB,SAAS,EAAa,GAAG;EACvB,IAAI,IAAI,IAAI,EAAM,EAAE,UAAU,IAAO,CAAC,EAGlC,IAAQ,EAAE,OAAO,CAAC,IAClB,IAAO,EAAE,WAAW;AACxB,IAAE,QAAQ,GAAO,EAAE,CAAC;AAGpB,OADA,IAAI,GAAM,GACH,EAAU,GAAG,EAAE,GAAG,GAGvB,CAFA,IAAO,EAAiB,GAAG,EAAE,EAC7B,IAAQ,EAAE,QAAQ,EAAK,EAAE,GAAG,EAAM,GAAG,EAAK,GAAG,CAAC,EAAM,GAAG,EAAK,EAC5D,EAAW,GAAG,GAAG,EAAM;AAGzB,SAAO;;CAOT,SAAS,EAAU,GAAG,GAAG;EACvB,SAAS,EAAI,GAAG;AACd,KAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,SAAS,GAAG;IACpC,IAAI,IAAQ,EAAE,GACZ,IAAK,MAAM,IAAS,EAAE,IAAI;AAC5B,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAM,GAAG,EAAE,KAC/B,EAAE,QAAQ,GAAG,EAAE,CAAC,EAChB,EAAE,QAAQ,GAAG,GAAG,EAAE,CAAC,EACnB,EAAI,EAAE;KAER;;AAIJ,SADA,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAI,EAClB,EAAE,WAAW;;CAOtB,SAAS,EAAiB,GAAG,GAAG;AAC9B,SAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG;AACpC,OAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,CACnC,QAAO,EAAM,GAAG,EAAE;IAEpB;;CAGJ,SAAS,EAAW,GAAG,GAAG,GAAO;AAC/B,IAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,GAAG;AAC/B,KAAE,KAAK,EAAE,CAAC,QAAQ;IAClB"}

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

@@ -0,0 +1,35 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_util as t } from "./util.js";
+import { require_feasible_tree as n } from "./feasible-tree.js";
+import { require_network_simplex as r } from "./network-simplex.js";
+//#region node_modules/dagre/lib/rank/index.js
+var i = /* @__PURE__ */ e(((e, i) => {
+	var a = t().longestPath, o = n(), s = r();
+	i.exports = c;
+	function c(e) {
+		switch (e.graph().ranker) {
+			case "network-simplex":
+				d(e);
+				break;
+			case "tight-tree":
+				u(e);
+				break;
+			case "longest-path":
+				l(e);
+				break;
+			default: d(e);
+		}
+	}
+	var l = a;
+	function u(e) {
+		a(e), o(e);
+	}
+	function d(e) {
+		s(e);
+	}
+}));
+//#endregion
+export default i();
+export { i as require_rank };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../node_modules/dagre/lib/rank/index.js"],"sourcesContent":["\"use strict\";\n\nvar rankUtil = require(\"./util\");\nvar longestPath = rankUtil.longestPath;\nvar feasibleTree = require(\"./feasible-tree\");\nvar networkSimplex = require(\"./network-simplex\");\n\nmodule.exports = rank;\n\n/*\n * Assigns a rank to each node in the input graph that respects the \"minlen\"\n * constraint specified on edges between nodes.\n *\n * This basic structure is derived from Gansner, et al., \"A Technique for\n * Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a connected DAG\n *    2. Graph nodes must be objects\n *    3. Graph edges must have \"weight\" and \"minlen\" attributes\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have a \"rank\" attribute based on the results of the\n *       algorithm. Ranks can start at any index (including negative), we'll\n *       fix them up later.\n */\nfunction rank(g) {\n  switch(g.graph().ranker) {\n  case \"network-simplex\": networkSimplexRanker(g); break;\n  case \"tight-tree\": tightTreeRanker(g); break;\n  case \"longest-path\": longestPathRanker(g); break;\n  default: networkSimplexRanker(g);\n  }\n}\n\n// A fast and simple ranker, but results are far from optimal.\nvar longestPathRanker = longestPath;\n\nfunction tightTreeRanker(g) {\n  longestPath(g);\n  feasibleTree(g);\n}\n\nfunction networkSimplexRanker(g) {\n  networkSimplex(g);\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;;;CAGA,IAAI,IAAA,GAAA,CAAuB,aACvB,IAAA,GAAA,EACA,IAAA,GAAA;AAEJ,GAAO,UAAU;CAqBjB,SAAS,EAAK,GAAG;AACf,UAAO,EAAE,OAAO,CAAC,QAAjB;GACA,KAAK;AAAmB,MAAqB,EAAE;AAAE;GACjD,KAAK;AAAc,MAAgB,EAAE;AAAE;GACvC,KAAK;AAAgB,MAAkB,EAAE;AAAE;GAC3C,QAAS,GAAqB,EAAE;;;CAKlC,IAAI,IAAoB;CAExB,SAAS,EAAgB,GAAG;AAE1B,EADA,EAAY,EAAE,EACd,EAAa,EAAE;;CAGjB,SAAS,EAAqB,GAAG;AAC/B,IAAe,EAAE"}

package/dist/node_modules/dagre/lib/rank/network-simplex.js

@@ -0,0 +1,90 @@
+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_util as i } from "./util.js";
+import { require_feasible_tree as a } from "./feasible-tree.js";
+//#region node_modules/dagre/lib/rank/network-simplex.js
+var o = /* @__PURE__ */ e(((e, o) => {
+	var s = n(), c = a(), l = i().slack, u = i().longestPath, d = t().alg.preorder, f = t().alg.postorder, p = r().simplify;
+	o.exports = m, m.initLowLimValues = v, m.initCutValues = h, m.calcCutValue = _, m.leaveEdge = b, m.enterEdge = x, m.exchangeEdges = S;
+	function m(e) {
+		e = p(e), u(e);
+		var t = c(e);
+		v(t), h(t, e);
+		for (var n, r; n = b(t);) r = x(t, e, n), S(t, e, n, r);
+	}
+	function h(e, t) {
+		var n = f(e, e.nodes());
+		n = n.slice(0, n.length - 1), s.forEach(n, function(n) {
+			g(e, t, n);
+		});
+	}
+	function g(e, t, n) {
+		var r = e.node(n).parent;
+		e.edge(n, r).cutvalue = _(e, t, n);
+	}
+	function _(e, t, n) {
+		var r = e.node(n).parent, i = !0, a = t.edge(n, r), o = 0;
+		return a ||= (i = !1, t.edge(r, n)), o = a.weight, s.forEach(t.nodeEdges(n), function(a) {
+			var s = a.v === n, c = s ? a.w : a.v;
+			if (c !== r) {
+				var l = s === i, u = t.edge(a).weight;
+				if (o += l ? u : -u, w(e, n, c)) {
+					var d = e.edge(n, c).cutvalue;
+					o += l ? -d : d;
+				}
+			}
+		}), o;
+	}
+	function v(e, t) {
+		arguments.length < 2 && (t = e.nodes()[0]), y(e, {}, 1, t);
+	}
+	function y(e, t, n, r, i) {
+		var a = n, o = e.node(r);
+		return t[r] = !0, s.forEach(e.neighbors(r), function(i) {
+			s.has(t, i) || (n = y(e, t, n, i, r));
+		}), o.low = a, o.lim = n++, i ? o.parent = i : delete o.parent, n;
+	}
+	function b(e) {
+		return s.find(e.edges(), function(t) {
+			return e.edge(t).cutvalue < 0;
+		});
+	}
+	function x(e, t, n) {
+		var r = n.v, i = n.w;
+		t.hasEdge(r, i) || (r = n.w, i = n.v);
+		var a = e.node(r), o = e.node(i), c = a, u = !1;
+		a.lim > o.lim && (c = o, u = !0);
+		var d = s.filter(t.edges(), function(t) {
+			return u === T(e, e.node(t.v), c) && u !== T(e, e.node(t.w), c);
+		});
+		return s.minBy(d, function(e) {
+			return l(t, e);
+		});
+	}
+	function S(e, t, n, r) {
+		var i = n.v, a = n.w;
+		e.removeEdge(i, a), e.setEdge(r.v, r.w, {}), v(e), h(e, t), C(e, t);
+	}
+	function C(e, t) {
+		var n = d(e, s.find(e.nodes(), function(e) {
+			return !t.node(e).parent;
+		}));
+		n = n.slice(1), s.forEach(n, function(n) {
+			var r = e.node(n).parent, i = t.edge(n, r), a = !1;
+			i || (i = t.edge(r, n), a = !0), t.node(n).rank = t.node(r).rank + (a ? i.minlen : -i.minlen);
+		});
+	}
+	function w(e, t, n) {
+		return e.hasEdge(t, n);
+	}
+	function T(e, t, n) {
+		return n.low <= t.lim && t.lim <= n.lim;
+	}
+}));
+//#endregion
+export default o();
+export { o as require_network_simplex };
+
+//# sourceMappingURL=network-simplex.js.map

package/dist/node_modules/dagre/lib/rank/network-simplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.js","names":[],"sources":["../../../../../node_modules/dagre/lib/rank/network-simplex.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar feasibleTree = require(\"./feasible-tree\");\nvar slack = require(\"./util\").slack;\nvar initRank = require(\"./util\").longestPath;\nvar preorder = require(\"../graphlib\").alg.preorder;\nvar postorder = require(\"../graphlib\").alg.postorder;\nvar simplify = require(\"../util\").simplify;\n\nmodule.exports = networkSimplex;\n\n// Expose some internals for testing purposes\nnetworkSimplex.initLowLimValues = initLowLimValues;\nnetworkSimplex.initCutValues = initCutValues;\nnetworkSimplex.calcCutValue = calcCutValue;\nnetworkSimplex.leaveEdge = leaveEdge;\nnetworkSimplex.enterEdge = enterEdge;\nnetworkSimplex.exchangeEdges = exchangeEdges;\n\n/*\n * The network simplex algorithm assigns ranks to each node in the input graph\n * and iteratively improves the ranking to reduce the length of edges.\n *\n * Preconditions:\n *\n *    1. The input graph must be a DAG.\n *    2. All nodes in the graph must have an object value.\n *    3. All edges in the graph must have \"minlen\" and \"weight\" attributes.\n *\n * Postconditions:\n *\n *    1. All nodes in the graph will have an assigned \"rank\" attribute that has\n *       been optimized by the network simplex algorithm. Ranks start at 0.\n *\n *\n * A rough sketch of the algorithm is as follows:\n *\n *    1. Assign initial ranks to each node. We use the longest path algorithm,\n *       which assigns ranks to the lowest position possible. In general this\n *       leads to very wide bottom ranks and unnecessarily long edges.\n *    2. Construct a feasible tight tree. A tight tree is one such that all\n *       edges in the tree have no slack (difference between length of edge\n *       and minlen for the edge). This by itself greatly improves the assigned\n *       rankings by shorting edges.\n *    3. Iteratively find edges that have negative cut values. Generally a\n *       negative cut value indicates that the edge could be removed and a new\n *       tree edge could be added to produce a more compact graph.\n *\n * Much of the algorithms here are derived from Gansner, et al., \"A Technique\n * for Drawing Directed Graphs.\" The structure of the file roughly follows the\n * structure of the overall algorithm.\n */\nfunction networkSimplex(g) {\n  g = simplify(g);\n  initRank(g);\n  var t = feasibleTree(g);\n  initLowLimValues(t);\n  initCutValues(t, g);\n\n  var e, f;\n  while ((e = leaveEdge(t))) {\n    f = enterEdge(t, g, e);\n    exchangeEdges(t, g, e, f);\n  }\n}\n\n/*\n * Initializes cut values for all edges in the tree.\n */\nfunction initCutValues(t, g) {\n  var vs = postorder(t, t.nodes());\n  vs = vs.slice(0, vs.length - 1);\n  _.forEach(vs, function(v) {\n    assignCutValue(t, g, v);\n  });\n}\n\nfunction assignCutValue(t, g, child) {\n  var childLab = t.node(child);\n  var parent = childLab.parent;\n  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);\n}\n\n/*\n * Given the tight tree, its graph, and a child in the graph calculate and\n * return the cut value for the edge between the child and its parent.\n */\nfunction calcCutValue(t, g, child) {\n  var childLab = t.node(child);\n  var parent = childLab.parent;\n  // True if the child is on the tail end of the edge in the directed graph\n  var childIsTail = true;\n  // The graph's view of the tree edge we're inspecting\n  var graphEdge = g.edge(child, parent);\n  // The accumulated cut value for the edge between this node and its parent\n  var cutValue = 0;\n\n  if (!graphEdge) {\n    childIsTail = false;\n    graphEdge = g.edge(parent, child);\n  }\n\n  cutValue = graphEdge.weight;\n\n  _.forEach(g.nodeEdges(child), function(e) {\n    var isOutEdge = e.v === child,\n      other = isOutEdge ? e.w : e.v;\n\n    if (other !== parent) {\n      var pointsToHead = isOutEdge === childIsTail,\n        otherWeight = g.edge(e).weight;\n\n      cutValue += pointsToHead ? otherWeight : -otherWeight;\n      if (isTreeEdge(t, child, other)) {\n        var otherCutValue = t.edge(child, other).cutvalue;\n        cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n      }\n    }\n  });\n\n  return cutValue;\n}\n\nfunction initLowLimValues(tree, root) {\n  if (arguments.length < 2) {\n    root = tree.nodes()[0];\n  }\n  dfsAssignLowLim(tree, {}, 1, root);\n}\n\nfunction dfsAssignLowLim(tree, visited, nextLim, v, parent) {\n  var low = nextLim;\n  var label = tree.node(v);\n\n  visited[v] = true;\n  _.forEach(tree.neighbors(v), function(w) {\n    if (!_.has(visited, w)) {\n      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);\n    }\n  });\n\n  label.low = low;\n  label.lim = nextLim++;\n  if (parent) {\n    label.parent = parent;\n  } else {\n    // TODO should be able to remove this when we incrementally update low lim\n    delete label.parent;\n  }\n\n  return nextLim;\n}\n\nfunction leaveEdge(tree) {\n  return _.find(tree.edges(), function(e) {\n    return tree.edge(e).cutvalue < 0;\n  });\n}\n\nfunction enterEdge(t, g, edge) {\n  var v = edge.v;\n  var w = edge.w;\n\n  // For the rest of this function we assume that v is the tail and w is the\n  // head, so if we don't have this edge in the graph we should flip it to\n  // match the correct orientation.\n  if (!g.hasEdge(v, w)) {\n    v = edge.w;\n    w = edge.v;\n  }\n\n  var vLabel = t.node(v);\n  var wLabel = t.node(w);\n  var tailLabel = vLabel;\n  var flip = false;\n\n  // If the root is in the tail of the edge then we need to flip the logic that\n  // checks for the head and tail nodes in the candidates function below.\n  if (vLabel.lim > wLabel.lim) {\n    tailLabel = wLabel;\n    flip = true;\n  }\n\n  var candidates = _.filter(g.edges(), function(edge) {\n    return flip === isDescendant(t, t.node(edge.v), tailLabel) &&\n           flip !== isDescendant(t, t.node(edge.w), tailLabel);\n  });\n\n  return _.minBy(candidates, function(edge) { return slack(g, edge); });\n}\n\nfunction exchangeEdges(t, g, e, f) {\n  var v = e.v;\n  var w = e.w;\n  t.removeEdge(v, w);\n  t.setEdge(f.v, f.w, {});\n  initLowLimValues(t);\n  initCutValues(t, g);\n  updateRanks(t, g);\n}\n\nfunction updateRanks(t, g) {\n  var root = _.find(t.nodes(), function(v) { return !g.node(v).parent; });\n  var vs = preorder(t, root);\n  vs = vs.slice(1);\n  _.forEach(vs, function(v) {\n    var parent = t.node(v).parent,\n      edge = g.edge(v, parent),\n      flipped = false;\n\n    if (!edge) {\n      edge = g.edge(parent, v);\n      flipped = true;\n    }\n\n    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);\n  });\n}\n\n/*\n * Returns true if the edge is in the tree.\n */\nfunction isTreeEdge(tree, u, v) {\n  return tree.hasEdge(u, v);\n}\n\n/*\n * Returns true if the specified node is descendant of the root node per the\n * assigned low and lim attributes in the tree.\n */\nfunction isDescendant(tree, vLabel, rootLabel) {\n  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/dagre/lib/rank/util.js

@@ -0,0 +1,31 @@
+import { __commonJSMin as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { require_lodash as t } from "../lodash.js";
+//#region node_modules/dagre/lib/rank/util.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = {
+		longestPath: i,
+		slack: a
+	};
+	function i(e) {
+		var t = {};
+		function n(i) {
+			var a = e.node(i);
+			if (r.has(t, i)) return a.rank;
+			t[i] = !0;
+			var o = r.min(r.map(e.outEdges(i), function(t) {
+				return n(t.w) - e.edge(t).minlen;
+			}));
+			return (o === Infinity || o == null) && (o = 0), a.rank = o;
+		}
+		r.forEach(e.sources(), n);
+	}
+	function a(e, t) {
+		return e.node(t.w).rank - e.node(t.v).rank - e.edge(t).minlen;
+	}
+}));
+//#endregion
+export default n();
+export { n as require_util };
+
+//# sourceMappingURL=util.js.map

package/dist/node_modules/dagre/lib/rank/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":[],"sources":["../../../../../node_modules/dagre/lib/rank/util.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\n\nmodule.exports = {\n  longestPath: longestPath,\n  slack: slack\n};\n\n/*\n * Initializes ranks for the input graph using the longest path algorithm. This\n * algorithm scales well and is fast in practice, it yields rather poor\n * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom\n * ranks wide and leaving edges longer than necessary. However, due to its\n * speed, this algorithm is good for getting an initial ranking that can be fed\n * into other algorithms.\n *\n * This algorithm does not normalize layers because it will be used by other\n * algorithms in most cases. If using this algorithm directly, be sure to\n * run normalize at the end.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG.\n *    2. Input graph node labels can be assigned properties.\n *\n * Post-conditions:\n *\n *    1. Each node will be assign an (unnormalized) \"rank\" property.\n */\nfunction longestPath(g) {\n  var visited = {};\n\n  function dfs(v) {\n    var label = g.node(v);\n    if (_.has(visited, v)) {\n      return label.rank;\n    }\n    visited[v] = true;\n\n    var rank = _.min(_.map(g.outEdges(v), function(e) {\n      return dfs(e.w) - g.edge(e).minlen;\n    }));\n\n    if (rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3\n        rank === undefined || // return value of _.map([]) for Lodash 4\n        rank === null) { // return value of _.map([null])\n      rank = 0;\n    }\n\n    return (label.rank = rank);\n  }\n\n  _.forEach(g.sources(), dfs);\n}\n\n/*\n * Returns the amount of slack for the given edge. The slack is defined as the\n * difference between the length of the edge and its minimum length.\n */\nfunction slack(g, e) {\n  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;CAEA,IAAI,IAAA,GAAA;AAEJ,GAAO,UAAU;EACF;EACN;EACR;CAuBD,SAAS,EAAY,GAAG;EACtB,IAAI,IAAU,EAAE;EAEhB,SAAS,EAAI,GAAG;GACd,IAAI,IAAQ,EAAE,KAAK,EAAE;AACrB,OAAI,EAAE,IAAI,GAAS,EAAE,CACnB,QAAO,EAAM;AAEf,KAAQ,KAAK;GAEb,IAAI,IAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG;AAChD,WAAO,EAAI,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;KAC5B,CAAC;AAQH,WANI,MAAS,YACT,KACS,UACX,IAAO,IAGD,EAAM,OAAO;;AAGvB,IAAE,QAAQ,EAAE,SAAS,EAAE,EAAI;;CAO7B,SAAS,EAAM,GAAG,GAAG;AACnB,SAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC"}