@fecp/designer 5.6.6 → 5.6.9

package/lib/node_modules/dagre-d3-es/src/dagre/layout.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../graphlib/graph.js");
+const addBorderSegments = require("./add-border-segments.js");
+const coordinateSystem = require("./coordinate-system.js");
+const acyclic = require("./acyclic.js");
+const normalize = require("./normalize.js");
+const index = require("./rank/index.js");
+const nestingGraph = require("./nesting-graph.js");
+const index$1 = require("./order/index.js");
+const parentDummyChains = require("./parent-dummy-chains.js");
+const index$2 = require("./position/index.js");
+const util = require("./util.js");
+const forEach = require("../../../lodash-es/forEach.js");
+const merge = require("../../../lodash-es/merge.js");
+const pick = require("../../../lodash-es/pick.js");
+const mapValues = require("../../../lodash-es/mapValues.js");
+const defaults = require("../../../lodash-es/defaults.js");
+const max = require("../../../lodash-es/max.js");
+const last = require("../../../lodash-es/last.js");
+function layout(g, opts) {
+  var time = util.notime;
+  time("layout", () => {
+    var layoutGraph = time("  buildLayoutGraph", () => buildLayoutGraph(g));
+    time("  runLayout", () => runLayout(layoutGraph, time));
+    time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
+  });
+}
+function runLayout(g, time) {
+  time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
+  time("    removeSelfEdges", () => removeSelfEdges(g));
+  time("    acyclic", () => acyclic.run(g));
+  time("    nestingGraph.run", () => nestingGraph.run(g));
+  time("    rank", () => index.rank(util.asNonCompoundGraph(g)));
+  time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
+  time("    removeEmptyRanks", () => util.removeEmptyRanks(g));
+  time("    nestingGraph.cleanup", () => nestingGraph.cleanup(g));
+  time("    normalizeRanks", () => util.normalizeRanks(g));
+  time("    assignRankMinMax", () => assignRankMinMax(g));
+  time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
+  time("    normalize.run", () => normalize.run(g));
+  time("    parentDummyChains", () => parentDummyChains.parentDummyChains(g));
+  time("    addBorderSegments", () => addBorderSegments.addBorderSegments(g));
+  time("    order", () => index$1.order(g));
+  time("    insertSelfEdges", () => insertSelfEdges(g));
+  time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
+  time("    position", () => index$2.position(g));
+  time("    positionSelfEdges", () => positionSelfEdges(g));
+  time("    removeBorderNodes", () => removeBorderNodes(g));
+  time("    normalize.undo", () => normalize.undo(g));
+  time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
+  time("    undoCoordinateSystem", () => coordinateSystem.undo(g));
+  time("    translateGraph", () => translateGraph(g));
+  time("    assignNodeIntersects", () => assignNodeIntersects(g));
+  time("    reversePoints", () => reversePointsForReversedEdges(g));
+  time("    acyclic.undo", () => acyclic.undo(g));
+}
+function updateInputGraph(inputGraph, layoutGraph) {
+  forEach.default(inputGraph.nodes(), function(v) {
+    var inputLabel = inputGraph.node(v);
+    var layoutLabel = layoutGraph.node(v);
+    if (inputLabel) {
+      inputLabel.x = layoutLabel.x;
+      inputLabel.y = layoutLabel.y;
+      if (layoutGraph.children(v).length) {
+        inputLabel.width = layoutLabel.width;
+        inputLabel.height = layoutLabel.height;
+      }
+    }
+  });
+  forEach.default(inputGraph.edges(), function(e) {
+    var inputLabel = inputGraph.edge(e);
+    var layoutLabel = layoutGraph.edge(e);
+    inputLabel.points = layoutLabel.points;
+    if (Object.prototype.hasOwnProperty.call(layoutLabel, "x")) {
+      inputLabel.x = layoutLabel.x;
+      inputLabel.y = layoutLabel.y;
+    }
+  });
+  inputGraph.graph().width = layoutGraph.graph().width;
+  inputGraph.graph().height = layoutGraph.graph().height;
+}
+var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
+var graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
+var nodeNumAttrs = ["width", "height"];
+var nodeDefaults = { width: 0, height: 0 };
+var edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
+var edgeDefaults = {
+  minlen: 1,
+  weight: 1,
+  width: 0,
+  height: 0,
+  labeloffset: 10,
+  labelpos: "r"
+};
+var edgeAttrs = ["labelpos"];
+function buildLayoutGraph(inputGraph) {
+  var g = new graph.Graph({ multigraph: true, compound: true });
+  var graph$1 = canonicalize(inputGraph.graph());
+  g.setGraph(
+    merge.default({}, graphDefaults, selectNumberAttrs(graph$1, graphNumAttrs), pick.default(graph$1, graphAttrs))
+  );
+  forEach.default(inputGraph.nodes(), function(v) {
+    var node = canonicalize(inputGraph.node(v));
+    g.setNode(v, defaults.default(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+    g.setParent(v, inputGraph.parent(v));
+  });
+  forEach.default(inputGraph.edges(), function(e) {
+    var edge = canonicalize(inputGraph.edge(e));
+    g.setEdge(
+      e,
+      merge.default({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pick.default(edge, edgeAttrs))
+    );
+  });
+  return g;
+}
+function makeSpaceForEdgeLabels(g) {
+  var graph2 = g.graph();
+  graph2.ranksep /= 2;
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    edge.minlen *= 2;
+    if (edge.labelpos.toLowerCase() !== "c") {
+      if (graph2.rankdir === "TB" || graph2.rankdir === "BT") {
+        edge.width += edge.labeloffset;
+      } else {
+        edge.height += edge.labeloffset;
+      }
+    }
+  });
+}
+function injectEdgeLabelProxies(g) {
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    if (edge.width && edge.height) {
+      var v = g.node(e.v);
+      var w = g.node(e.w);
+      var label = { rank: (w.rank - v.rank) / 2 + v.rank, e };
+      util.addDummyNode(g, "edge-proxy", label, "_ep");
+    }
+  });
+}
+function assignRankMinMax(g) {
+  var maxRank = 0;
+  forEach.default(g.nodes(), function(v) {
+    var node = g.node(v);
+    if (node.borderTop) {
+      node.minRank = g.node(node.borderTop).rank;
+      node.maxRank = g.node(node.borderBottom).rank;
+      maxRank = max.default(maxRank, node.maxRank);
+    }
+  });
+  g.graph().maxRank = maxRank;
+}
+function removeEdgeLabelProxies(g) {
+  forEach.default(g.nodes(), function(v) {
+    var node = g.node(v);
+    if (node.dummy === "edge-proxy") {
+      g.edge(node.e).labelRank = node.rank;
+      g.removeNode(v);
+    }
+  });
+}
+function translateGraph(g) {
+  var minX = Number.POSITIVE_INFINITY;
+  var maxX = 0;
+  var minY = Number.POSITIVE_INFINITY;
+  var maxY = 0;
+  var graphLabel = g.graph();
+  var marginX = graphLabel.marginx || 0;
+  var marginY = graphLabel.marginy || 0;
+  function getExtremes(attrs) {
+    var x = attrs.x;
+    var y = attrs.y;
+    var w = attrs.width;
+    var h = attrs.height;
+    minX = Math.min(minX, x - w / 2);
+    maxX = Math.max(maxX, x + w / 2);
+    minY = Math.min(minY, y - h / 2);
+    maxY = Math.max(maxY, y + h / 2);
+  }
+  forEach.default(g.nodes(), function(v) {
+    getExtremes(g.node(v));
+  });
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
+      getExtremes(edge);
+    }
+  });
+  minX -= marginX;
+  minY -= marginY;
+  forEach.default(g.nodes(), function(v) {
+    var node = g.node(v);
+    node.x -= minX;
+    node.y -= minY;
+  });
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    forEach.default(edge.points, function(p) {
+      p.x -= minX;
+      p.y -= minY;
+    });
+    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
+      edge.x -= minX;
+    }
+    if (Object.prototype.hasOwnProperty.call(edge, "y")) {
+      edge.y -= minY;
+    }
+  });
+  graphLabel.width = maxX - minX + marginX;
+  graphLabel.height = maxY - minY + marginY;
+}
+function assignNodeIntersects(g) {
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    var nodeV = g.node(e.v);
+    var nodeW = g.node(e.w);
+    var p1, p2;
+    if (!edge.points) {
+      edge.points = [];
+      p1 = nodeW;
+      p2 = nodeV;
+    } else {
+      p1 = edge.points[0];
+      p2 = edge.points[edge.points.length - 1];
+    }
+    edge.points.unshift(util.intersectRect(nodeV, p1));
+    edge.points.push(util.intersectRect(nodeW, p2));
+  });
+}
+function fixupEdgeLabelCoords(g) {
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
+      if (edge.labelpos === "l" || edge.labelpos === "r") {
+        edge.width -= edge.labeloffset;
+      }
+      switch (edge.labelpos) {
+        case "l":
+          edge.x -= edge.width / 2 + edge.labeloffset;
+          break;
+        case "r":
+          edge.x += edge.width / 2 + edge.labeloffset;
+          break;
+      }
+    }
+  });
+}
+function reversePointsForReversedEdges(g) {
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    if (edge.reversed) {
+      edge.points.reverse();
+    }
+  });
+}
+function removeBorderNodes(g) {
+  forEach.default(g.nodes(), function(v) {
+    if (g.children(v).length) {
+      var node = g.node(v);
+      var t = g.node(node.borderTop);
+      var b = g.node(node.borderBottom);
+      var l = g.node(last.default(node.borderLeft));
+      var r = g.node(last.default(node.borderRight));
+      node.width = Math.abs(r.x - l.x);
+      node.height = Math.abs(b.y - t.y);
+      node.x = l.x + node.width / 2;
+      node.y = t.y + node.height / 2;
+    }
+  });
+  forEach.default(g.nodes(), function(v) {
+    if (g.node(v).dummy === "border") {
+      g.removeNode(v);
+    }
+  });
+}
+function removeSelfEdges(g) {
+  forEach.default(g.edges(), function(e) {
+    if (e.v === e.w) {
+      var node = g.node(e.v);
+      if (!node.selfEdges) {
+        node.selfEdges = [];
+      }
+      node.selfEdges.push({ e, label: g.edge(e) });
+      g.removeEdge(e);
+    }
+  });
+}
+function insertSelfEdges(g) {
+  var layers = util.buildLayerMatrix(g);
+  forEach.default(layers, function(layer) {
+    var orderShift = 0;
+    forEach.default(layer, function(v, i) {
+      var node = g.node(v);
+      node.order = i + orderShift;
+      forEach.default(node.selfEdges, function(selfEdge) {
+        util.addDummyNode(
+          g,
+          "selfedge",
+          {
+            width: selfEdge.label.width,
+            height: selfEdge.label.height,
+            rank: node.rank,
+            order: i + ++orderShift,
+            e: selfEdge.e,
+            label: selfEdge.label
+          },
+          "_se"
+        );
+      });
+      delete node.selfEdges;
+    });
+  });
+}
+function positionSelfEdges(g) {
+  forEach.default(g.nodes(), function(v) {
+    var node = g.node(v);
+    if (node.dummy === "selfedge") {
+      var selfNode = g.node(node.e.v);
+      var x = selfNode.x + selfNode.width / 2;
+      var y = selfNode.y;
+      var dx = node.x - x;
+      var dy = selfNode.height / 2;
+      g.setEdge(node.e, node.label);
+      g.removeNode(v);
+      node.label.points = [
+        { x: x + 2 * dx / 3, y: y - dy },
+        { x: x + 5 * dx / 6, y: y - dy },
+        { x: x + dx, y },
+        { x: x + 5 * dx / 6, y: y + dy },
+        { x: x + 2 * dx / 3, y: y + dy }
+      ];
+      node.label.x = node.x;
+      node.label.y = node.y;
+    }
+  });
+}
+function selectNumberAttrs(obj, attrs) {
+  return mapValues.default(pick.default(obj, attrs), Number);
+}
+function canonicalize(attrs) {
+  var newAttrs = {};
+  forEach.default(attrs, function(v, k) {
+    newAttrs[k.toLowerCase()] = v;
+  });
+  return newAttrs;
+}
+exports.layout = layout;

