@windrun-huaiin/third-ui 7.0.0 → 7.1.1

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/layout.mjs

@@ -0,0 +1,412 @@
+import { Graph } from '../graphlib/graph.mjs';
+import { addBorderSegments } from './add-border-segments.mjs';
+import { adjust, undo as undo$1 } from './coordinate-system.mjs';
+import { run, undo as undo$2 } from './acyclic.mjs';
+import { run as run$2, undo } from './normalize.mjs';
+import { rank } from './rank/index.mjs';
+import { run as run$1, cleanup } from './nesting-graph.mjs';
+import { order } from './order/index.mjs';
+import { parentDummyChains } from './parent-dummy-chains.mjs';
+import { position } from './position/index.mjs';
+import { notime, asNonCompoundGraph, removeEmptyRanks, normalizeRanks, addDummyNode, intersectRect, buildLayerMatrix } from './util.mjs';
+import forEach from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs';
+import merge from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/merge.mjs';
+import pick from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/pick.mjs';
+import defaults from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/defaults.mjs';
+import max from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.mjs';
+import last from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs';
+import mapValues from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/mapValues.mjs';
+
+function layout(g, opts) {
+  var time = 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', () => run(g));
+  time('    nestingGraph.run', () => run$1(g));
+  time('    rank', () => rank(asNonCompoundGraph(g)));
+  time('    injectEdgeLabelProxies', () => injectEdgeLabelProxies(g));
+  time('    removeEmptyRanks', () => removeEmptyRanks(g));
+  time('    nestingGraph.cleanup', () => cleanup(g));
+  time('    normalizeRanks', () => normalizeRanks(g));
+  time('    assignRankMinMax', () => assignRankMinMax(g));
+  time('    removeEdgeLabelProxies', () => removeEdgeLabelProxies(g));
+  time('    normalize.run', () => run$2(g));
+  time('    parentDummyChains', () => parentDummyChains(g));
+  time('    addBorderSegments', () => addBorderSegments(g));
+  time('    order', () => order(g));
+  time('    insertSelfEdges', () => insertSelfEdges(g));
+  time('    adjustCoordinateSystem', () => adjust(g));
+  time('    position', () => position(g));
+  time('    positionSelfEdges', () => positionSelfEdges(g));
+  time('    removeBorderNodes', () => removeBorderNodes(g));
+  time('    normalize.undo', () => undo(g));
+  time('    fixupEdgeLabelCoords', () => fixupEdgeLabelCoords(g));
+  time('    undoCoordinateSystem', () => undo$1(g));
+  time('    translateGraph', () => translateGraph(g));
+  time('    assignNodeIntersects', () => assignNodeIntersects(g));
+  time('    reversePoints', () => reversePointsForReversedEdges(g));
+  time('    acyclic.undo', () => undo$2(g));
+}
+
+/*
+ * Copies final layout information from the layout graph back to the input
+ * graph. This process only copies whitelisted attributes from the layout graph
+ * to the input graph, so it serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function updateInputGraph(inputGraph, layoutGraph) {
+  forEach(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(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'];
+
+/*
+ * Constructs a new graph from the input graph, which can be used for layout.
+ * This process copies only whitelisted attributes from the input graph to the
+ * layout graph. Thus this function serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function buildLayoutGraph(inputGraph) {
+  var g = new Graph({ multigraph: true, compound: true });
+  var graph = canonicalize(inputGraph.graph());
+
+  g.setGraph(
+    merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), pick(graph, graphAttrs)),
+  );
+
+  forEach(inputGraph.nodes(), function (v) {
+    var node = canonicalize(inputGraph.node(v));
+    g.setNode(v, defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+    g.setParent(v, inputGraph.parent(v));
+  });
+
+  forEach(inputGraph.edges(), function (e) {
+    var edge = canonicalize(inputGraph.edge(e));
+    g.setEdge(
+      e,
+      merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pick(edge, edgeAttrs)),
+    );
+  });
+
+  return g;
+}
+
+/*
+ * This idea comes from the Gansner paper: to account for edge labels in our
+ * layout we split each rank in half by doubling minlen and halving ranksep.
+ * Then we can place labels at these mid-points between nodes.
+ *
+ * We also add some minimal padding to the width to push the label for the edge
+ * away from the edge itself a bit.
+ */
+function makeSpaceForEdgeLabels(g) {
+  var graph = g.graph();
+  graph.ranksep /= 2;
+  forEach(g.edges(), function (e) {
+    var edge = g.edge(e);
+    edge.minlen *= 2;
+    if (edge.labelpos.toLowerCase() !== 'c') {
+      if (graph.rankdir === 'TB' || graph.rankdir === 'BT') {
+        edge.width += edge.labeloffset;
+      } else {
+        edge.height += edge.labeloffset;
+      }
+    }
+  });
+}
+
+/*
+ * Creates temporary dummy nodes that capture the rank in which each edge's
+ * label is going to, if it has one of non-zero width and height. We do this
+ * so that we can safely remove empty ranks while preserving balance for the
+ * label's position.
+ */
+function injectEdgeLabelProxies(g) {
+  forEach(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: e };
+      addDummyNode(g, 'edge-proxy', label, '_ep');
+    }
+  });
+}
+
+function assignRankMinMax(g) {
+  var maxRank = 0;
+  forEach(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;
+      // @ts-expect-error
+      maxRank = max(maxRank, node.maxRank);
+    }
+  });
+  g.graph().maxRank = maxRank;
+}
+
+function removeEdgeLabelProxies(g) {
+  forEach(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(g.nodes(), function (v) {
+    getExtremes(g.node(v));
+  });
+  forEach(g.edges(), function (e) {
+    var edge = g.edge(e);
+    if (Object.prototype.hasOwnProperty.call(edge, 'x')) {
+      getExtremes(edge);
+    }
+  });
+
+  minX -= marginX;
+  minY -= marginY;
+
+  forEach(g.nodes(), function (v) {
+    var node = g.node(v);
+    node.x -= minX;
+    node.y -= minY;
+  });
+
+  forEach(g.edges(), function (e) {
+    var edge = g.edge(e);
+    forEach(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(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(intersectRect(nodeV, p1));
+    edge.points.push(intersectRect(nodeW, p2));
+  });
+}
+
+function fixupEdgeLabelCoords(g) {
+  forEach(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(g.edges(), function (e) {
+    var edge = g.edge(e);
+    if (edge.reversed) {
+      edge.points.reverse();
+    }
+  });
+}
+
+function removeBorderNodes(g) {
+  forEach(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(node.borderLeft));
+      var r = g.node(last(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(g.nodes(), function (v) {
+    if (g.node(v).dummy === 'border') {
+      g.removeNode(v);
+    }
+  });
+}
+
+function removeSelfEdges(g) {
+  forEach(g.edges(), function (e) {
+    if (e.v === e.w) {
+      var node = g.node(e.v);
+      if (!node.selfEdges) {
+        node.selfEdges = [];
+      }
+      node.selfEdges.push({ e: e, label: g.edge(e) });
+      g.removeEdge(e);
+    }
+  });
+}
+
+function insertSelfEdges(g) {
+  var layers = buildLayerMatrix(g);
+  forEach(layers, function (layer) {
+    var orderShift = 0;
+    forEach(layer, function (v, i) {
+      var node = g.node(v);
+      node.order = i + orderShift;
+      forEach(node.selfEdges, function (selfEdge) {
+        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(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: 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(pick(obj, attrs), Number);
+}
+
+function canonicalize(attrs) {
+  var newAttrs = {};
+  forEach(attrs, function (v, k) {
+    newAttrs[k.toLowerCase()] = v;
+  });
+  return newAttrs;
+}
+
+export { layout };

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/nesting-graph.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var util = require('./util.js');
+var max = require('../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.js');
+var values = require('../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.js');
+var forEach = require('../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.js');
+var reduce = require('../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.js');
+
+/*
+ * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
+ * adds appropriate edges to ensure that all cluster nodes are placed between
+ * these boundries, and ensures that the graph is connected.
+ *
+ * In addition we ensure, through the use of the minlen property, that nodes
+ * and subgraph border nodes to not end up on the same rank.
+ *
+ * Preconditions:
+ *
+ *    1. Input graph is a DAG
+ *    2. Nodes in the input graph has a minlen attribute
+ *
+ * Postconditions:
+ *
+ *    1. Input graph is connected.
+ *    2. Dummy nodes are added for the tops and bottoms of subgraphs.
+ *    3. The minlen attribute for nodes is adjusted to ensure nodes do not
+ *       get placed on the same rank as subgraph border nodes.
+ *
+ * The nesting graph idea comes from Sander, "Layout of Compound Directed
+ * Graphs."
+ */
+function run(g) {
+  var root = util.addDummyNode(g, 'root', {}, '_root');
+  var depths = treeDepths(g);
+  var height = max(values(depths)) - 1; // Note: depths is an Object not an array
+  var nodeSep = 2 * height + 1;
+
+  g.graph().nestingRoot = root;
+
+  // Multiply minlen by nodeSep to align nodes on non-border ranks.
+  forEach(g.edges(), function (e) {
+    g.edge(e).minlen *= nodeSep;
+  });
+
+  // Calculate a weight that is sufficient to keep subgraphs vertically compact
+  var weight = sumWeights(g) + 1;
+
+  // Create border nodes and link them up
+  forEach(g.children(), function (child) {
+    dfs(g, root, nodeSep, weight, height, depths, child);
+  });
+
+  // Save the multiplier for node layers for later removal of empty border
+  // layers.
+  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(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: minlen,
+      nestingEdge: true,
+    });
+
+    g.setEdge(childBottom, bottom, {
+      weight: thisWeight,
+      minlen: minlen,
+      nestingEdge: true,
+    });
+  });
+
+  if (!g.parent(v)) {
+    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+  }
+}
+
+function treeDepths(g) {
+  var depths = {};
+  function dfs(v, depth) {
+    var children = g.children(v);
+    if (children && children.length) {
+      forEach(children, function (child) {
+        dfs(child, depth + 1);
+      });
+    }
+    depths[v] = depth;
+  }
+  forEach(g.children(), function (v) {
+    dfs(v, 1);
+  });
+  return depths;
+}
+
+function sumWeights(g) {
+  return reduce(
+    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(g.edges(), function (e) {
+    var edge = g.edge(e);
+    if (edge.nestingEdge) {
+      g.removeEdge(e);
+    }
+  });
+}
+
+exports.cleanup = cleanup;
+exports.run = run;

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/nesting-graph.mjs

@@ -0,0 +1,140 @@
+import { addDummyNode, addBorderNode } from './util.mjs';
+import max from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/max.mjs';
+import values from '../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.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';
+
+/*
+ * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
+ * adds appropriate edges to ensure that all cluster nodes are placed between
+ * these boundries, and ensures that the graph is connected.
+ *
+ * In addition we ensure, through the use of the minlen property, that nodes
+ * and subgraph border nodes to not end up on the same rank.
+ *
+ * Preconditions:
+ *
+ *    1. Input graph is a DAG
+ *    2. Nodes in the input graph has a minlen attribute
+ *
+ * Postconditions:
+ *
+ *    1. Input graph is connected.
+ *    2. Dummy nodes are added for the tops and bottoms of subgraphs.
+ *    3. The minlen attribute for nodes is adjusted to ensure nodes do not
+ *       get placed on the same rank as subgraph border nodes.
+ *
+ * The nesting graph idea comes from Sander, "Layout of Compound Directed
+ * Graphs."
+ */
+function run(g) {
+  var root = addDummyNode(g, 'root', {}, '_root');
+  var depths = treeDepths(g);
+  var height = max(values(depths)) - 1; // Note: depths is an Object not an array
+  var nodeSep = 2 * height + 1;
+
+  g.graph().nestingRoot = root;
+
+  // Multiply minlen by nodeSep to align nodes on non-border ranks.
+  forEach(g.edges(), function (e) {
+    g.edge(e).minlen *= nodeSep;
+  });
+
+  // Calculate a weight that is sufficient to keep subgraphs vertically compact
+  var weight = sumWeights(g) + 1;
+
+  // Create border nodes and link them up
+  forEach(g.children(), function (child) {
+    dfs(g, root, nodeSep, weight, height, depths, child);
+  });
+
+  // Save the multiplier for node layers for later removal of empty border
+  // layers.
+  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 = addBorderNode(g, '_bt');
+  var bottom = addBorderNode(g, '_bb');
+  var label = g.node(v);
+
+  g.setParent(top, v);
+  label.borderTop = top;
+  g.setParent(bottom, v);
+  label.borderBottom = bottom;
+
+  forEach(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: minlen,
+      nestingEdge: true,
+    });
+
+    g.setEdge(childBottom, bottom, {
+      weight: thisWeight,
+      minlen: minlen,
+      nestingEdge: true,
+    });
+  });
+
+  if (!g.parent(v)) {
+    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+  }
+}
+
+function treeDepths(g) {
+  var depths = {};
+  function dfs(v, depth) {
+    var children = g.children(v);
+    if (children && children.length) {
+      forEach(children, function (child) {
+        dfs(child, depth + 1);
+      });
+    }
+    depths[v] = depth;
+  }
+  forEach(g.children(), function (v) {
+    dfs(v, 1);
+  });
+  return depths;
+}
+
+function sumWeights(g) {
+  return reduce(
+    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(g.edges(), function (e) {
+    var edge = g.edge(e);
+    if (edge.nestingEdge) {
+      g.removeEdge(e);
+    }
+  });
+}
+
+export { cleanup, run };