service-flow-designer 0.0.1-beta.5 → 0.0.1-beta.6

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/dagre/src/greedy-fas.js

@@ -1,99 +0,0 @@
-"use strict";
-const graphlib = require("./graphlib.js");
-const list = require("./data/list.js");
-const Graph = graphlib.Graph;
-const DEFAULT_WEIGHT_FN = () => 1;
-const greedyFAS = (g, weightFn) => {
-  var _a;
-  if (g.nodeCount() <= 1)
-    return [];
-  const state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  const results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
-  return (_a = results.map((e) => g.outEdges(e.v, e.w))) === null || _a === void 0 ? void 0 : _a.flat();
-};
-const doGreedyFAS = (g, buckets, zeroIdx) => {
-  let results = [];
-  const sources = buckets[buckets.length - 1];
-  const sinks = buckets[0];
-  let entry;
-  while (g.nodeCount()) {
-    while (entry = sinks.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    while (entry = sources.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    if (g.nodeCount()) {
-      for (let i = buckets.length - 2; i > 0; --i) {
-        entry = buckets[i].dequeue();
-        if (entry) {
-          results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
-          break;
-        }
-      }
-    }
-  }
-  return results;
-};
-const removeNode = (g, buckets, zeroIdx, entry, collectPredecessors) => {
-  var _a, _b;
-  const results = collectPredecessors ? [] : void 0;
-  (_a = g.inEdges(entry.v)) === null || _a === void 0 ? void 0 : _a.forEach((edge) => {
-    const weight = g.edge(edge);
-    const uEntry = g.node(edge.v);
-    if (collectPredecessors) {
-      results.push({ v: edge.v, w: edge.w });
-    }
-    if (uEntry.out === void 0)
-      uEntry.out = 0;
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-  (_b = g.outEdges(entry.v)) === null || _b === void 0 ? void 0 : _b.forEach((edge) => {
-    const weight = g.edge(edge);
-    const w = edge.w;
-    const wEntry = g.node(w);
-    if (wEntry.in === void 0)
-      wEntry.in = 0;
-    wEntry.in -= weight;
-    assignBucket(buckets, zeroIdx, wEntry);
-  });
-  g.removeNode(entry.v);
-  return results;
-};
-const buildState = (g, weightFn) => {
-  const fasGraph = new Graph();
-  let maxIn = 0;
-  let maxOut = 0;
-  g.nodes().forEach((v) => {
-    fasGraph.setNode(v, { v, "in": 0, out: 0 });
-  });
-  g.edges().forEach((e) => {
-    const prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    const weight = weightFn === null || weightFn === void 0 ? void 0 : weightFn(e);
-    const edgeWeight = prevWeight + weight;
-    fasGraph.setEdge(e.v, e.w, edgeWeight);
-    maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
-    maxIn = Math.max(maxIn, fasGraph.node(e.w)["in"] += weight);
-  });
-  const buckets = [];
-  const rangeMax = maxOut + maxIn + 3;
-  for (let i = 0; i < rangeMax; i++) {
-    buckets.push(new list());
-  }
-  const zeroIdx = maxIn + 1;
-  fasGraph.nodes().forEach((v) => {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-  return { buckets, zeroIdx, graph: fasGraph };
-};
-const assignBucket = (buckets, zeroIdx, entry) => {
-  if (!entry.out) {
-    buckets[0].enqueue(entry);
-  } else if (!entry["in"]) {
-    buckets[buckets.length - 1].enqueue(entry);
-  } else {
-    buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
-  }
-};
-module.exports = greedyFAS;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/dagre/src/layout.js

@@ -1,474 +0,0 @@
-"use strict";
-const acyclic = require("./acyclic.js");
-const normalize = require("./normalize.js");
-const index = require("./rank/index.js");
-const util = require("./util.js");
-const parentDummyChains = require("./parent-dummy-chains.js");
-const nestingGraph = require("./nesting-graph.js");
-const addBorderSegments = require("./add-border-segments.js");
-const coordinateSystem = require("./coordinate-system.js");
-const index$1 = require("./order/index.js");
-const index$2 = require("./position/index.js");
-const graphlib = require("./graphlib.js");
-const initDataOrder = require("./order/init-data-order.js");
-const Graph = graphlib.Graph;
-const layout = (g, opts) => {
-  const time = opts && opts.debugTiming ? util.default.time : util.default.notime;
-  time("layout", () => {
-    if (opts && !opts.keepNodeOrder && opts.prevGraph) {
-      time("  inheritOrder", () => {
-        inheritOrder(g, opts.prevGraph);
-      });
-    }
-    const layoutGraph = time("  buildLayoutGraph", () => {
-      return buildLayoutGraph(g);
-    });
-    if (!(opts && opts.edgeLabelSpace === false)) {
-      time("  makeSpaceForEdgeLabels", () => {
-        makeSpaceForEdgeLabels(layoutGraph);
-      });
-    }
-    try {
-      time("  runLayout", () => {
-        runLayout(layoutGraph, time, opts);
-      });
-    } catch (e) {
-      if (e.message === "Not possible to find intersection inside of the rectangle") {
-        console.error("The following error may be caused by improper layer setting, please make sure your manual layer setting does not violate the graph's structure:\n", e);
-        return;
-      }
-      throw e;
-    }
-    time("  updateInputGraph", () => {
-      updateInputGraph(g, layoutGraph);
-    });
-  });
-};
-const runLayout = (g, time, opts) => {
-  time("    removeSelfEdges", () => {
-    removeSelfEdges(g);
-  });
-  time("    acyclic", () => {
-    acyclic.run(g);
-  });
-  time("    nestingGraph.run", () => {
-    nestingGraph.run(g);
-  });
-  time("    rank", () => {
-    index(util.default.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(g);
-  });
-  time("    addBorderSegments", () => {
-    addBorderSegments(g);
-  });
-  if (opts && opts.keepNodeOrder) {
-    time("    initDataOrder", () => {
-      initDataOrder(g, opts.nodeOrder);
-    });
-  }
-  time("    order", () => {
-    index$1(g);
-  });
-  time("    insertSelfEdges", () => {
-    insertSelfEdges(g);
-  });
-  time("    adjustCoordinateSystem", () => {
-    coordinateSystem.adjust(g);
-  });
-  time("    position", () => {
-    index$2(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);
-  });
-};
-const inheritOrder = (currG, prevG) => {
-  const prevNodeMap = prevG._nodes || {};
-  currG.nodes().forEach((n) => {
-    const node = currG.node(n);
-    if (prevNodeMap[n] !== void 0) {
-      node.fixorder = prevNodeMap[n]._order;
-      delete prevNodeMap[n]._order;
-    } else {
-      delete node.fixorder;
-    }
-  });
-};
-const updateInputGraph = (inputGraph, layoutGraph) => {
-  inputGraph.nodes().forEach((v) => {
-    var _a;
-    const inputLabel = inputGraph.node(v);
-    const layoutLabel = layoutGraph.node(v);
-    if (inputLabel) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-      inputLabel._order = layoutLabel.order;
-      inputLabel._rank = layoutLabel.rank;
-      if ((_a = layoutGraph.children(v)) === null || _a === void 0 ? void 0 : _a.length) {
-        inputLabel.width = layoutLabel.width;
-        inputLabel.height = layoutLabel.height;
-      }
-    }
-  });
-  inputGraph.edges().forEach((e) => {
-    const inputLabel = inputGraph.edge(e);
-    const layoutLabel = layoutGraph.edge(e);
-    inputLabel.points = layoutLabel.points;
-    if (layoutLabel.hasOwnProperty("x")) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-    }
-  });
-  inputGraph.graph().width = layoutGraph.graph().width;
-  inputGraph.graph().height = layoutGraph.graph().height;
-};
-const graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
-const graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
-const graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
-const nodeNumAttrs = ["width", "height", "layer", "fixorder"];
-const nodeDefaults = { width: 0, height: 0 };
-const edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
-const edgeDefaults = {
-  minlen: 1,
-  weight: 1,
-  width: 0,
-  height: 0,
-  labeloffset: 10,
-  labelpos: "r"
-};
-const edgeAttrs = ["labelpos"];
-const buildLayoutGraph = (inputGraph) => {
-  const g = new Graph({ multigraph: true, compound: true });
-  const graph = canonicalize(inputGraph.graph());
-  const pickedProperties = {};
-  graphAttrs === null || graphAttrs === void 0 ? void 0 : graphAttrs.forEach((key) => {
-    if (graph[key] !== void 0)
-      pickedProperties[key] = graph[key];
-  });
-  g.setGraph(Object.assign({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), pickedProperties));
-  inputGraph.nodes().forEach((v) => {
-    const node = canonicalize(inputGraph.node(v));
-    const defaultAttrs = selectNumberAttrs(node, nodeNumAttrs);
-    Object.keys(nodeDefaults).forEach((key) => {
-      if (defaultAttrs[key] === void 0) {
-        defaultAttrs[key] = nodeDefaults[key];
-      }
-    });
-    g.setNode(v, defaultAttrs);
-    g.setParent(v, inputGraph.parent(v));
-  });
-  inputGraph.edges().forEach((e) => {
-    const edge = canonicalize(inputGraph.edge(e));
-    const pickedProperties2 = {};
-    edgeAttrs === null || edgeAttrs === void 0 ? void 0 : edgeAttrs.forEach((key) => {
-      if (edge[key] !== void 0)
-        pickedProperties2[key] = edge[key];
-    });
-    g.setEdge(e, Object.assign({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pickedProperties2));
-  });
-  return g;
-};
-const makeSpaceForEdgeLabels = (g) => {
-  const graph = g.graph();
-  if (!graph.ranksep)
-    graph.ranksep = 0;
-  graph.ranksep /= 2;
-  g.nodes().forEach((n) => {
-    const node = g.node(n);
-    if (!isNaN(node.layer)) {
-      if (!node.layer)
-        node.layer = 0;
-      else
-        node.layer *= 2;
-    }
-  });
-  g.edges().forEach((e) => {
-    var _a;
-    const edge = g.edge(e);
-    edge.minlen *= 2;
-    if (((_a = edge.labelpos) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== "c") {
-      if (graph.rankdir === "TB" || graph.rankdir === "BT") {
-        edge.width += edge.labeloffset;
-      } else {
-        edge.height += edge.labeloffset;
-      }
-    }
-  });
-};
-const injectEdgeLabelProxies = (g) => {
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    if (edge.width && edge.height) {
-      const v = g.node(e.v);
-      const w = g.node(e.w);
-      const label = { e, rank: (w.rank - v.rank) / 2 + v.rank };
-      util.default.addDummyNode(g, "edge-proxy", label, "_ep");
-    }
-  });
-};
-const assignRankMinMax = (g) => {
-  let maxRank = 0;
-  g.nodes().forEach((v) => {
-    const node = g.node(v);
-    if (node.borderTop) {
-      node.minRank = g.node(node.borderTop).rank;
-      node.maxRank = g.node(node.borderBottom).rank;
-      maxRank = Math.max(maxRank, node.maxRank || -Infinity);
-    }
-  });
-  g.graph().maxRank = maxRank;
-};
-const removeEdgeLabelProxies = (g) => {
-  g.nodes().forEach((v) => {
-    const node = g.node(v);
-    if (node.dummy === "edge-proxy") {
-      g.edge(node.e).labelRank = node.rank;
-      g.removeNode(v);
-    }
-  });
-};
-const translateGraph = (g) => {
-  let minX = Number.POSITIVE_INFINITY;
-  let maxX = 0;
-  let minY = Number.POSITIVE_INFINITY;
-  let maxY = 0;
-  const graphLabel = g.graph();
-  const marginX = graphLabel.marginx || 0;
-  const marginY = graphLabel.marginy || 0;
-  const getExtremes = (attrs) => {
-    if (!attrs)
-      return;
-    const x = attrs.x;
-    const y = attrs.y;
-    const w = attrs.width;
-    const h = attrs.height;
-    if (!isNaN(x) && !isNaN(w)) {
-      minX = Math.min(minX, x - w / 2);
-      maxX = Math.max(maxX, x + w / 2);
-    }
-    if (!isNaN(y) && !isNaN(h)) {
-      minY = Math.min(minY, y - h / 2);
-      maxY = Math.max(maxY, y + h / 2);
-    }
-  };
-  g.nodes().forEach((v) => {
-    getExtremes(g.node(v));
-  });
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    if (edge.hasOwnProperty("x")) {
-      getExtremes(edge);
-    }
-  });
-  minX -= marginX;
-  minY -= marginY;
-  g.nodes().forEach((v) => {
-    const node = g.node(v);
-    node.x -= minX;
-    node.y -= minY;
-  });
-  g.edges().forEach((e) => {
-    var _a;
-    const edge = g.edge(e);
-    (_a = edge.points) === null || _a === void 0 ? void 0 : _a.forEach((p) => {
-      p.x -= minX;
-      p.y -= minY;
-    });
-    if (edge.hasOwnProperty("x")) {
-      edge.x -= minX;
-    }
-    if (edge.hasOwnProperty("y")) {
-      edge.y -= minY;
-    }
-  });
-  graphLabel.width = maxX - minX + marginX;
-  graphLabel.height = maxY - minY + marginY;
-};
-const assignNodeIntersects = (g) => {
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    const nodeV = g.node(e.v);
-    const nodeW = g.node(e.w);
-    let p1;
-    let 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.default.intersectRect(nodeV, p1));
-    edge.points.push(util.default.intersectRect(nodeW, p2));
-  });
-};
-const fixupEdgeLabelCoords = (g) => {
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    if (edge.hasOwnProperty("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;
-      }
-    }
-  });
-};
-const reversePointsForReversedEdges = (g) => {
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    if (edge.reversed) {
-      edge.points.reverse();
-    }
-  });
-};
-const removeBorderNodes = (g) => {
-  g.nodes().forEach((v) => {
-    var _a, _b, _c;
-    if ((_a = g.children(v)) === null || _a === void 0 ? void 0 : _a.length) {
-      const node = g.node(v);
-      const t = g.node(node.borderTop);
-      const b = g.node(node.borderBottom);
-      const l = g.node(node.borderLeft[((_b = node.borderLeft) === null || _b === void 0 ? void 0 : _b.length) - 1]);
-      const r = g.node(node.borderRight[((_c = node.borderRight) === null || _c === void 0 ? void 0 : _c.length) - 1]);
-      node.width = Math.abs((r === null || r === void 0 ? void 0 : r.x) - (l === null || l === void 0 ? void 0 : l.x)) || 10;
-      node.height = Math.abs((b === null || b === void 0 ? void 0 : b.y) - (t === null || t === void 0 ? void 0 : t.y)) || 10;
-      node.x = ((l === null || l === void 0 ? void 0 : l.x) || 0) + node.width / 2;
-      node.y = ((t === null || t === void 0 ? void 0 : t.y) || 0) + node.height / 2;
-    }
-  });
-  g.nodes().forEach((v) => {
-    if (g.node(v).dummy === "border") {
-      g.removeNode(v);
-    }
-  });
-};
-const removeSelfEdges = (g) => {
-  g.edges().forEach((e) => {
-    if (e.v === e.w) {
-      const node = g.node(e.v);
-      if (!node.selfEdges) {
-        node.selfEdges = [];
-      }
-      node.selfEdges.push({ e, label: g.edge(e) });
-      g.removeEdge(e);
-    }
-  });
-};
-const insertSelfEdges = (g) => {
-  const layers = util.default.buildLayerMatrix(g);
-  layers === null || layers === void 0 ? void 0 : layers.forEach((layer) => {
-    let orderShift = 0;
-    layer === null || layer === void 0 ? void 0 : layer.forEach((v, i) => {
-      var _a;
-      const node = g.node(v);
-      node.order = i + orderShift;
-      (_a = node.selfEdges) === null || _a === void 0 ? void 0 : _a.forEach((selfEdge) => {
-        util.default.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;
-    });
-  });
-};
-const positionSelfEdges = (g) => {
-  g.nodes().forEach((v) => {
-    const node = g.node(v);
-    if (node.dummy === "selfedge") {
-      const selfNode = g.node(node.e.v);
-      const x = selfNode.x + selfNode.width / 2;
-      const y = selfNode.y;
-      const dx = node.x - x;
-      const 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 },
-        { y, x: x + dx },
-        { 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;
-    }
-  });
-};
-const selectNumberAttrs = (obj, attrs) => {
-  const pickedProperties = {};
-  attrs === null || attrs === void 0 ? void 0 : attrs.forEach((key) => {
-    if (obj[key] === void 0)
-      return;
-    pickedProperties[key] = +obj[key];
-  });
-  return pickedProperties;
-};
-const canonicalize = (attrs) => {
-  const newAttrs = {};
-  Object.keys(attrs).forEach((k) => {
-    const v = attrs[k];
-    newAttrs[k.toLowerCase()] = v;
-  });
-  return newAttrs;
-};
-module.exports = layout;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/dagre/src/nesting-graph.js

@@ -1,86 +0,0 @@
-"use strict";
-const util = require("./util.js");
-const run = (g) => {
-  var _a;
-  const root = util.default.addDummyNode(g, "root", {}, "_root");
-  const depths = treeDepths(g);
-  const height = Math.max(...Object.values(depths)) - 1;
-  const nodeSep = 2 * height + 1;
-  g.graph().nestingRoot = root;
-  g.edges().forEach((e) => {
-    g.edge(e).minlen *= nodeSep;
-  });
-  const weight = sumWeights(g) + 1;
-  (_a = g.children()) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-  });
-  g.graph().nodeRankFactor = nodeSep;
-};
-const dfs = (g, root, nodeSep, weight, height, depths, v) => {
-  const children = g.children(v);
-  if (!(children === null || children === void 0 ? void 0 : children.length)) {
-    if (v !== root) {
-      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
-    }
-    return;
-  }
-  const top = util.default.addBorderNode(g, "_bt");
-  const bottom = util.default.addBorderNode(g, "_bb");
-  const label = g.node(v);
-  g.setParent(top, v);
-  label.borderTop = top;
-  g.setParent(bottom, v);
-  label.borderBottom = bottom;
-  children === null || children === void 0 ? void 0 : children.forEach((child) => {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-    const childNode = g.node(child);
-    const childTop = childNode.borderTop ? childNode.borderTop : child;
-    const childBottom = childNode.borderBottom ? childNode.borderBottom : child;
-    const thisWeight = childNode.borderTop ? weight : 2 * weight;
-    const minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
-    g.setEdge(top, childTop, {
-      minlen,
-      weight: thisWeight,
-      nestingEdge: true
-    });
-    g.setEdge(childBottom, bottom, {
-      minlen,
-      weight: thisWeight,
-      nestingEdge: true
-    });
-  });
-  if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
-  }
-};
-const treeDepths = (g) => {
-  var _a;
-  const depths = {};
-  const dfs2 = (v, depth) => {
-    const children = g.children(v);
-    children === null || children === void 0 ? void 0 : children.forEach((child) => dfs2(child, depth + 1));
-    depths[v] = depth;
-  };
-  (_a = g.children()) === null || _a === void 0 ? void 0 : _a.forEach((v) => dfs2(v, 1));
-  return depths;
-};
-const sumWeights = (g) => {
-  let result = 0;
-  g.edges().forEach((e) => {
-    result += g.edge(e).weight;
-  });
-  return result;
-};
-const cleanup = (g) => {
-  const graphLabel = g.graph();
-  graphLabel.nestingRoot && g.removeNode(graphLabel.nestingRoot);
-  delete graphLabel.nestingRoot;
-  g.edges().forEach((e) => {
-    const edge = g.edge(e);
-    if (edge.nestingEdge) {
-      g.removeEdge(e);
-    }
-  });
-};
-const nestingGraph = { run, cleanup };
-module.exports = nestingGraph;