qidian-vue-ui 1.1.49 → 1.1.51

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport * as alg from '../../graphlib/alg/index.js';\nimport { simplify } from '../util.js';\nimport { feasibleTree } from './feasible-tree.js';\nimport { longestPath, slack } from './util.js';\n\nexport { 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  longestPath(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 = alg.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 (!Object.prototype.hasOwnProperty.call(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 (\n      flip === isDescendant(t, t.node(edge.v), tailLabel) &&\n      flip !== isDescendant(t, t.node(edge.w), tailLabel)\n    );\n  });\n\n  return _.minBy(candidates, function (edge) {\n    return slack(g, edge);\n  });\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) {\n    return !g.node(v).parent;\n  });\n  var vs = alg.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"],"names":["alg.postorder","_.forEach","_.find","_.filter","edge","_.minBy","alg.preorder"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/util.mjs

@@ -0,0 +1,33 @@
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import min from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/min.mjs";
+import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+function longestPath(g) {
+  var visited = {};
+  function dfs(v) {
+    var label = g.node(v);
+    if (Object.prototype.hasOwnProperty.call(visited, v)) {
+      return label.rank;
+    }
+    visited[v] = true;
+    var rank = min(
+      map(g.outEdges(v), function(e) {
+        return dfs(e.w) - g.edge(e).minlen;
+      })
+    );
+    if (rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+    rank === void 0 || // return value of _.map([]) for Lodash 4
+    rank === null) {
+      rank = 0;
+    }
+    return label.rank = rank;
+  }
+  forEach(g.sources(), dfs);
+}
+function slack(g, e) {
+  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+export {
+  longestPath,
+  slack
+};
+//# sourceMappingURL=util.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/util.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { longestPath, slack };\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 (Object.prototype.hasOwnProperty.call(visited, v)) {\n      return label.rank;\n    }\n    visited[v] = true;\n\n    var rank = _.min(\n      _.map(g.outEdges(v), function (e) {\n        return dfs(e.w) - g.edge(e).minlen;\n      }),\n    );\n\n    if (\n      rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3\n      rank === undefined || // return value of _.map([]) for Lodash 4\n      rank === null\n    ) {\n      // 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"],"names":["_.min","_.map","_.forEach"],"mappings":";;;AAyBA,SAAS,YAAY,GAAG;AACtB,MAAI,UAAU,CAAA;AAEd,WAAS,IAAI,GAAG;AACd,QAAI,QAAQ,EAAE,KAAK,CAAC;AACpB,QAAI,OAAO,UAAU,eAAe,KAAK,SAAS,CAAC,GAAG;AACpD,aAAO,MAAM;AAAA,IACf;AACA,YAAQ,CAAC,IAAI;AAEb,QAAI,OAAOA;AAAAA,MACTC,IAAM,EAAE,SAAS,CAAC,GAAG,SAAU,GAAG;AAChC,eAAO,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE;AAAA,MAC9B,CAAC;AAAA,IACP;AAEI,QACE,SAAS,OAAO;AAAA,IAChB,SAAS;AAAA,IACT,SAAS,MACT;AAEA,aAAO;AAAA,IACT;AAEA,WAAQ,MAAM,OAAO;AAAA,EACvB;AAEAC,UAAU,EAAE,QAAO,GAAI,GAAG;AAC5B;AAMA,SAAS,MAAM,GAAG,GAAG;AACnB,SAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE;AACzD;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/util.mjs

@@ -0,0 +1,172 @@
+import { Graph } from "../graphlib/graph.mjs";
+import forEach from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import min from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/min.mjs";
+import map from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import range from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/range.mjs";
+import uniqueId from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/uniqueId.mjs";
+import max from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.mjs";
+import isUndefined from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+import has from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+function addDummyNode(g, type, attrs, name) {
+  var v;
+  do {
+    v = uniqueId(name);
+  } while (g.hasNode(v));
+  attrs.dummy = type;
+  g.setNode(v, attrs);
+  return v;
+}
+function simplify(g) {
+  var simplified = new Graph().setGraph(g.graph());
+  forEach(g.nodes(), function(v) {
+    simplified.setNode(v, g.node(v));
+  });
+  forEach(g.edges(), function(e) {
+    var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
+    var label = g.edge(e);
+    simplified.setEdge(e.v, e.w, {
+      weight: simpleLabel.weight + label.weight,
+      minlen: Math.max(simpleLabel.minlen, label.minlen)
+    });
+  });
+  return simplified;
+}
+function asNonCompoundGraph(g) {
+  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+  forEach(g.nodes(), function(v) {
+    if (!g.children(v).length) {
+      simplified.setNode(v, g.node(v));
+    }
+  });
+  forEach(g.edges(), function(e) {
+    simplified.setEdge(e, g.edge(e));
+  });
+  return simplified;
+}
+function intersectRect(rect, point) {
+  var x = rect.x;
+  var y = rect.y;
+  var dx = point.x - x;
+  var dy = point.y - y;
+  var w = rect.width / 2;
+  var h = rect.height / 2;
+  if (!dx && !dy) {
+    throw new Error("Not possible to find intersection inside of the rectangle");
+  }
+  var sx, sy;
+  if (Math.abs(dy) * w > Math.abs(dx) * h) {
+    if (dy < 0) {
+      h = -h;
+    }
+    sx = h * dx / dy;
+    sy = h;
+  } else {
+    if (dx < 0) {
+      w = -w;
+    }
+    sx = w;
+    sy = w * dy / dx;
+  }
+  return { x: x + sx, y: y + sy };
+}
+function buildLayerMatrix(g) {
+  var layering = map(range(maxRank(g) + 1), function() {
+    return [];
+  });
+  forEach(g.nodes(), function(v) {
+    var node = g.node(v);
+    var rank = node.rank;
+    if (!isUndefined(rank)) {
+      layering[rank][node.order] = v;
+    }
+  });
+  return layering;
+}
+function normalizeRanks(g) {
+  var min$1 = min(
+    map(g.nodes(), function(v) {
+      return g.node(v).rank;
+    })
+  );
+  forEach(g.nodes(), function(v) {
+    var node = g.node(v);
+    if (has(node, "rank")) {
+      node.rank -= min$1;
+    }
+  });
+}
+function removeEmptyRanks(g) {
+  var offset = min(
+    map(g.nodes(), function(v) {
+      return g.node(v).rank;
+    })
+  );
+  var layers = [];
+  forEach(g.nodes(), function(v) {
+    var rank = g.node(v).rank - offset;
+    if (!layers[rank]) {
+      layers[rank] = [];
+    }
+    layers[rank].push(v);
+  });
+  var delta = 0;
+  var nodeRankFactor = g.graph().nodeRankFactor;
+  forEach(layers, function(vs, i) {
+    if (isUndefined(vs) && i % nodeRankFactor !== 0) {
+      --delta;
+    } else if (delta) {
+      forEach(vs, function(v) {
+        g.node(v).rank += delta;
+      });
+    }
+  });
+}
+function addBorderNode(g, prefix, rank, order) {
+  var node = {
+    width: 0,
+    height: 0
+  };
+  if (arguments.length >= 4) {
+    node.rank = rank;
+    node.order = order;
+  }
+  return addDummyNode(g, "border", node, prefix);
+}
+function maxRank(g) {
+  return max(
+    map(g.nodes(), function(v) {
+      var rank = g.node(v).rank;
+      if (!isUndefined(rank)) {
+        return rank;
+      }
+    })
+  );
+}
+function partition(collection, fn) {
+  var result = { lhs: [], rhs: [] };
+  forEach(collection, function(value) {
+    if (fn(value)) {
+      result.lhs.push(value);
+    } else {
+      result.rhs.push(value);
+    }
+  });
+  return result;
+}
+function notime(name, fn) {
+  return fn();
+}
+export {
+  addBorderNode,
+  addDummyNode,
+  asNonCompoundGraph,
+  buildLayerMatrix,
+  intersectRect,
+  maxRank,
+  normalizeRanks,
+  notime,
+  partition,
+  removeEmptyRanks,
+  simplify
+};
+//# sourceMappingURL=util.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/util.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { Graph } from '../graphlib/index.js';\n\nexport {\n  addDummyNode,\n  simplify,\n  asNonCompoundGraph,\n  successorWeights,\n  predecessorWeights,\n  intersectRect,\n  buildLayerMatrix,\n  normalizeRanks,\n  removeEmptyRanks,\n  addBorderNode,\n  maxRank,\n  partition,\n  time,\n  notime,\n};\n\n/*\n * Adds a dummy node to the graph and return v.\n */\nfunction addDummyNode(g, type, attrs, name) {\n  var v;\n  do {\n    v = _.uniqueId(name);\n  } while (g.hasNode(v));\n\n  attrs.dummy = type;\n  g.setNode(v, attrs);\n  return v;\n}\n\n/*\n * Returns a new graph with only simple edges. Handles aggregation of data\n * associated with multi-edges.\n */\nfunction simplify(g) {\n  var simplified = new Graph().setGraph(g.graph());\n  _.forEach(g.nodes(), function (v) {\n    simplified.setNode(v, g.node(v));\n  });\n  _.forEach(g.edges(), function (e) {\n    var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };\n    var label = g.edge(e);\n    simplified.setEdge(e.v, e.w, {\n      weight: simpleLabel.weight + label.weight,\n      minlen: Math.max(simpleLabel.minlen, label.minlen),\n    });\n  });\n  return simplified;\n}\n\nfunction asNonCompoundGraph(g) {\n  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());\n  _.forEach(g.nodes(), function (v) {\n    if (!g.children(v).length) {\n      simplified.setNode(v, g.node(v));\n    }\n  });\n  _.forEach(g.edges(), function (e) {\n    simplified.setEdge(e, g.edge(e));\n  });\n  return simplified;\n}\n\nfunction successorWeights(g) {\n  var weightMap = _.map(g.nodes(), function (v) {\n    var sucs = {};\n    _.forEach(g.outEdges(v), function (e) {\n      sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;\n    });\n    return sucs;\n  });\n  return _.zipObject(g.nodes(), weightMap);\n}\n\nfunction predecessorWeights(g) {\n  var weightMap = _.map(g.nodes(), function (v) {\n    var preds = {};\n    _.forEach(g.inEdges(v), function (e) {\n      preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;\n    });\n    return preds;\n  });\n  return _.zipObject(g.nodes(), weightMap);\n}\n\n/*\n * Finds where a line starting at point ({x, y}) would intersect a rectangle\n * ({x, y, width, height}) if it were pointing at the rectangle's center.\n */\nfunction intersectRect(rect, point) {\n  var x = rect.x;\n  var y = rect.y;\n\n  // Rectangle intersection algorithm from:\n  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes\n  var dx = point.x - x;\n  var dy = point.y - y;\n  var w = rect.width / 2;\n  var h = rect.height / 2;\n\n  if (!dx && !dy) {\n    throw new Error('Not possible to find intersection inside of the rectangle');\n  }\n\n  var sx, sy;\n  if (Math.abs(dy) * w > Math.abs(dx) * h) {\n    // Intersection is top or bottom of rect.\n    if (dy < 0) {\n      h = -h;\n    }\n    sx = (h * dx) / dy;\n    sy = h;\n  } else {\n    // Intersection is left or right of rect.\n    if (dx < 0) {\n      w = -w;\n    }\n    sx = w;\n    sy = (w * dy) / dx;\n  }\n\n  return { x: x + sx, y: y + sy };\n}\n\n/*\n * Given a DAG with each node assigned \"rank\" and \"order\" properties, this\n * function will produce a matrix with the ids of each node.\n */\nfunction buildLayerMatrix(g) {\n  var layering = _.map(_.range(maxRank(g) + 1), function () {\n    return [];\n  });\n  _.forEach(g.nodes(), function (v) {\n    var node = g.node(v);\n    var rank = node.rank;\n    if (!_.isUndefined(rank)) {\n      layering[rank][node.order] = v;\n    }\n  });\n  return layering;\n}\n\n/*\n * Adjusts the ranks for all nodes in the graph such that all nodes v have\n * rank(v) >= 0 and at least one node w has rank(w) = 0.\n */\nfunction normalizeRanks(g) {\n  var min = _.min(\n    _.map(g.nodes(), function (v) {\n      return g.node(v).rank;\n    }),\n  );\n  _.forEach(g.nodes(), function (v) {\n    var node = g.node(v);\n    if (_.has(node, 'rank')) {\n      node.rank -= min;\n    }\n  });\n}\n\nfunction removeEmptyRanks(g) {\n  // Ranks may not start at 0, so we need to offset them\n  var offset = _.min(\n    _.map(g.nodes(), function (v) {\n      return g.node(v).rank;\n    }),\n  );\n\n  var layers = [];\n  _.forEach(g.nodes(), function (v) {\n    var rank = g.node(v).rank - offset;\n    if (!layers[rank]) {\n      layers[rank] = [];\n    }\n    layers[rank].push(v);\n  });\n\n  var delta = 0;\n  var nodeRankFactor = g.graph().nodeRankFactor;\n  _.forEach(layers, function (vs, i) {\n    if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {\n      --delta;\n    } else if (delta) {\n      _.forEach(vs, function (v) {\n        g.node(v).rank += delta;\n      });\n    }\n  });\n}\n\nfunction addBorderNode(g, prefix, rank, order) {\n  var node = {\n    width: 0,\n    height: 0,\n  };\n  if (arguments.length >= 4) {\n    node.rank = rank;\n    node.order = order;\n  }\n  return addDummyNode(g, 'border', node, prefix);\n}\n\nfunction maxRank(g) {\n  return _.max(\n    _.map(g.nodes(), function (v) {\n      var rank = g.node(v).rank;\n      if (!_.isUndefined(rank)) {\n        return rank;\n      }\n    }),\n  );\n}\n\n/*\n * Partition a collection into two groups: `lhs` and `rhs`. If the supplied\n * function returns true for an entry it goes into `lhs`. Otherwise it goes\n * into `rhs.\n */\nfunction partition(collection, fn) {\n  var result = { lhs: [], rhs: [] };\n  _.forEach(collection, function (value) {\n    if (fn(value)) {\n      result.lhs.push(value);\n    } else {\n      result.rhs.push(value);\n    }\n  });\n  return result;\n}\n\n/*\n * Returns a new function that wraps `fn` with a timer. The wrapper logs the\n * time it takes to execute the function.\n */\nfunction time(name, fn) {\n  var start = _.now();\n  try {\n    return fn();\n  } finally {\n    console.log(name + ' time: ' + (_.now() - start) + 'ms');\n  }\n}\n\nfunction notime(name, fn) {\n  return fn();\n}\n"],"names":["_.uniqueId","_.forEach","_.map","_.range","_.isUndefined","min","_.min","_.has","_.max"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dfs.mjs

@@ -0,0 +1,35 @@
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import isArray from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.mjs";
+function dfs(g, vs, order) {
+  if (!isArray(vs)) {
+    vs = [vs];
+  }
+  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+  var acc = [];
+  var visited = {};
+  forEach(vs, function(v) {
+    if (!g.hasNode(v)) {
+      throw new Error("Graph does not have node: " + v);
+    }
+    doDfs(g, v, order === "post", visited, navigation, acc);
+  });
+  return acc;
+}
+function doDfs(g, v, postorder, visited, navigation, acc) {
+  if (!Object.prototype.hasOwnProperty.call(visited, v)) {
+    visited[v] = true;
+    if (!postorder) {
+      acc.push(v);
+    }
+    forEach(navigation(v), function(w) {
+      doDfs(g, w, postorder, visited, navigation, acc);
+    });
+    if (postorder) {
+      acc.push(v);
+    }
+  }
+}
+export {
+  dfs
+};
+//# sourceMappingURL=dfs.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dfs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfs.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dfs.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { dfs };\n\n/*\n * A helper that preforms a pre- or post-order traversal on the input graph\n * and returns the nodes in the order they were visited. If the graph is\n * undirected then this algorithm will navigate using neighbors. If the graph\n * is directed then this algorithm will navigate using successors.\n *\n * Order must be one of \"pre\" or \"post\".\n */\nfunction dfs(g, vs, order) {\n  if (!_.isArray(vs)) {\n    vs = [vs];\n  }\n\n  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);\n\n  var acc = [];\n  var visited = {};\n  _.each(vs, function (v) {\n    if (!g.hasNode(v)) {\n      throw new Error('Graph does not have node: ' + v);\n    }\n\n    doDfs(g, v, order === 'post', visited, navigation, acc);\n  });\n  return acc;\n}\n\nfunction doDfs(g, v, postorder, visited, navigation, acc) {\n  if (!Object.prototype.hasOwnProperty.call(visited, v)) {\n    visited[v] = true;\n\n    if (!postorder) {\n      acc.push(v);\n    }\n    _.each(navigation(v), function (w) {\n      doDfs(g, w, postorder, visited, navigation, acc);\n    });\n    if (postorder) {\n      acc.push(v);\n    }\n  }\n}\n"],"names":["_.isArray","_.each"],"mappings":";;AAYA,SAAS,IAAI,GAAG,IAAI,OAAO;AACzB,MAAI,CAACA,QAAU,EAAE,GAAG;AAClB,SAAK,CAAC,EAAE;AAAA,EACV;AAEA,MAAI,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,KAAK,CAAC;AAErE,MAAI,MAAM,CAAA;AACV,MAAI,UAAU,CAAA;AACdC,UAAO,IAAI,SAAU,GAAG;AACtB,QAAI,CAAC,EAAE,QAAQ,CAAC,GAAG;AACjB,YAAM,IAAI,MAAM,+BAA+B,CAAC;AAAA,IAClD;AAEA,UAAM,GAAG,GAAG,UAAU,QAAQ,SAAS,YAAY,GAAG;AAAA,EACxD,CAAC;AACD,SAAO;AACT;AAEA,SAAS,MAAM,GAAG,GAAG,WAAW,SAAS,YAAY,KAAK;AACxD,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,SAAS,CAAC,GAAG;AACrD,YAAQ,CAAC,IAAI;AAEb,QAAI,CAAC,WAAW;AACd,UAAI,KAAK,CAAC;AAAA,IACZ;AACAA,YAAO,WAAW,CAAC,GAAG,SAAU,GAAG;AACjC,YAAM,GAAG,GAAG,WAAW,SAAS,YAAY,GAAG;AAAA,IACjD,CAAC;AACD,QAAI,WAAW;AACb,UAAI,KAAK,CAAC;AAAA,IACZ;AAAA,EACF;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/postorder.mjs

@@ -0,0 +1,8 @@
+import { dfs } from "./dfs.mjs";
+function postorder(g, vs) {
+  return dfs(g, vs, "post");
+}
+export {
+  postorder
+};
+//# sourceMappingURL=postorder.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/postorder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postorder.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/postorder.js"],"sourcesContent":["import { dfs } from './dfs.js';\n\nexport { postorder };\n\nfunction postorder(g, vs) {\n  return dfs(g, vs, 'post');\n}\n"],"names":[],"mappings":";AAIA,SAAS,UAAU,GAAG,IAAI;AACxB,SAAO,IAAI,GAAG,IAAI,MAAM;AAC1B;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/preorder.mjs

@@ -0,0 +1,8 @@
+import { dfs } from "./dfs.mjs";
+function preorder(g, vs) {
+  return dfs(g, vs, "pre");
+}
+export {
+  preorder
+};
+//# sourceMappingURL=preorder.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/preorder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preorder.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/preorder.js"],"sourcesContent":["import { dfs } from './dfs.js';\n\nexport { preorder };\n\nfunction preorder(g, vs) {\n  return dfs(g, vs, 'pre');\n}\n"],"names":[],"mappings":";AAIA,SAAS,SAAS,GAAG,IAAI;AACvB,SAAO,IAAI,GAAG,IAAI,KAAK;AACzB;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/topsort.mjs

@@ -0,0 +1,7 @@
+function CycleException() {
+}
+CycleException.prototype = new Error();
+export {
+  CycleException
+};
+//# sourceMappingURL=topsort.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/topsort.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"topsort.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/topsort.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { topsort, CycleException };\n\ntopsort.CycleException = CycleException;\n\nfunction topsort(g) {\n  var visited = {};\n  var stack = {};\n  var results = [];\n\n  function visit(node) {\n    if (Object.prototype.hasOwnProperty.call(stack, node)) {\n      throw new CycleException();\n    }\n\n    if (!Object.prototype.hasOwnProperty.call(visited, node)) {\n      stack[node] = true;\n      visited[node] = true;\n      _.each(g.predecessors(node), visit);\n      delete stack[node];\n      results.push(node);\n    }\n  }\n\n  _.each(g.sinks(), visit);\n\n  if (_.size(visited) !== g.nodeCount()) {\n    throw new CycleException();\n  }\n\n  return results;\n}\n\nfunction CycleException() {}\nCycleException.prototype = new Error(); // must be an instance of Error to pass testing\n"],"names":[],"mappings":"AAkCA,SAAS,iBAAiB;AAAC;AAC3B,eAAe,YAAY,IAAI;","x_google_ignoreList":[0]}