package/lib/node_modules/dagre-d3-es/src/dagre/nesting-graph.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("./util.js");
+const max = require("../../../lodash-es/max.js");
+const values = require("../../../lodash-es/values.js");
+const forEach = require("../../../lodash-es/forEach.js");
+const reduce = require("../../../lodash-es/reduce.js");
+function run(g) {
+  var root = util.addDummyNode(g, "root", {}, "_root");
+  var depths = treeDepths(g);
+  var height = max.default(values.default(depths)) - 1;
+  var nodeSep = 2 * height + 1;
+  g.graph().nestingRoot = root;
+  forEach.default(g.edges(), function(e) {
+    g.edge(e).minlen *= nodeSep;
+  });
+  var weight = sumWeights(g) + 1;
+  forEach.default(g.children(), function(child) {
+    dfs(g, root, nodeSep, weight, height, depths, child);
+  });
+  g.graph().nodeRankFactor = nodeSep;
+}
+function dfs(g, root, nodeSep, weight, height, depths, v) {
+  var children = g.children(v);
+  if (!children.length) {
+    if (v !== root) {
+      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
+    }
+    return;
+  }
+  var top = util.addBorderNode(g, "_bt");
+  var bottom = util.addBorderNode(g, "_bb");
+  var label = g.node(v);
+  g.setParent(top, v);
+  label.borderTop = top;
+  g.setParent(bottom, v);
+  label.borderBottom = bottom;
+  forEach.default(children, function(child) {
+    dfs(g, root, nodeSep, weight, height, depths, child);
+    var childNode = g.node(child);
+    var childTop = childNode.borderTop ? childNode.borderTop : child;
+    var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+    var thisWeight = childNode.borderTop ? weight : 2 * weight;
+    var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+    g.setEdge(top, childTop, {
+      weight: thisWeight,
+      minlen,
+      nestingEdge: true
+    });
+    g.setEdge(childBottom, bottom, {
+      weight: thisWeight,
+      minlen,
+      nestingEdge: true
+    });
+  });
+  if (!g.parent(v)) {
+    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+  }
+}
+function treeDepths(g) {
+  var depths = {};
+  function dfs2(v, depth) {
+    var children = g.children(v);
+    if (children && children.length) {
+      forEach.default(children, function(child) {
+        dfs2(child, depth + 1);
+      });
+    }
+    depths[v] = depth;
+  }
+  forEach.default(g.children(), function(v) {
+    dfs2(v, 1);
+  });
+  return depths;
+}
+function sumWeights(g) {
+  return reduce.default(
+    g.edges(),
+    function(acc, e) {
+      return acc + g.edge(e).weight;
+    },
+    0
+  );
+}
+function cleanup(g) {
+  var graphLabel = g.graph();
+  g.removeNode(graphLabel.nestingRoot);
+  delete graphLabel.nestingRoot;
+  forEach.default(g.edges(), function(e) {
+    var edge = g.edge(e);
+    if (edge.nestingEdge) {
+      g.removeEdge(e);
+    }
+  });
+}
+exports.cleanup = cleanup;
+exports.run = run;

