qidian-vue-ui 1.1.55 → 1.1.57

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

@@ -1,320 +0,0 @@
-import { Graph } from "../../graphlib/graph.mjs";
-import { buildLayerMatrix } from "../util.mjs";
-import merge from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/merge.mjs";
-import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
-import reduce from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs";
-import minBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/minBy.mjs";
-import values from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
-import min from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/min.mjs";
-import max from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.mjs";
-import mapValues from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/mapValues.mjs";
-import sortBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/sortBy.mjs";
-import map from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
-import forIn from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forIn.mjs";
-import last from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs";
-import find from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/find.mjs";
-import range from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/range.mjs";
-function findType1Conflicts(g, layering) {
-  var conflicts = {};
-  function visitLayer(prevLayer, layer) {
-    var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = last(layer);
-    forEach(layer, function(v, i) {
-      var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
-      if (w || v === lastNode) {
-        forEach(layer.slice(scanPos, i + 1), function(scanNode) {
-          forEach(g.predecessors(scanNode), function(u) {
-            var uLabel = g.node(u), uPos = uLabel.order;
-            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
-              addConflict(conflicts, u, scanNode);
-            }
-          });
-        });
-        scanPos = i + 1;
-        k0 = k1;
-      }
-    });
-    return layer;
-  }
-  reduce(layering, visitLayer);
-  return conflicts;
-}
-function findType2Conflicts(g, layering) {
-  var conflicts = {};
-  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
-    var v;
-    forEach(range(southPos, southEnd), function(i) {
-      v = south[i];
-      if (g.node(v).dummy) {
-        forEach(g.predecessors(v), function(u) {
-          var uNode = g.node(u);
-          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
-            addConflict(conflicts, u, v);
-          }
-        });
-      }
-    });
-  }
-  function visitLayer(north, south) {
-    var prevNorthPos = -1, nextNorthPos, southPos = 0;
-    forEach(south, function(v, southLookahead) {
-      if (g.node(v).dummy === "border") {
-        var predecessors = g.predecessors(v);
-        if (predecessors.length) {
-          nextNorthPos = g.node(predecessors[0]).order;
-          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
-          southPos = southLookahead;
-          prevNorthPos = nextNorthPos;
-        }
-      }
-      scan(south, southPos, south.length, nextNorthPos, north.length);
-    });
-    return south;
-  }
-  reduce(layering, visitLayer);
-  return conflicts;
-}
-function findOtherInnerSegmentNode(g, v) {
-  if (g.node(v).dummy) {
-    return find(g.predecessors(v), function(u) {
-      return g.node(u).dummy;
-    });
-  }
-}
-function addConflict(conflicts, v, w) {
-  if (v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
-  }
-  if (!Object.prototype.hasOwnProperty.call(conflicts, v)) {
-    Object.defineProperty(conflicts, v, {
-      enumerable: true,
-      configurable: true,
-      value: {},
-      writable: true
-    });
-  }
-  var conflictsV = conflicts[v];
-  Object.defineProperty(conflictsV, w, {
-    enumerable: true,
-    configurable: true,
-    value: true,
-    writable: true
-  });
-}
-function hasConflict(conflicts, v, w) {
-  if (v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
-  }
-  return !!conflicts[v] && Object.prototype.hasOwnProperty.call(conflicts[v], w);
-}
-function verticalAlignment(g, layering, conflicts, neighborFn) {
-  var root = {}, align = {}, pos = {};
-  forEach(layering, function(layer) {
-    forEach(layer, function(v, order) {
-      root[v] = v;
-      align[v] = v;
-      pos[v] = order;
-    });
-  });
-  forEach(layering, function(layer) {
-    var prevIdx = -1;
-    forEach(layer, function(v) {
-      var ws = neighborFn(v);
-      if (ws.length) {
-        ws = sortBy(ws, function(w2) {
-          return pos[w2];
-        });
-        var mp = (ws.length - 1) / 2;
-        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
-          var w = ws[i];
-          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
-            align[w] = v;
-            align[v] = root[v] = root[w];
-            prevIdx = pos[w];
-          }
-        }
-      }
-    });
-  });
-  return { root, align };
-}
-function horizontalCompaction(g, layering, root, align, reverseSep) {
-  var xs = {}, blockG = buildBlockGraph(g, layering, root, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
-  function iterate(setXsFunc, nextNodesFunc) {
-    var stack = blockG.nodes();
-    var elem = stack.pop();
-    var visited = {};
-    while (elem) {
-      if (visited[elem]) {
-        setXsFunc(elem);
-      } else {
-        visited[elem] = true;
-        stack.push(elem);
-        stack = stack.concat(nextNodesFunc(elem));
-      }
-      elem = stack.pop();
-    }
-  }
-  function pass1(elem) {
-    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
-      return Math.max(acc, xs[e.v] + blockG.edge(e));
-    }, 0);
-  }
-  function pass2(elem) {
-    var min2 = blockG.outEdges(elem).reduce(function(acc, e) {
-      return Math.min(acc, xs[e.w] - blockG.edge(e));
-    }, Number.POSITIVE_INFINITY);
-    var node = g.node(elem);
-    if (min2 !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
-      xs[elem] = Math.max(xs[elem], min2);
-    }
-  }
-  iterate(pass1, blockG.predecessors.bind(blockG));
-  iterate(pass2, blockG.successors.bind(blockG));
-  forEach(align, function(v) {
-    xs[v] = xs[root[v]];
-  });
-  return xs;
-}
-function buildBlockGraph(g, layering, root, reverseSep) {
-  var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
-  forEach(layering, function(layer) {
-    var u;
-    forEach(layer, function(v) {
-      var vRoot = root[v];
-      blockGraph.setNode(vRoot);
-      if (u) {
-        var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
-        blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
-      }
-      u = v;
-    });
-  });
-  return blockGraph;
-}
-function findSmallestWidthAlignment(g, xss) {
-  return minBy(values(xss), function(xs) {
-    var max2 = Number.NEGATIVE_INFINITY;
-    var min2 = Number.POSITIVE_INFINITY;
-    forIn(xs, function(x, v) {
-      var halfWidth = width(g, v) / 2;
-      max2 = Math.max(x + halfWidth, max2);
-      min2 = Math.min(x - halfWidth, min2);
-    });
-    return max2 - min2;
-  });
-}
-function alignCoordinates(xss, alignTo) {
-  var alignToVals = values(alignTo), alignToMin = min(alignToVals), alignToMax = max(alignToVals);
-  forEach(["u", "d"], function(vert) {
-    forEach(["l", "r"], function(horiz) {
-      var alignment = vert + horiz, xs = xss[alignment], delta;
-      if (xs === alignTo) return;
-      var xsVals = values(xs);
-      delta = horiz === "l" ? alignToMin - min(xsVals) : alignToMax - max(xsVals);
-      if (delta) {
-        xss[alignment] = mapValues(xs, function(x) {
-          return x + delta;
-        });
-      }
-    });
-  });
-}
-function balance(xss, align) {
-  return mapValues(xss.ul, function(ignore, v) {
-    if (align) {
-      return xss[align.toLowerCase()][v];
-    } else {
-      var xs = sortBy(map(xss, v));
-      return (xs[1] + xs[2]) / 2;
-    }
-  });
-}
-function positionX(g) {
-  var layering = buildLayerMatrix(g);
-  var conflicts = merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
-  var xss = {};
-  var adjustedLayering;
-  forEach(["u", "d"], function(vert) {
-    adjustedLayering = vert === "u" ? layering : values(layering).reverse();
-    forEach(["l", "r"], function(horiz) {
-      if (horiz === "r") {
-        adjustedLayering = map(adjustedLayering, function(inner) {
-          return values(inner).reverse();
-        });
-      }
-      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
-      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
-      var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
-      if (horiz === "r") {
-        xs = mapValues(xs, function(x) {
-          return -x;
-        });
-      }
-      xss[vert + horiz] = xs;
-    });
-  });
-  var smallestWidth = findSmallestWidthAlignment(g, xss);
-  alignCoordinates(xss, smallestWidth);
-  return balance(xss, g.graph().align);
-}
-function sep(nodeSep, edgeSep, reverseSep) {
-  return function(g, v, w) {
-    var vLabel = g.node(v);
-    var wLabel = g.node(w);
-    var sum = 0;
-    var delta;
-    sum += vLabel.width / 2;
-    if (Object.prototype.hasOwnProperty.call(vLabel, "labelpos")) {
-      switch (vLabel.labelpos.toLowerCase()) {
-        case "l":
-          delta = -vLabel.width / 2;
-          break;
-        case "r":
-          delta = vLabel.width / 2;
-          break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
-    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
-    sum += wLabel.width / 2;
-    if (Object.prototype.hasOwnProperty.call(wLabel, "labelpos")) {
-      switch (wLabel.labelpos.toLowerCase()) {
-        case "l":
-          delta = wLabel.width / 2;
-          break;
-        case "r":
-          delta = -wLabel.width / 2;
-          break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-    return sum;
-  };
-}
-function width(g, v) {
-  return g.node(v).width;
-}
-export {
-  addConflict,
-  alignCoordinates,
-  balance,
-  findSmallestWidthAlignment,
-  findType1Conflicts,
-  findType2Conflicts,
-  hasConflict,
-  horizontalCompaction,
-  positionX,
-  verticalAlignment
-};
-//# sourceMappingURL=bk.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"bk.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/bk.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { Graph } from '../../graphlib/index.js';\nimport * as util from '../util.js';\n\n/*\n * This module provides coordinate assignment based on Brandes and Köpf, \"Fast\n * and Simple Horizontal Coordinate Assignment.\"\n */\n\nexport {\n  positionX,\n  findType1Conflicts,\n  findType2Conflicts,\n  addConflict,\n  hasConflict,\n  verticalAlignment,\n  horizontalCompaction,\n  alignCoordinates,\n  findSmallestWidthAlignment,\n  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  /** @type {{[nodeId: string | number]: {[nodeId: string | number]: true}}} */\n  var conflicts = {};\n\n  function visitLayer(prevLayer, layer) {\n    var // 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) && !(uLabel.dummy && g.node(scanNode).dummy)) {\n              addConflict(conflicts, u, scanNode);\n            }\n          });\n        });\n        // @ts-expect-error\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  /** @type {{[nodeId: string | number]: {[nodeId: string | number]: true}}} */\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 && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {\n            addConflict(conflicts, u, v);\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          // @ts-expect-error\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\n/**\n * Sets `conflicts[v][w] = true`, creating objects if needed.\n *\n * @param {{[nodeId: string | number]: {[nodeId: string | number]: true}}} conflicts - Object to set.\n * @param {string | number} v - First Node ID\n * @param {string | number} w - Second Node ID\n */\nfunction addConflict(conflicts, v, w) {\n  if (v > w) {\n    var tmp = v;\n    v = w;\n    w = tmp;\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(conflicts, v)) {\n    // can't use conflicts[v] = {} since it's unsafe if v = `__proto__`\n    Object.defineProperty(conflicts, v, {\n      enumerable: true,\n      configurable: true,\n      value: {},\n      writable: true,\n    });\n  }\n  var conflictsV = conflicts[v];\n  Object.defineProperty(conflictsV, w, {\n    enumerable: true,\n    configurable: true,\n    value: true,\n    writable: true,\n  });\n}\n\nfunction hasConflict(conflicts, v, w) {\n  if (v > w) {\n    var tmp = v;\n    v = w;\n    w = tmp;\n  }\n  return !!conflicts[v] && Object.prototype.hasOwnProperty.call(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) {\n          return pos[w];\n        });\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 && prevIdx < pos[w] && !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\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) {\n          return x + delta;\n        });\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(findType1Conflicts(g, layering), 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, align.root, align.align, horiz === 'r');\n      if (horiz === 'r') {\n        xs = _.mapValues(xs, function (x) {\n          return -x;\n        });\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 (Object.prototype.hasOwnProperty.call(vLabel, 'labelpos')) {\n      switch (vLabel.labelpos.toLowerCase()) {\n        case 'l':\n          delta = -vLabel.width / 2;\n          break;\n        case 'r':\n          delta = vLabel.width / 2;\n          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 (Object.prototype.hasOwnProperty.call(wLabel, 'labelpos')) {\n      switch (wLabel.labelpos.toLowerCase()) {\n        case 'l':\n          delta = wLabel.width / 2;\n          break;\n        case 'r':\n          delta = -wLabel.width / 2;\n          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"],"names":["_.last","_.forEach","_.reduce","_.range","_.find","_.sortBy","w","min","_.minBy","_.values","max","_.forIn","_.min","_.max","_.mapValues","_.map","util.buildLayerMatrix","_.merge"],"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/position/index.mjs

@@ -1,33 +0,0 @@
-import { asNonCompoundGraph, buildLayerMatrix } from "../util.mjs";
-import { positionX } from "./bk.mjs";
-import forOwn from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forOwn.mjs";
-import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.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";
-function position(g) {
-  g = asNonCompoundGraph(g);
-  positionY(g);
-  forOwn(positionX(g), function(x, v) {
-    g.node(v).x = x;
-  });
-}
-function positionY(g) {
-  var layering = buildLayerMatrix(g);
-  var rankSep = g.graph().ranksep;
-  var prevY = 0;
-  forEach(layering, function(layer) {
-    var maxHeight = max(
-      map(layer, function(v) {
-        return g.node(v).height;
-      })
-    );
-    forEach(layer, function(v) {
-      g.node(v).y = prevY + maxHeight / 2;
-    });
-    prevY += maxHeight + rankSep;
-  });
-}
-export {
-  position
-};
-//# sourceMappingURL=index.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/index.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport * as util from '../util.js';\nimport { positionX } from './bk.js';\n\nexport { position };\n\nfunction position(g) {\n  g = util.asNonCompoundGraph(g);\n\n  positionY(g);\n  _.forOwn(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(\n      _.map(layer, function (v) {\n        return g.node(v).height;\n      }),\n    );\n    _.forEach(layer, function (v) {\n      g.node(v).y = prevY + maxHeight / 2;\n    });\n    prevY += maxHeight + rankSep;\n  });\n}\n"],"names":["util.asNonCompoundGraph","_.forOwn","util.buildLayerMatrix","_.forEach","_.max","_.map"],"mappings":";;;;;;AAMA,SAAS,SAAS,GAAG;AACnB,MAAIA,mBAAwB,CAAC;AAE7B,YAAU,CAAC;AACXC,SAAS,UAAU,CAAC,GAAG,SAAU,GAAG,GAAG;AACrC,MAAE,KAAK,CAAC,EAAE,IAAI;AAAA,EAChB,CAAC;AACH;AAEA,SAAS,UAAU,GAAG;AACpB,MAAI,WAAWC,iBAAsB,CAAC;AACtC,MAAI,UAAU,EAAE,MAAK,EAAG;AACxB,MAAI,QAAQ;AACZC,UAAU,UAAU,SAAU,OAAO;AACnC,QAAI,YAAYC;AAAAA,MACdC,IAAM,OAAO,SAAU,GAAG;AACxB,eAAO,EAAE,KAAK,CAAC,EAAE;AAAA,MACnB,CAAC;AAAA,IACP;AACIF,YAAU,OAAO,SAAU,GAAG;AAC5B,QAAE,KAAK,CAAC,EAAE,IAAI,QAAQ,YAAY;AAAA,IACpC,CAAC;AACD,aAAS,YAAY;AAAA,EACvB,CAAC;AACH;","x_google_ignoreList":[0]}

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

@@ -1,47 +0,0 @@
-import { Graph } from "../../graphlib/graph.mjs";
-import { slack } from "./util.mjs";
-import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
-import minBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/minBy.mjs";
-function feasibleTree(g) {
-  var t = new Graph({ directed: false });
-  var start = g.nodes()[0];
-  var size = g.nodeCount();
-  t.setNode(start, {});
-  var edge, delta;
-  while (tightTree(t, g) < size) {
-    edge = findMinSlackEdge(t, g);
-    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
-    shiftRanks(t, g, delta);
-  }
-  return t;
-}
-function tightTree(t, g) {
-  function dfs(v) {
-    forEach(g.nodeEdges(v), function(e) {
-      var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
-      if (!t.hasNode(w) && !slack(g, e)) {
-        t.setNode(w, {});
-        t.setEdge(v, w, {});
-        dfs(w);
-      }
-    });
-  }
-  forEach(t.nodes(), dfs);
-  return t.nodeCount();
-}
-function findMinSlackEdge(t, g) {
-  return minBy(g.edges(), function(e) {
-    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
-      return slack(g, e);
-    }
-  });
-}
-function shiftRanks(t, g, delta) {
-  forEach(t.nodes(), function(v) {
-    g.node(v).rank += delta;
-  });
-}
-export {
-  feasibleTree
-};
-//# sourceMappingURL=feasible-tree.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"feasible-tree.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js"],"sourcesContent":["import * as _ from 'lodash-es';\nimport { Graph } from '../../graphlib/index.js';\nimport { slack } from './util.js';\n\nexport { 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"],"names":["_.forEach","_.minBy"],"mappings":";;;;AA+BA,SAAS,aAAa,GAAG;AACvB,MAAI,IAAI,IAAI,MAAM,EAAE,UAAU,MAAK,CAAE;AAGrC,MAAI,QAAQ,EAAE,MAAK,EAAG,CAAC;AACvB,MAAI,OAAO,EAAE,UAAS;AACtB,IAAE,QAAQ,OAAO,EAAE;AAEnB,MAAI,MAAM;AACV,SAAO,UAAU,GAAG,CAAC,IAAI,MAAM;AAC7B,WAAO,iBAAiB,GAAG,CAAC;AAC5B,YAAQ,EAAE,QAAQ,KAAK,CAAC,IAAI,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI;AAC3D,eAAW,GAAG,GAAG,KAAK;AAAA,EACxB;AAEA,SAAO;AACT;AAMA,SAAS,UAAU,GAAG,GAAG;AACvB,WAAS,IAAI,GAAG;AACdA,YAAU,EAAE,UAAU,CAAC,GAAG,SAAU,GAAG;AACrC,UAAI,QAAQ,EAAE,GACZ,IAAI,MAAM,QAAQ,EAAE,IAAI;AAC1B,UAAI,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG;AACjC,UAAE,QAAQ,GAAG,EAAE;AACf,UAAE,QAAQ,GAAG,GAAG,CAAA,CAAE;AAClB,YAAI,CAAC;AAAA,MACP;AAAA,IACF,CAAC;AAAA,EACH;AAEAA,UAAU,EAAE,MAAK,GAAI,GAAG;AACxB,SAAO,EAAE,UAAS;AACpB;AAMA,SAAS,iBAAiB,GAAG,GAAG;AAC9B,SAAOC,MAAQ,EAAE,MAAK,GAAI,SAAU,GAAG;AACrC,QAAI,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG;AACrC,aAAO,MAAM,GAAG,CAAC;AAAA,IACnB;AAAA,EACF,CAAC;AACH;AAEA,SAAS,WAAW,GAAG,GAAG,OAAO;AAC/BD,UAAU,EAAE,MAAK,GAAI,SAAU,GAAG;AAChC,MAAE,KAAK,CAAC,EAAE,QAAQ;AAAA,EACpB,CAAC;AACH;","x_google_ignoreList":[0]}

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

@@ -1,30 +0,0 @@
-import { feasibleTree } from "./feasible-tree.mjs";
-import { networkSimplex } from "./network-simplex.mjs";
-import { longestPath } from "./util.mjs";
-function rank(g) {
-  switch (g.graph().ranker) {
-    case "network-simplex":
-      networkSimplexRanker(g);
-      break;
-    case "tight-tree":
-      tightTreeRanker(g);
-      break;
-    case "longest-path":
-      longestPathRanker(g);
-      break;
-    default:
-      networkSimplexRanker(g);
-  }
-}
-var longestPathRanker = longestPath;
-function tightTreeRanker(g) {
-  longestPath(g);
-  feasibleTree(g);
-}
-function networkSimplexRanker(g) {
-  networkSimplex(g);
-}
-export {
-  rank
-};
-//# sourceMappingURL=index.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":["../../../../../../../../../../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/index.js"],"sourcesContent":["import { feasibleTree } from './feasible-tree.js';\nimport { networkSimplex } from './network-simplex.js';\nimport { longestPath } from './util.js';\n\nexport { 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':\n      networkSimplexRanker(g);\n      break;\n    case 'tight-tree':\n      tightTreeRanker(g);\n      break;\n    case 'longest-path':\n      longestPathRanker(g);\n      break;\n    default:\n      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"],"names":[],"mappings":";;;AAyBA,SAAS,KAAK,GAAG;AACf,UAAQ,EAAE,MAAK,EAAG,QAAM;AAAA,IACtB,KAAK;AACH,2BAAqB,CAAC;AACtB;AAAA,IACF,KAAK;AACH,sBAAgB,CAAC;AACjB;AAAA,IACF,KAAK;AACH,wBAAkB,CAAC;AACnB;AAAA,IACF;AACE,2BAAqB,CAAC;AAAA,EAC5B;AACA;AAGA,IAAI,oBAAoB;AAExB,SAAS,gBAAgB,GAAG;AAC1B,cAAY,CAAC;AACb,eAAa,CAAC;AAChB;AAEA,SAAS,qBAAqB,GAAG;AAC/B,iBAAe,CAAC;AAClB;","x_google_ignoreList":[0]}

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

@@ -1,150 +0,0 @@
-import "../../graphlib/alg/topsort.mjs";
-import { postorder } from "../../graphlib/alg/postorder.mjs";
-import { preorder } from "../../graphlib/alg/preorder.mjs";
-import "../../graphlib/graph.mjs";
-import { simplify } from "../util.mjs";
-import { feasibleTree } from "./feasible-tree.mjs";
-import { longestPath, slack } from "./util.mjs";
-import forEach from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
-import find from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/find.mjs";
-import filter from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.mjs";
-import minBy from "../../../../../../lodash-es@4.17.21/node_modules/lodash-es/minBy.mjs";
-networkSimplex.initLowLimValues = initLowLimValues;
-networkSimplex.initCutValues = initCutValues;
-networkSimplex.calcCutValue = calcCutValue;
-networkSimplex.leaveEdge = leaveEdge;
-networkSimplex.enterEdge = enterEdge;
-networkSimplex.exchangeEdges = exchangeEdges;
-function networkSimplex(g) {
-  g = simplify(g);
-  longestPath(g);
-  var t = feasibleTree(g);
-  initLowLimValues(t);
-  initCutValues(t, g);
-  var e, f;
-  while (e = leaveEdge(t)) {
-    f = enterEdge(t, g, e);
-    exchangeEdges(t, g, e, f);
-  }
-}
-function initCutValues(t, g) {
-  var vs = postorder(t, t.nodes());
-  vs = vs.slice(0, vs.length - 1);
-  forEach(vs, function(v) {
-    assignCutValue(t, g, v);
-  });
-}
-function assignCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
-}
-function calcCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  var childIsTail = true;
-  var graphEdge = g.edge(child, parent);
-  var cutValue = 0;
-  if (!graphEdge) {
-    childIsTail = false;
-    graphEdge = g.edge(parent, child);
-  }
-  cutValue = graphEdge.weight;
-  forEach(g.nodeEdges(child), function(e) {
-    var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
-    if (other !== parent) {
-      var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
-      cutValue += pointsToHead ? otherWeight : -otherWeight;
-      if (isTreeEdge(t, child, other)) {
-        var otherCutValue = t.edge(child, other).cutvalue;
-        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
-      }
-    }
-  });
-  return cutValue;
-}
-function initLowLimValues(tree, root) {
-  if (arguments.length < 2) {
-    root = tree.nodes()[0];
-  }
-  dfsAssignLowLim(tree, {}, 1, root);
-}
-function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
-  var low = nextLim;
-  var label = tree.node(v);
-  visited[v] = true;
-  forEach(tree.neighbors(v), function(w) {
-    if (!Object.prototype.hasOwnProperty.call(visited, w)) {
-      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
-    }
-  });
-  label.low = low;
-  label.lim = nextLim++;
-  if (parent) {
-    label.parent = parent;
-  } else {
-    delete label.parent;
-  }
-  return nextLim;
-}
-function leaveEdge(tree) {
-  return find(tree.edges(), function(e) {
-    return tree.edge(e).cutvalue < 0;
-  });
-}
-function enterEdge(t, g, edge) {
-  var v = edge.v;
-  var w = edge.w;
-  if (!g.hasEdge(v, w)) {
-    v = edge.w;
-    w = edge.v;
-  }
-  var vLabel = t.node(v);
-  var wLabel = t.node(w);
-  var tailLabel = vLabel;
-  var flip = false;
-  if (vLabel.lim > wLabel.lim) {
-    tailLabel = wLabel;
-    flip = true;
-  }
-  var candidates = filter(g.edges(), function(edge2) {
-    return flip === isDescendant(t, t.node(edge2.v), tailLabel) && flip !== isDescendant(t, t.node(edge2.w), tailLabel);
-  });
-  return minBy(candidates, function(edge2) {
-    return slack(g, edge2);
-  });
-}
-function exchangeEdges(t, g, e, f) {
-  var v = e.v;
-  var w = e.w;
-  t.removeEdge(v, w);
-  t.setEdge(f.v, f.w, {});
-  initLowLimValues(t);
-  initCutValues(t, g);
-  updateRanks(t, g);
-}
-function updateRanks(t, g) {
-  var root = find(t.nodes(), function(v) {
-    return !g.node(v).parent;
-  });
-  var vs = preorder(t, root);
-  vs = vs.slice(1);
-  forEach(vs, function(v) {
-    var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
-    if (!edge) {
-      edge = g.edge(parent, v);
-      flipped = true;
-    }
-    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
-  });
-}
-function isTreeEdge(tree, u, v) {
-  return tree.hasEdge(u, v);
-}
-function isDescendant(tree, vLabel, rootLabel) {
-  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
-}
-export {
-  networkSimplex
-};
-//# sourceMappingURL=network-simplex.mjs.map