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/order/build-layer-graph.mjs

@@ -0,0 +1,36 @@
+import { Graph } from "../../graphlib/graph.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import uniqueId from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/uniqueId.mjs";
+import isUndefined from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+function buildLayerGraph(g, rank, relationship) {
+  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
+    return g.node(v);
+  });
+  forEach(g.nodes(), function(v) {
+    var node = g.node(v), parent = g.parent(v);
+    if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
+      result.setNode(v);
+      result.setParent(v, parent || root);
+      forEach(g[relationship](v), function(e) {
+        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !isUndefined(edge) ? edge.weight : 0;
+        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+      });
+      if (Object.prototype.hasOwnProperty.call(node, "minRank")) {
+        result.setNode(v, {
+          borderLeft: node.borderLeft[rank],
+          borderRight: node.borderRight[rank]
+        });
+      }
+    }
+  });
+  return result;
+}
+function createRootNode(g) {
+  var v;
+  while (g.hasNode(v = uniqueId("_root"))) ;
+  return v;
+}
+export {
+  buildLayerGraph
+};
+//# sourceMappingURL=build-layer-graph.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-layer-graph.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { Graph } from '../../graphlib/index.js';\n\nexport { 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 })\n      .setGraph({ root: root })\n      .setDefaultNodeLabel(function (v) {\n        return g.node(v);\n      });\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 (Object.prototype.hasOwnProperty.call(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"],"names":["_.forEach","_.isUndefined","_.uniqueId"],"mappings":";;;;AAmCA,SAAS,gBAAgB,GAAG,MAAM,cAAc;AAC9C,MAAI,OAAO,eAAe,CAAC,GACzB,SAAS,IAAI,MAAM,EAAE,UAAU,KAAI,CAAE,EAClC,SAAS,EAAE,KAAU,CAAE,EACvB,oBAAoB,SAAU,GAAG;AAChC,WAAO,EAAE,KAAK,CAAC;AAAA,EACjB,CAAC;AAELA,UAAU,EAAE,MAAK,GAAI,SAAU,GAAG;AAChC,QAAI,OAAO,EAAE,KAAK,CAAC,GACjB,SAAS,EAAE,OAAO,CAAC;AAErB,QAAI,KAAK,SAAS,QAAS,KAAK,WAAW,QAAQ,QAAQ,KAAK,SAAU;AACxE,aAAO,QAAQ,CAAC;AAChB,aAAO,UAAU,GAAG,UAAU,IAAI;AAGlCA,cAAU,EAAE,YAAY,EAAE,CAAC,GAAG,SAAU,GAAG;AACzC,YAAI,IAAI,EAAE,MAAM,IAAI,EAAE,IAAI,EAAE,GAC1B,OAAO,OAAO,KAAK,GAAG,CAAC,GACvB,SAAS,CAACC,YAAc,IAAI,IAAI,KAAK,SAAS;AAChD,eAAO,QAAQ,GAAG,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,SAAS,OAAM,CAAE;AAAA,MAC5D,CAAC;AAED,UAAI,OAAO,UAAU,eAAe,KAAK,MAAM,SAAS,GAAG;AACzD,eAAO,QAAQ,GAAG;AAAA,UAChB,YAAY,KAAK,WAAW,IAAI;AAAA,UAChC,aAAa,KAAK,YAAY,IAAI;AAAA,QAC5C,CAAS;AAAA,MACH;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEA,SAAS,eAAe,GAAG;AACzB,MAAI;AACJ,SAAO,EAAE,QAAS,IAAIC,SAAW,OAAO,CAAC,EAAG;AAC5C,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.mjs