package/lib/node_modules/dagre-d3-es/src/dagre/normalize.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("./util.js");
+const forEach = require("../../../lodash-es/forEach.js");
+function run(g) {
+  g.graph().dummyChains = [];
+  forEach.default(g.edges(), function(edge) {
+    normalizeEdge(g, edge);
+  });
+}
+function normalizeEdge(g, e) {
+  var v = e.v;
+  var vRank = g.node(v).rank;
+  var w = e.w;
+  var wRank = g.node(w).rank;
+  var name = e.name;
+  var edgeLabel = g.edge(e);
+  var labelRank = edgeLabel.labelRank;
+  if (wRank === vRank + 1) return;
+  g.removeEdge(e);
+  var attrs = void 0;
+  var dummy, i;
+  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+    edgeLabel.points = [];
+    attrs = {
+      width: 0,
+      height: 0,
+      edgeLabel,
+      edgeObj: e,
+      rank: vRank
+    };
+    dummy = util.addDummyNode(g, "edge", attrs, "_d");
+    if (vRank === labelRank) {
+      attrs.width = edgeLabel.width;
+      attrs.height = edgeLabel.height;
+      attrs.dummy = "edge-label";
+      attrs.labelpos = edgeLabel.labelpos;
+    }
+    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+    if (i === 0) {
+      g.graph().dummyChains.push(dummy);
+    }
+    v = dummy;
+  }
+  g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+function undo(g) {
+  forEach.default(g.graph().dummyChains, function(v) {
+    var node = g.node(v);
+    var origLabel = node.edgeLabel;
+    var w;
+    g.setEdge(node.edgeObj, origLabel);
+    while (node.dummy) {
+      w = g.successors(v)[0];
+      g.removeNode(v);
+      origLabel.points.push({ x: node.x, y: node.y });
+      if (node.dummy === "edge-label") {
+        origLabel.x = node.x;
+        origLabel.y = node.y;
+        origLabel.width = node.width;
+        origLabel.height = node.height;
+      }
+      v = w;
+      node = g.node(v);
+    }
+  });
+}
+exports.run = run;
+exports.undo = undo;

