@seed-ship/mcp-ui-solid 5.7.0 → 6.0.0

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/node_modules/dagre/lib/position/bk.cjs

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lodash = require("../lodash.cjs");
+const graphlib = require("../graphlib.cjs");
+const util = require("../util.cjs");
+var bk;
+var hasRequiredBk;
+function requireBk() {
+  if (hasRequiredBk) return bk;
+  hasRequiredBk = 1;
+  var _ = lodash.__require();
+  var Graph = graphlib.__require().Graph;
+  var util$1 = util.__require();
+  bk = {
+    positionX,
+    findType1Conflicts,
+    findType2Conflicts,
+    addConflict,
+    hasConflict,
+    verticalAlignment,
+    horizontalCompaction,
+    alignCoordinates,
+    findSmallestWidthAlignment,
+    balance
+  };
+  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;
+    }
+    var conflictsV = conflicts[v];
+    if (!conflictsV) {
+      conflicts[v] = conflictsV = {};
+    }
+    conflictsV[w] = true;
+  }
+  function hasConflict(conflicts, v, w) {
+    if (v > w) {
+      var tmp = v;
+      v = w;
+      w = tmp;
+    }
+    return _.has(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 min = 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 (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+        xs[elem] = Math.max(xs[elem], min);
+      }
+    }
+    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 max = Number.NEGATIVE_INFINITY;
+      var min = Number.POSITIVE_INFINITY;
+      _.forIn(xs, function(x, v) {
+        var halfWidth = width(g, v) / 2;
+        max = Math.max(x + halfWidth, max);
+        min = Math.min(x - halfWidth, min);
+      });
+      return max - min;
+    });
+  }
+  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 = util$1.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 (_.has(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 (_.has(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;
+  }
+  return bk;
+}
+exports.__require = requireBk;
+//# sourceMappingURL=bk.cjs.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/node_modules/dagre/lib/position/bk.cjs.map

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

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/node_modules/dagre/lib/position/bk.js

@@ -0,0 +1,319 @@
+import { __require as requireLodash } from "../lodash.js";
+import { __require as requireGraphlib } from "../graphlib.js";
+import { __require as requireUtil$1 } from "../util.js";
+var bk;
+var hasRequiredBk;
+function requireBk() {
+  if (hasRequiredBk) return bk;
+  hasRequiredBk = 1;
+  var _ = requireLodash();
+  var Graph = requireGraphlib().Graph;
+  var util = requireUtil$1();
+  bk = {
+    positionX,
+    findType1Conflicts,
+    findType2Conflicts,
+    addConflict,
+    hasConflict,
+    verticalAlignment,
+    horizontalCompaction,
+    alignCoordinates,
+    findSmallestWidthAlignment,
+    balance
+  };
+  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;
+    }
+    var conflictsV = conflicts[v];
+    if (!conflictsV) {
+      conflicts[v] = conflictsV = {};
+    }
+    conflictsV[w] = true;
+  }
+  function hasConflict(conflicts, v, w) {
+    if (v > w) {
+      var tmp = v;
+      v = w;
+      w = tmp;
+    }
+    return _.has(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 min = 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 (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+        xs[elem] = Math.max(xs[elem], min);
+      }
+    }
+    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 max = Number.NEGATIVE_INFINITY;
+      var min = Number.POSITIVE_INFINITY;
+      _.forIn(xs, function(x, v) {
+        var halfWidth = width(g, v) / 2;
+        max = Math.max(x + halfWidth, max);
+        min = Math.min(x - halfWidth, min);
+      });
+      return max - min;
+    });
+  }
+  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 = util.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 (_.has(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 (_.has(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;
+  }
+  return bk;
+}
+export {
+  requireBk as __require
+};
+//# sourceMappingURL=bk.js.map