@@ -0,0 +1,59 @@
+import zipObject from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/zipObject.mjs";
+import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import flatten from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import sortBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/sortBy.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+function crossCount(g, layering) {
+  var cc = 0;
+  for (var i = 1; i < layering.length; ++i) {
+    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+  }
+  return cc;
+}
+function twoLayerCrossCount(g, northLayer, southLayer) {
+  var southPos = zipObject(
+    southLayer,
+    map(southLayer, function(v, i) {
+      return i;
+    })
+  );
+  var southEntries = flatten(
+    map(northLayer, function(v) {
+      return sortBy(
+        map(g.outEdges(v), function(e) {
+          return { pos: southPos[e.w], weight: g.edge(e).weight };
+        }),
+        "pos"
+      );
+    })
+  );
+  var firstIndex = 1;
+  while (firstIndex < southLayer.length) firstIndex <<= 1;
+  var treeSize = 2 * firstIndex - 1;
+  firstIndex -= 1;
+  var tree = map(new Array(treeSize), function() {
+    return 0;
+  });
+  var cc = 0;
+  forEach(
+    // @ts-expect-error
+    southEntries.forEach(function(entry) {
+      var index = entry.pos + firstIndex;
+      tree[index] += entry.weight;
+      var weightSum = 0;
+      while (index > 0) {
+        if (index % 2) {
+          weightSum += tree[index + 1];
+        }
+        index = index - 1 >> 1;
+        tree[index] += entry.weight;
+      }
+      cc += entry.weight * weightSum;
+    })
+  );
+  return cc;
+}
+export {
+  crossCount
+};
+//# sourceMappingURL=cross-count.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-count.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { 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(\n    southLayer,\n    _.map(southLayer, function (v, i) {\n      return i;\n    }),\n  );\n  var southEntries = _.flatten(\n    _.map(northLayer, function (v) {\n      return _.sortBy(\n        _.map(g.outEdges(v), function (e) {\n          return { pos: southPos[e.w], weight: g.edge(e).weight };\n        }),\n        'pos',\n      );\n    }),\n  );\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 () {\n    return 0;\n  });\n\n  // Calculate the weighted crossings\n  var cc = 0;\n  _.forEach(\n    // @ts-expect-error\n    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\n  return cc;\n}\n"],"names":["_.zipObject","_.map","_.flatten","_.sortBy","_.forEach"],"mappings":";;;;;AAoBA,SAAS,WAAW,GAAG,UAAU;AAC/B,MAAI,KAAK;AACT,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,EAAE,GAAG;AACxC,UAAM,mBAAmB,GAAG,SAAS,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC;AAAA,EAC1D;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,GAAG,YAAY,YAAY;AAIrD,MAAI,WAAWA;AAAAA,IACb;AAAA,IACAC,IAAM,YAAY,SAAU,GAAG,GAAG;AAChC,aAAO;AAAA,IACT,CAAC;AAAA,EACL;AACE,MAAI,eAAeC;AAAAA,IACjBD,IAAM,YAAY,SAAU,GAAG;AAC7B,aAAOE;AAAAA,QACLF,IAAM,EAAE,SAAS,CAAC,GAAG,SAAU,GAAG;AAChC,iBAAO,EAAE,KAAK,SAAS,EAAE,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,EAAE,OAAM;AAAA,QACvD,CAAC;AAAA,QACD;AAAA,MACR;AAAA,IACI,CAAC;AAAA,EACL;AAGE,MAAI,aAAa;AACjB,SAAO,aAAa,WAAW,OAAQ,gBAAe;AACtD,MAAI,WAAW,IAAI,aAAa;AAChC,gBAAc;AACd,MAAI,OAAOA,IAAM,IAAI,MAAM,QAAQ,GAAG,WAAY;AAChD,WAAO;AAAA,EACT,CAAC;AAGD,MAAI,KAAK;AACTG;AAAAA;AAAAA,IAEE,aAAa,QAAQ,SAAU,OAAO;AACpC,UAAI,QAAQ,MAAM,MAAM;AACxB,WAAK,KAAK,KAAK,MAAM;AACrB,UAAI,YAAY;AAChB,aAAO,QAAQ,GAAG;AAChB,YAAI,QAAQ,GAAG;AACb,uBAAa,KAAK,QAAQ,CAAC;AAAA,QAC7B;AACA,gBAAS,QAAQ,KAAM;AACvB,aAAK,KAAK,KAAK,MAAM;AAAA,MACvB;AACA,YAAM,MAAM,SAAS;AAAA,IACvB,CAAC;AAAA,EACL;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,55 @@
+import { Graph } from "../../graphlib/graph.mjs";
+import { maxRank, buildLayerMatrix } from "../util.mjs";
+import { addSubgraphConstraints } from "./add-subgraph-constraints.mjs";
+import { buildLayerGraph } from "./build-layer-graph.mjs";
+import { crossCount } from "./cross-count.mjs";
+import { initOrder } from "./init-order.mjs";
+import { sortSubgraph } from "./sort-subgraph.mjs";
+import range from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/range.mjs";
+import cloneDeep from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/cloneDeep.mjs";
+import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+function order(g) {
+  var maxRank$1 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, range(1, maxRank$1 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, range(maxRank$1 - 1, -1, -1), "outEdges");
+  var layering = initOrder(g);
+  assignOrder(g, layering);
+  var bestCC = Number.POSITIVE_INFINITY, best;
+  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+    sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+    layering = buildLayerMatrix(g);
+    var cc = crossCount(g, layering);
+    if (cc < bestCC) {
+      lastBest = 0;
+      best = cloneDeep(layering);
+      bestCC = cc;
+    }
+  }
+  assignOrder(g, best);
+}
+function buildLayerGraphs(g, ranks, relationship) {
+  return map(ranks, function(rank) {
+    return buildLayerGraph(g, rank, relationship);
+  });
+}
+function sweepLayerGraphs(layerGraphs, biasRight) {
+  var cg = new Graph();
+  forEach(layerGraphs, function(lg) {
+    var root = lg.graph().root;
+    var sorted = sortSubgraph(lg, root, cg, biasRight);
+    forEach(sorted.vs, function(v, i) {
+      lg.node(v).order = i;
+    });
+    addSubgraphConstraints(lg, cg, sorted.vs);
+  });
+}
+function assignOrder(g, layering) {
+  forEach(layering, function(layer) {
+    forEach(layer, function(v, i) {
+      g.node(v).order = i;
+    });
+  });
+}
+export {
+  order
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/index.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { Graph } from '../../graphlib/index.js';\nimport * as util from '../util.js';\nimport { addSubgraphConstraints } from './add-subgraph-constraints.js';\nimport { buildLayerGraph } from './build-layer-graph.js';\nimport { crossCount } from './cross-count.js';\nimport { initOrder } from './init-order.js';\nimport { sortSubgraph } from './sort-subgraph.js';\n\nexport { 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"],"names":["maxRank","util.maxRank","_.range","util.buildLayerMatrix","_.cloneDeep","_.map","_.forEach"],"mappings":";;;;;;;;;;;AA0BA,SAAS,MAAM,GAAG;AAChB,MAAIA,YAAUC,QAAa,CAAC,GAC1B,kBAAkB,iBAAiB,GAAGC,MAAQ,GAAGF,YAAU,CAAC,GAAG,SAAS,GACxE,gBAAgB,iBAAiB,GAAGE,MAAQF,YAAU,GAAG,IAAI,EAAE,GAAG,UAAU;AAE9E,MAAI,WAAW,UAAU,CAAC;AAC1B,cAAY,GAAG,QAAQ;AAEvB,MAAI,SAAS,OAAO,mBAClB;AAEF,WAAS,IAAI,GAAG,WAAW,GAAG,WAAW,GAAG,EAAE,GAAG,EAAE,UAAU;AAC3D,qBAAiB,IAAI,IAAI,kBAAkB,eAAe,IAAI,KAAK,CAAC;AAEpE,eAAWG,iBAAsB,CAAC;AAClC,QAAI,KAAK,WAAW,GAAG,QAAQ;AAC/B,QAAI,KAAK,QAAQ;AACf,iBAAW;AACX,aAAOC,UAAY,QAAQ;AAC3B,eAAS;AAAA,IACX;AAAA,EACF;AAEA,cAAY,GAAG,IAAI;AACrB;AAEA,SAAS,iBAAiB,GAAG,OAAO,cAAc;AAChD,SAAOC,IAAM,OAAO,SAAU,MAAM;AAClC,WAAO,gBAAgB,GAAG,MAAM,YAAY;AAAA,EAC9C,CAAC;AACH;AAEA,SAAS,iBAAiB,aAAa,WAAW;AAChD,MAAI,KAAK,IAAI,MAAK;AAClBC,UAAU,aAAa,SAAU,IAAI;AACnC,QAAI,OAAO,GAAG,MAAK,EAAG;AACtB,QAAI,SAAS,aAAa,IAAI,MAAM,IAAI,SAAS;AACjDA,YAAU,OAAO,IAAI,SAAU,GAAG,GAAG;AACnC,SAAG,KAAK,CAAC,EAAE,QAAQ;AAAA,IACrB,CAAC;AACD,2BAAuB,IAAI,IAAI,OAAO,EAAE;AAAA,EAC1C,CAAC;AACH;AAEA,SAAS,YAAY,GAAG,UAAU;AAChCA,UAAU,UAAU,SAAU,OAAO;AACnCA,YAAU,OAAO,SAAU,GAAG,GAAG;AAC/B,QAAE,KAAK,CAAC,EAAE,QAAQ;AAAA,IACpB,CAAC;AAAA,EACH,CAAC;AACH;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,37 @@
+import filter from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.mjs";
+import max from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.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 sortBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/sortBy.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import has from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+function initOrder(g) {
+  var visited = {};
+  var simpleNodes = filter(g.nodes(), function(v) {
+    return !g.children(v).length;
+  });
+  var maxRank = max(
+    map(simpleNodes, function(v) {
+      return g.node(v).rank;
+    })
+  );
+  var layers = map(range(maxRank + 1), function() {
+    return [];
+  });
+  function dfs(v) {
+    if (has(visited, v)) return;
+    visited[v] = true;
+    var node = g.node(v);
+    layers[node.rank].push(v);
+    forEach(g.successors(v), dfs);
+  }
+  var orderedVs = sortBy(simpleNodes, function(v) {
+    return g.node(v).rank;
+  });
+  forEach(orderedVs, dfs);
+  return layers;
+}
+export {
+  initOrder
+};
+//# sourceMappingURL=init-order.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init-order.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/init-order.js"],"sourcesContent":["import * as _ from 'lodash-es';\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 */\nexport function initOrder(g) {\n  var visited = {};\n  var simpleNodes = _.filter(g.nodes(), function (v) {\n    return !g.children(v).length;\n  });\n  var maxRank = _.max(\n    _.map(simpleNodes, function (v) {\n      return g.node(v).rank;\n    }),\n  );\n  var layers = _.map(_.range(maxRank + 1), function () {\n    return [];\n  });\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) {\n    return g.node(v).rank;\n  });\n  _.forEach(orderedVs, dfs);\n\n  return layers;\n}\n"],"names":["_.filter","_.max","_.map","_.range","_.has","_.forEach","_.sortBy"],"mappings":";;;;;;;AAaO,SAAS,UAAU,GAAG;AAC3B,MAAI,UAAU,CAAA;AACd,MAAI,cAAcA,OAAS,EAAE,MAAK,GAAI,SAAU,GAAG;AACjD,WAAO,CAAC,EAAE,SAAS,CAAC,EAAE;AAAA,EACxB,CAAC;AACD,MAAI,UAAUC;AAAAA,IACZC,IAAM,aAAa,SAAU,GAAG;AAC9B,aAAO,EAAE,KAAK,CAAC,EAAE;AAAA,IACnB,CAAC;AAAA,EACL;AACE,MAAI,SAASA,IAAMC,MAAQ,UAAU,CAAC,GAAG,WAAY;AACnD,WAAO,CAAA;AAAA,EACT,CAAC;AAED,WAAS,IAAI,GAAG;AACd,QAAIC,IAAM,SAAS,CAAC,EAAG;AACvB,YAAQ,CAAC,IAAI;AACb,QAAI,OAAO,EAAE,KAAK,CAAC;AACnB,WAAO,KAAK,IAAI,EAAE,KAAK,CAAC;AACxBC,YAAU,EAAE,WAAW,CAAC,GAAG,GAAG;AAAA,EAChC;AAEA,MAAI,YAAYC,OAAS,aAAa,SAAU,GAAG;AACjD,WAAO,EAAE,KAAK,CAAC,EAAE;AAAA,EACnB,CAAC;AACDD,UAAU,WAAW,GAAG;AAExB,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.mjs

@@ -0,0 +1,89 @@
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import isUndefined from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+import filter from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.mjs";
+import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import pick from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pick.mjs";
+function resolveConflicts(entries, cg) {
+  var mappedEntries = {};
+  forEach(entries, function(entry, i) {
+    var tmp = mappedEntries[entry.v] = {
+      indegree: 0,
+      in: [],
+      out: [],
+      vs: [entry.v],
+      i
+    };
+    if (!isUndefined(entry.barycenter)) {
+      tmp.barycenter = entry.barycenter;
+      tmp.weight = entry.weight;
+    }
+  });
+  forEach(cg.edges(), function(e) {
+    var entryV = mappedEntries[e.v];
+    var entryW = mappedEntries[e.w];
+    if (!isUndefined(entryV) && !isUndefined(entryW)) {
+      entryW.indegree++;
+      entryV.out.push(mappedEntries[e.w]);
+    }
+  });
+  var sourceSet = filter(mappedEntries, function(entry) {
+    return !entry.indegree;
+  });
+  return doResolveConflicts(sourceSet);
+}
+function doResolveConflicts(sourceSet) {
+  var entries = [];
+  function handleIn(vEntry) {
+    return function(uEntry) {
+      if (uEntry.merged) {
+        return;
+      }
+      if (isUndefined(uEntry.barycenter) || isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) {
+        mergeEntries(vEntry, uEntry);
+      }
+    };
+  }
+  function handleOut(vEntry) {
+    return function(wEntry) {
+      wEntry["in"].push(vEntry);
+      if (--wEntry.indegree === 0) {
+        sourceSet.push(wEntry);
+      }
+    };
+  }
+  while (sourceSet.length) {
+    var entry = sourceSet.pop();
+    entries.push(entry);
+    forEach(entry["in"].reverse(), handleIn(entry));
+    forEach(entry.out, handleOut(entry));
+  }
+  return map(
+    filter(entries, function(entry2) {
+      return !entry2.merged;
+    }),
+    function(entry2) {
+      return pick(entry2, ["vs", "i", "barycenter", "weight"]);
+    }
+  );
+}
+function mergeEntries(target, source) {
+  var sum = 0;
+  var weight = 0;
+  if (target.weight) {
+    sum += target.barycenter * target.weight;
+    weight += target.weight;
+  }
+  if (source.weight) {
+    sum += source.barycenter * source.weight;
+    weight += source.weight;
+  }
+  target.vs = source.vs.concat(target.vs);
+  target.barycenter = sum / weight;
+  target.weight = weight;
+  target.i = Math.min(source.i, target.i);
+  source.merged = true;
+}
+export {
+  resolveConflicts
+};
+//# sourceMappingURL=resolve-conflicts.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-conflicts.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { 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      // @ts-expect-error\n      tmp.barycenter = entry.barycenter;\n      // @ts-expect-error\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    // @ts-expect-error\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 (\n        _.isUndefined(uEntry.barycenter) ||\n        _.isUndefined(vEntry.barycenter) ||\n        uEntry.barycenter >= vEntry.barycenter\n      ) {\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(\n    _.filter(entries, function (entry) {\n      return !entry.merged;\n    }),\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"],"names":["_.forEach","_.isUndefined","_.filter","_.map","entry","_.pick"],"mappings":";;;;;AA6BA,SAAS,iBAAiB,SAAS,IAAI;AACrC,MAAI,gBAAgB,CAAA;AACpBA,UAAU,SAAS,SAAU,OAAO,GAAG;AACrC,QAAI,MAAO,cAAc,MAAM,CAAC,IAAI;AAAA,MAClC,UAAU;AAAA,MACV,IAAI,CAAA;AAAA,MACJ,KAAK,CAAA;AAAA,MACL,IAAI,CAAC,MAAM,CAAC;AAAA,MACZ;AAAA,IACN;AACI,QAAI,CAACC,YAAc,MAAM,UAAU,GAAG;AAEpC,UAAI,aAAa,MAAM;AAEvB,UAAI,SAAS,MAAM;AAAA,IACrB;AAAA,EACF,CAAC;AAEDD,UAAU,GAAG,MAAK,GAAI,SAAU,GAAG;AACjC,QAAI,SAAS,cAAc,EAAE,CAAC;AAC9B,QAAI,SAAS,cAAc,EAAE,CAAC;AAC9B,QAAI,CAACC,YAAc,MAAM,KAAK,CAACA,YAAc,MAAM,GAAG;AACpD,aAAO;AACP,aAAO,IAAI,KAAK,cAAc,EAAE,CAAC,CAAC;AAAA,IACpC;AAAA,EACF,CAAC;AAED,MAAI,YAAYC,OAAS,eAAe,SAAU,OAAO;AAEvD,WAAO,CAAC,MAAM;AAAA,EAChB,CAAC;AAED,SAAO,mBAAmB,SAAS;AACrC;AAEA,SAAS,mBAAmB,WAAW;AACrC,MAAI,UAAU,CAAA;AAEd,WAAS,SAAS,QAAQ;AACxB,WAAO,SAAU,QAAQ;AACvB,UAAI,OAAO,QAAQ;AACjB;AAAA,MACF;AACA,UACED,YAAc,OAAO,UAAU,KAC/BA,YAAc,OAAO,UAAU,KAC/B,OAAO,cAAc,OAAO,YAC5B;AACA,qBAAa,QAAQ,MAAM;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAEA,WAAS,UAAU,QAAQ;AACzB,WAAO,SAAU,QAAQ;AACvB,aAAO,IAAI,EAAE,KAAK,MAAM;AACxB,UAAI,EAAE,OAAO,aAAa,GAAG;AAC3B,kBAAU,KAAK,MAAM;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,UAAU,QAAQ;AACvB,QAAI,QAAQ,UAAU,IAAG;AACzB,YAAQ,KAAK,KAAK;AAClBD,YAAU,MAAM,IAAI,EAAE,QAAO,GAAI,SAAS,KAAK,CAAC;AAChDA,YAAU,MAAM,KAAK,UAAU,KAAK,CAAC;AAAA,EACvC;AAEA,SAAOG;AAAAA,IACLD,OAAS,SAAS,SAAUE,QAAO;AACjC,aAAO,CAACA,OAAM;AAAA,IAChB,CAAC;AAAA,IACD,SAAUA,QAAO;AACf,aAAOC,KAAOD,QAAO,CAAC,MAAM,KAAK,cAAc,QAAQ,CAAC;AAAA,IAC1D;AAAA,EACJ;AACA;AAEA,SAAS,aAAa,QAAQ,QAAQ;AACpC,MAAI,MAAM;AACV,MAAI,SAAS;AAEb,MAAI,OAAO,QAAQ;AACjB,WAAO,OAAO,aAAa,OAAO;AAClC,cAAU,OAAO;AAAA,EACnB;AAEA,MAAI,OAAO,QAAQ;AACjB,WAAO,OAAO,aAAa,OAAO;AAClC,cAAU,OAAO;AAAA,EACnB;AAEA,SAAO,KAAK,OAAO,GAAG,OAAO,OAAO,EAAE;AACtC,SAAO,aAAa,MAAM;AAC1B,SAAO,SAAS;AAChB,SAAO,IAAI,KAAK,IAAI,OAAO,GAAG,OAAO,CAAC;AACtC,SAAO,SAAS;AAClB;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.mjs

@@ -0,0 +1,70 @@
+import { barycenter } from "./barycenter.mjs";
+import { resolveConflicts } from "./resolve-conflicts.mjs";
+import { sort } from "./sort.mjs";
+import filter from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import flatten from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import isUndefined from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+function sortSubgraph(g, v, cg, biasRight) {
+  var movable = g.children(v);
+  var node = g.node(v);
+  var bl = node ? node.borderLeft : void 0;
+  var br = node ? node.borderRight : void 0;
+  var subgraphs = {};
+  if (bl) {
+    movable = filter(movable, function(w) {
+      return w !== bl && w !== br;
+    });
+  }
+  var barycenters = barycenter(g, movable);
+  forEach(barycenters, function(entry) {
+    if (g.children(entry.v).length) {
+      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+      subgraphs[entry.v] = subgraphResult;
+      if (Object.prototype.hasOwnProperty.call(subgraphResult, "barycenter")) {
+        mergeBarycenters(entry, subgraphResult);
+      }
+    }
+  });
+  var entries = resolveConflicts(barycenters, cg);
+  expandSubgraphs(entries, subgraphs);
+  var result = sort(entries, biasRight);
+  if (bl) {
+    result.vs = flatten([bl, result.vs, br]);
+    if (g.predecessors(bl).length) {
+      var blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
+      if (!Object.prototype.hasOwnProperty.call(result, "barycenter")) {
+        result.barycenter = 0;
+        result.weight = 0;
+      }
+      result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+      result.weight += 2;
+    }
+  }
+  return result;
+}
+function expandSubgraphs(entries, subgraphs) {
+  forEach(entries, function(entry) {
+    entry.vs = flatten(
+      entry.vs.map(function(v) {
+        if (subgraphs[v]) {
+          return subgraphs[v].vs;
+        }
+        return v;
+      })
+    );
+  });
+}
+function mergeBarycenters(target, other) {
+  if (!isUndefined(target.barycenter)) {
+    target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+    target.weight += other.weight;
+  } else {
+    target.barycenter = other.barycenter;
+    target.weight = other.weight;
+  }
+}
+export {
+  sortSubgraph
+};
+//# sourceMappingURL=sort-subgraph.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-subgraph.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { barycenter } from './barycenter.js';\nimport { resolveConflicts } from './resolve-conflicts.js';\nimport { sort } from './sort.js';\n\nexport { 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 (Object.prototype.hasOwnProperty.call(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]);\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 (!Object.prototype.hasOwnProperty.call(result, 'barycenter')) {\n        result.barycenter = 0;\n        result.weight = 0;\n      }\n      result.barycenter =\n        (result.barycenter * result.weight + 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(\n      entry.vs.map(function (v) {\n        if (subgraphs[v]) {\n          return subgraphs[v].vs;\n        }\n        return v;\n      }),\n    );\n  });\n}\n\nfunction mergeBarycenters(target, other) {\n  if (!_.isUndefined(target.barycenter)) {\n    target.barycenter =\n      (target.barycenter * target.weight + 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"],"names":["_.filter","_.forEach","_.flatten","_.isUndefined"],"mappings":";;;;;;;AAOA,SAAS,aAAa,GAAG,GAAG,IAAI,WAAW;AACzC,MAAI,UAAU,EAAE,SAAS,CAAC;AAC1B,MAAI,OAAO,EAAE,KAAK,CAAC;AACnB,MAAI,KAAK,OAAO,KAAK,aAAa;AAClC,MAAI,KAAK,OAAO,KAAK,cAAc;AACnC,MAAI,YAAY,CAAA;AAEhB,MAAI,IAAI;AACN,cAAUA,OAAS,SAAS,SAAU,GAAG;AACvC,aAAO,MAAM,MAAM,MAAM;AAAA,IAC3B,CAAC;AAAA,EACH;AAEA,MAAI,cAAc,WAAW,GAAG,OAAO;AACvCC,UAAU,aAAa,SAAU,OAAO;AACtC,QAAI,EAAE,SAAS,MAAM,CAAC,EAAE,QAAQ;AAC9B,UAAI,iBAAiB,aAAa,GAAG,MAAM,GAAG,IAAI,SAAS;AAC3D,gBAAU,MAAM,CAAC,IAAI;AACrB,UAAI,OAAO,UAAU,eAAe,KAAK,gBAAgB,YAAY,GAAG;AACtE,yBAAiB,OAAO,cAAc;AAAA,MACxC;AAAA,IACF;AAAA,EACF,CAAC;AAED,MAAI,UAAU,iBAAiB,aAAa,EAAE;AAC9C,kBAAgB,SAAS,SAAS;AAElC,MAAI,SAAS,KAAK,SAAS,SAAS;AAEpC,MAAI,IAAI;AACN,WAAO,KAAKC,QAAU,CAAC,IAAI,OAAO,IAAI,EAAE,CAAC;AACzC,QAAI,EAAE,aAAa,EAAE,EAAE,QAAQ;AAC7B,UAAI,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC,GACvC,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AACvC,UAAI,CAAC,OAAO,UAAU,eAAe,KAAK,QAAQ,YAAY,GAAG;AAC/D,eAAO,aAAa;AACpB,eAAO,SAAS;AAAA,MAClB;AACA,aAAO,cACJ,OAAO,aAAa,OAAO,SAAS,OAAO,QAAQ,OAAO,UAAU,OAAO,SAAS;AACvF,aAAO,UAAU;AAAA,IACnB;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,gBAAgB,SAAS,WAAW;AAC3CD,UAAU,SAAS,SAAU,OAAO;AAClC,UAAM,KAAKC;AAAAA,MACT,MAAM,GAAG,IAAI,SAAU,GAAG;AACxB,YAAI,UAAU,CAAC,GAAG;AAChB,iBAAO,UAAU,CAAC,EAAE;AAAA,QACtB;AACA,eAAO;AAAA,MACT,CAAC;AAAA,IACP;AAAA,EACE,CAAC;AACH;AAEA,SAAS,iBAAiB,QAAQ,OAAO;AACvC,MAAI,CAACC,YAAc,OAAO,UAAU,GAAG;AACrC,WAAO,cACJ,OAAO,aAAa,OAAO,SAAS,MAAM,aAAa,MAAM,WAC7D,OAAO,SAAS,MAAM;AACzB,WAAO,UAAU,MAAM;AAAA,EACzB,OAAO;AACL,WAAO,aAAa,MAAM;AAC1B,WAAO,SAAS,MAAM;AAAA,EACxB;AACF;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,51 @@
+import { partition } from "../util.mjs";
+import sortBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/sortBy.mjs";
+import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import flatten from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import last from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs";
+function sort(entries, biasRight) {
+  var parts = partition(entries, function(entry) {
+    return Object.prototype.hasOwnProperty.call(entry, "barycenter");
+  });
+  var sortable = parts.lhs, unsortable = sortBy(parts.rhs, function(entry) {
+    return -entry.i;
+  }), vs = [], sum = 0, weight = 0, vsIndex = 0;
+  sortable.sort(compareWithBias(!!biasRight));
+  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+  forEach(sortable, function(entry) {
+    vsIndex += entry.vs.length;
+    vs.push(entry.vs);
+    sum += entry.barycenter * entry.weight;
+    weight += entry.weight;
+    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+  });
+  var result = { vs: flatten(vs) };
+  if (weight) {
+    result.barycenter = sum / weight;
+    result.weight = weight;
+  }
+  return result;
+}
+function consumeUnsortable(vs, unsortable, index) {
+  var last$1;
+  while (unsortable.length && (last$1 = last(unsortable)).i <= index) {
+    unsortable.pop();
+    vs.push(last$1.vs);
+    index++;
+  }
+  return index;
+}
+function compareWithBias(bias) {
+  return function(entryV, entryW) {
+    if (entryV.barycenter < entryW.barycenter) {
+      return -1;
+    } else if (entryV.barycenter > entryW.barycenter) {
+      return 1;
+    }
+    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+  };
+}
+export {
+  sort
+};
+//# sourceMappingURL=sort.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport * as util from '../util.js';\n\nexport { sort };\n\nfunction sort(entries, biasRight) {\n  var parts = util.partition(entries, function (entry) {\n    return Object.prototype.hasOwnProperty.call(entry, 'barycenter');\n  });\n  var sortable = parts.lhs,\n    unsortable = _.sortBy(parts.rhs, function (entry) {\n      return -entry.i;\n    }),\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) };\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"],"names":["util.partition","_.sortBy","_.forEach","_.flatten","last","_.last"],"mappings":";;;;;AAKA,SAAS,KAAK,SAAS,WAAW;AAChC,MAAI,QAAQA,UAAe,SAAS,SAAU,OAAO;AACnD,WAAO,OAAO,UAAU,eAAe,KAAK,OAAO,YAAY;AAAA,EACjE,CAAC;AACD,MAAI,WAAW,MAAM,KACnB,aAAaC,OAAS,MAAM,KAAK,SAAU,OAAO;AAChD,WAAO,CAAC,MAAM;AAAA,EAChB,CAAC,GACD,KAAK,CAAA,GACL,MAAM,GACN,SAAS,GACT,UAAU;AAEZ,WAAS,KAAK,gBAAgB,CAAC,CAAC,SAAS,CAAC;AAE1C,YAAU,kBAAkB,IAAI,YAAY,OAAO;AAEnDC,UAAU,UAAU,SAAU,OAAO;AACnC,eAAW,MAAM,GAAG;AACpB,OAAG,KAAK,MAAM,EAAE;AAChB,WAAO,MAAM,aAAa,MAAM;AAChC,cAAU,MAAM;AAChB,cAAU,kBAAkB,IAAI,YAAY,OAAO;AAAA,EACrD,CAAC;AAED,MAAI,SAAS,EAAE,IAAIC,QAAU,EAAE,EAAC;AAChC,MAAI,QAAQ;AACV,WAAO,aAAa,MAAM;AAC1B,WAAO,SAAS;AAAA,EAClB;AACA,SAAO;AACT;AAEA,SAAS,kBAAkB,IAAI,YAAY,OAAO;AAChD,MAAIC;AACJ,SAAO,WAAW,WAAWA,SAAOC,KAAO,UAAU,GAAG,KAAK,OAAO;AAClE,eAAW,IAAG;AACd,OAAG,KAAKD,OAAK,EAAE;AACf;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,gBAAgB,MAAM;AAC7B,SAAO,SAAU,QAAQ,QAAQ;AAC/B,QAAI,OAAO,aAAa,OAAO,YAAY;AACzC,aAAO;AAAA,IACT,WAAW,OAAO,aAAa,OAAO,YAAY;AAChD,aAAO;AAAA,IACT;AAEA,WAAO,CAAC,OAAO,OAAO,IAAI,OAAO,IAAI,OAAO,IAAI,OAAO;AAAA,EACzD;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.mjs

@@ -0,0 +1,67 @@
+import forEach from "../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+function parentDummyChains(g) {
+  var postorderNums = postorder(g);
+  forEach(g.graph().dummyChains, function(v) {
+    var node = g.node(v);
+    var edgeObj = node.edgeObj;
+    var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+    var path = pathData.path;
+    var lca = pathData.lca;
+    var pathIdx = 0;
+    var pathV = path[pathIdx];
+    var ascending = true;
+    while (v !== edgeObj.w) {
+      node = g.node(v);
+      if (ascending) {
+        while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+          pathIdx++;
+        }
+        if (pathV === lca) {
+          ascending = false;
+        }
+      }
+      if (!ascending) {
+        while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
+          pathIdx++;
+        }
+        pathV = path[pathIdx];
+      }
+      g.setParent(v, pathV);
+      v = g.successors(v)[0];
+    }
+  });
+}
+function findPath(g, postorderNums, v, w) {
+  var vPath = [];
+  var wPath = [];
+  var low = Math.min(postorderNums[v].low, postorderNums[w].low);
+  var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+  var parent;
+  var lca;
+  parent = v;
+  do {
+    parent = g.parent(parent);
+    vPath.push(parent);
+  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+  lca = parent;
+  parent = w;
+  while ((parent = g.parent(parent)) !== lca) {
+    wPath.push(parent);
+  }
+  return { path: vPath.concat(wPath.reverse()), lca };
+}
+function postorder(g) {
+  var result = {};
+  var lim = 0;
+  function dfs(v) {
+    var low = lim;
+    forEach(g.children(v), dfs);
+    result[v] = { low, lim: lim++ };
+  }
+  forEach(g.children(), dfs);
+  return result;
+}
+export {
+  parentDummyChains
+};
+//# sourceMappingURL=parent-dummy-chains.mjs.map

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-dummy-chains.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js"],"sourcesContent":["import * as _ from 'lodash-es';\n\nexport { 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 && 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 (\n          pathIdx < path.length - 1 &&\n          g.node((pathV = path[pathIdx + 1])).minRank <= node.rank\n        ) {\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 && (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"],"names":["_.forEach"],"mappings":";AAIA,SAAS,kBAAkB,GAAG;AAC5B,MAAI,gBAAgB,UAAU,CAAC;AAE/BA,UAAU,EAAE,MAAK,EAAG,aAAa,SAAU,GAAG;AAC5C,QAAI,OAAO,EAAE,KAAK,CAAC;AACnB,QAAI,UAAU,KAAK;AACnB,QAAI,WAAW,SAAS,GAAG,eAAe,QAAQ,GAAG,QAAQ,CAAC;AAC9D,QAAI,OAAO,SAAS;AACpB,QAAI,MAAM,SAAS;AACnB,QAAI,UAAU;AACd,QAAI,QAAQ,KAAK,OAAO;AACxB,QAAI,YAAY;AAEhB,WAAO,MAAM,QAAQ,GAAG;AACtB,aAAO,EAAE,KAAK,CAAC;AAEf,UAAI,WAAW;AACb,gBAAQ,QAAQ,KAAK,OAAO,OAAO,OAAO,EAAE,KAAK,KAAK,EAAE,UAAU,KAAK,MAAM;AAC3E;AAAA,QACF;AAEA,YAAI,UAAU,KAAK;AACjB,sBAAY;AAAA,QACd;AAAA,MACF;AAEA,UAAI,CAAC,WAAW;AACd,eACE,UAAU,KAAK,SAAS,KACxB,EAAE,KAAM,QAAQ,KAAK,UAAU,CAAC,CAAC,EAAG,WAAW,KAAK,MACpD;AACA;AAAA,QACF;AACA,gBAAQ,KAAK,OAAO;AAAA,MACtB;AAEA,QAAE,UAAU,GAAG,KAAK;AACpB,UAAI,EAAE,WAAW,CAAC,EAAE,CAAC;AAAA,IACvB;AAAA,EACF,CAAC;AACH;AAIA,SAAS,SAAS,GAAG,eAAe,GAAG,GAAG;AACxC,MAAI,QAAQ,CAAA;AACZ,MAAI,QAAQ,CAAA;AACZ,MAAI,MAAM,KAAK,IAAI,cAAc,CAAC,EAAE,KAAK,cAAc,CAAC,EAAE,GAAG;AAC7D,MAAI,MAAM,KAAK,IAAI,cAAc,CAAC,EAAE,KAAK,cAAc,CAAC,EAAE,GAAG;AAC7D,MAAI;AACJ,MAAI;AAGJ,WAAS;AACT,KAAG;AACD,aAAS,EAAE,OAAO,MAAM;AACxB,UAAM,KAAK,MAAM;AAAA,EACnB,SAAS,WAAW,cAAc,MAAM,EAAE,MAAM,OAAO,MAAM,cAAc,MAAM,EAAE;AACnF,QAAM;AAGN,WAAS;AACT,UAAQ,SAAS,EAAE,OAAO,MAAM,OAAO,KAAK;AAC1C,UAAM,KAAK,MAAM;AAAA,EACnB;AAEA,SAAO,EAAE,MAAM,MAAM,OAAO,MAAM,QAAO,CAAE,GAAG,IAAQ;AACxD;AAEA,SAAS,UAAU,GAAG;AACpB,MAAI,SAAS,CAAA;AACb,MAAI,MAAM;AAEV,WAAS,IAAI,GAAG;AACd,QAAI,MAAM;AACVA,YAAU,EAAE,SAAS,CAAC,GAAG,GAAG;AAC5B,WAAO,CAAC,IAAI,EAAE,KAAU,KAAK,MAAK;AAAA,EACpC;AACAA,UAAU,EAAE,SAAQ,GAAI,GAAG;AAE3B,SAAO;AACT;","x_google_ignoreList":[0]}