package/lib/node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const forEach = require("../../../../lodash-es/forEach.js");
+function addSubgraphConstraints(g, cg, vs) {
+  var prev = {}, rootPrev;
+  forEach.default(vs, function(v) {
+    var child = g.parent(v), parent, prevChild;
+    while (child) {
+      parent = g.parent(child);
+      if (parent) {
+        prevChild = prev[parent];
+        prev[parent] = child;
+      } else {
+        prevChild = rootPrev;
+        rootPrev = child;
+      }
+      if (prevChild && prevChild !== child) {
+        cg.setEdge(prevChild, child);
+        return;
+      }
+      child = parent;
+    }
+  });
+}
+exports.addSubgraphConstraints = addSubgraphConstraints;

package/lib/node_modules/dagre-d3-es/src/dagre/order/barycenter.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const map = require("../../../../lodash-es/map.js");
+const reduce = require("../../../../lodash-es/reduce.js");
+function barycenter(g, movable) {
+  return map.default(movable, function(v) {
+    var inV = g.inEdges(v);
+    if (!inV.length) {
+      return { v };
+    } else {
+      var result = reduce.default(
+        inV,
+        function(acc, e) {
+          var edge = g.edge(e), nodeU = g.node(e.v);
+          return {
+            sum: acc.sum + edge.weight * nodeU.order,
+            weight: acc.weight + edge.weight
+          };
+        },
+        { sum: 0, weight: 0 }
+      );
+      return {
+        v,
+        barycenter: result.sum / result.weight,
+        weight: result.weight
+      };
+    }
+  });
+}
+exports.barycenter = barycenter;

package/lib/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graph = require("../../graphlib/graph.js");
+const forEach = require("../../../../lodash-es/forEach.js");
+const uniqueId = require("../../../../lodash-es/uniqueId.js");
+const isUndefined = require("../../../../lodash-es/isUndefined.js");
+function buildLayerGraph(g, rank, relationship) {
+  var root = createRootNode(g), result = new graph.Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
+    return g.node(v);
+  });
+  forEach.default(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.default(g[relationship](v), function(e) {
+        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !isUndefined.default(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.default("_root"))) ;
+  return v;
+}
+exports.buildLayerGraph = buildLayerGraph;

package/lib/node_modules/dagre-d3-es/src/dagre/order/cross-count.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const zipObject = require("../../../../lodash-es/zipObject.js");
+const map = require("../../../../lodash-es/map.js");
+const flatten = require("../../../../lodash-es/flatten.js");
+const sortBy = require("../../../../lodash-es/sortBy.js");
+const forEach = require("../../../../lodash-es/forEach.js");
+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.default(
+    southLayer,
+    map.default(southLayer, function(v, i) {
+      return i;
+    })
+  );
+  var southEntries = flatten.default(
+    map.default(northLayer, function(v) {
+      return sortBy.default(
+        map.default(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.default(new Array(treeSize), function() {
+    return 0;
+  });
+  var cc = 0;
+  forEach.default(
+    // @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;
+}
+exports.crossCount = crossCount;