@statewalker/fsm-charts 0.2.5 → 0.2.7

package/dist/chunk-2LFUT2C6.js

@@ -1,2691 +0,0 @@
-import { getPadding } from './chunk-FIQDLBWD.js';
-
-// src/lodash-es/index.ts
-var _ = {
-  constant: (value) => () => value
-};
-function setLodash(lib) {
-  _ = lib;
-}
-function getLodash() {
-  return _;
-}
-
-// src/graphlib/graph.js
-var DEFAULT_EDGE_NAME = "\0";
-var GRAPH_NODE = "\0";
-var EDGE_KEY_DELIM = "
";
-var Graph = class {
-  constructor(opts = {}) {
-    this._isDirected = _.has(opts, "directed") ? opts.directed : true;
-    this._isMultigraph = _.has(opts, "multigraph") ? opts.multigraph : false;
-    this._isCompound = _.has(opts, "compound") ? opts.compound : false;
-    this._label = void 0;
-    this._defaultNodeLabelFn = _.constant(void 0);
-    this._defaultEdgeLabelFn = _.constant(void 0);
-    this._nodes = {};
-    if (this._isCompound) {
-      this._parent = {};
-      this._children = {};
-      this._children[GRAPH_NODE] = {};
-    }
-    this._in = {};
-    this._preds = {};
-    this._out = {};
-    this._sucs = {};
-    this._edgeObjs = {};
-    this._edgeLabels = {};
-  }
-  /* === Graph functions ========= */
-  isDirected() {
-    return this._isDirected;
-  }
-  isMultigraph() {
-    return this._isMultigraph;
-  }
-  isCompound() {
-    return this._isCompound;
-  }
-  setGraph(label) {
-    this._label = label;
-    return this;
-  }
-  graph() {
-    return this._label;
-  }
-  /* === Node functions ========== */
-  setDefaultNodeLabel(newDefault) {
-    if (!_.isFunction(newDefault)) {
-      newDefault = _.constant(newDefault);
-    }
-    this._defaultNodeLabelFn = newDefault;
-    return this;
-  }
-  nodeCount() {
-    return this._nodeCount;
-  }
-  nodes() {
-    return _.keys(this._nodes);
-  }
-  sources() {
-    return _.filter(this.nodes(), (v) => _.isEmpty(this._in[v]));
-  }
-  sinks() {
-    return _.filter(this.nodes(), (v) => _.isEmpty(this._out[v]));
-  }
-  setNodes(vs, value) {
-    var args = arguments;
-    _.each(vs, (v) => {
-      if (args.length > 1) {
-        this.setNode(v, value);
-      } else {
-        this.setNode(v);
-      }
-    });
-    return this;
-  }
-  setNode(v, value) {
-    if (_.has(this._nodes, v)) {
-      if (arguments.length > 1) {
-        this._nodes[v] = value;
-      }
-      return this;
-    }
-    this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
-    if (this._isCompound) {
-      this._parent[v] = GRAPH_NODE;
-      this._children[v] = {};
-      this._children[GRAPH_NODE][v] = true;
-    }
-    this._in[v] = {};
-    this._preds[v] = {};
-    this._out[v] = {};
-    this._sucs[v] = {};
-    ++this._nodeCount;
-    return this;
-  }
-  node(v) {
-    return this._nodes[v];
-  }
-  hasNode(v) {
-    return _.has(this._nodes, v);
-  }
-  removeNode(v) {
-    if (_.has(this._nodes, v)) {
-      var removeEdge = (e) => {
-        this.removeEdge(this._edgeObjs[e]);
-      };
-      delete this._nodes[v];
-      if (this._isCompound) {
-        this._removeFromParentsChildList(v);
-        delete this._parent[v];
-        _.each(this.children(v), (child) => {
-          this.setParent(child);
-        });
-        delete this._children[v];
-      }
-      _.each(_.keys(this._in[v]), removeEdge);
-      delete this._in[v];
-      delete this._preds[v];
-      _.each(_.keys(this._out[v]), removeEdge);
-      delete this._out[v];
-      delete this._sucs[v];
-      --this._nodeCount;
-    }
-    return this;
-  }
-  setParent(v, parent) {
-    if (!this._isCompound) {
-      throw new Error("Cannot set parent in a non-compound graph");
-    }
-    if (_.isUndefined(parent)) {
-      parent = GRAPH_NODE;
-    } else {
-      parent += "";
-      for (var ancestor = parent; !_.isUndefined(ancestor); ancestor = this.parent(ancestor)) {
-        if (ancestor === v) {
-          throw new Error(
-            `Setting ${parent} as parent of ${v} would create a cycle`
-          );
-        }
-      }
-      this.setNode(parent);
-    }
-    this.setNode(v);
-    this._removeFromParentsChildList(v);
-    this._parent[v] = parent;
-    this._children[parent][v] = true;
-    return this;
-  }
-  _removeFromParentsChildList(v) {
-    delete this._children[this._parent[v]][v];
-  }
-  parent(v) {
-    if (this._isCompound) {
-      var parent = this._parent[v];
-      if (parent !== GRAPH_NODE) {
-        return parent;
-      }
-    }
-  }
-  children(v) {
-    if (_.isUndefined(v)) {
-      v = GRAPH_NODE;
-    }
-    if (this._isCompound) {
-      var children = this._children[v];
-      if (children) {
-        return _.keys(children);
-      }
-    } else if (v === GRAPH_NODE) {
-      return this.nodes();
-    } else if (this.hasNode(v)) {
-      return [];
-    }
-  }
-  predecessors(v) {
-    var predsV = this._preds[v];
-    if (predsV) {
-      return _.keys(predsV);
-    }
-  }
-  successors(v) {
-    var sucsV = this._sucs[v];
-    if (sucsV) {
-      return _.keys(sucsV);
-    }
-  }
-  neighbors(v) {
-    var preds = this.predecessors(v);
-    if (preds) {
-      return _.union(preds, this.successors(v));
-    }
-  }
-  isLeaf(v) {
-    var neighbors;
-    if (this.isDirected()) {
-      neighbors = this.successors(v);
-    } else {
-      neighbors = this.neighbors(v);
-    }
-    return neighbors.length === 0;
-  }
-  filterNodes(filter) {
-    var copy = new this.constructor({
-      directed: this._isDirected,
-      multigraph: this._isMultigraph,
-      compound: this._isCompound
-    });
-    copy.setGraph(this.graph());
-    var self = this;
-    _.each(this._nodes, (value, v) => {
-      if (filter(v)) {
-        copy.setNode(v, value);
-      }
-    });
-    _.each(this._edgeObjs, (e) => {
-      if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
-        copy.setEdge(e, self.edge(e));
-      }
-    });
-    var parents = {};
-    function findParent(v) {
-      var parent = self.parent(v);
-      if (parent === void 0 || copy.hasNode(parent)) {
-        parents[v] = parent;
-        return parent;
-      } else if (parent in parents) {
-        return parents[parent];
-      } else {
-        return findParent(parent);
-      }
-    }
-    if (this._isCompound) {
-      _.each(copy.nodes(), (v) => {
-        copy.setParent(v, findParent(v));
-      });
-    }
-    return copy;
-  }
-  /* === Edge functions ========== */
-  setDefaultEdgeLabel(newDefault) {
-    if (!_.isFunction(newDefault)) {
-      newDefault = _.constant(newDefault);
-    }
-    this._defaultEdgeLabelFn = newDefault;
-    return this;
-  }
-  edgeCount() {
-    return this._edgeCount;
-  }
-  edges() {
-    return _.values(this._edgeObjs);
-  }
-  setPath(vs, value) {
-    var args = arguments;
-    _.reduce(vs, (v, w) => {
-      if (args.length > 1) {
-        this.setEdge(v, w, value);
-      } else {
-        this.setEdge(v, w);
-      }
-      return w;
-    });
-    return this;
-  }
-  /*
-   * setEdge(v, w, [value, [name]])
-   * setEdge({ v, w, [name] }, [value])
-   */
-  setEdge() {
-    var v, w, name, value;
-    var valueSpecified = false;
-    var arg0 = arguments[0];
-    if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
-      v = arg0.v;
-      w = arg0.w;
-      name = arg0.name;
-      if (arguments.length === 2) {
-        value = arguments[1];
-        valueSpecified = true;
-      }
-    } else {
-      v = arg0;
-      w = arguments[1];
-      name = arguments[3];
-      if (arguments.length > 2) {
-        value = arguments[2];
-        valueSpecified = true;
-      }
-    }
-    v = `${v}`;
-    w = `${w}`;
-    if (!_.isUndefined(name)) {
-      name = `${name}`;
-    }
-    var e = edgeArgsToId(this._isDirected, v, w, name);
-    if (_.has(this._edgeLabels, e)) {
-      if (valueSpecified) {
-        this._edgeLabels[e] = value;
-      }
-      return this;
-    }
-    if (!_.isUndefined(name) && !this._isMultigraph) {
-      throw new Error("Cannot set a named edge when isMultigraph = false");
-    }
-    this.setNode(v);
-    this.setNode(w);
-    this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
-    var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
-    v = edgeObj.v;
-    w = edgeObj.w;
-    Object.freeze(edgeObj);
-    this._edgeObjs[e] = edgeObj;
-    incrementOrInitEntry(this._preds[w], v);
-    incrementOrInitEntry(this._sucs[v], w);
-    this._in[w][e] = edgeObj;
-    this._out[v][e] = edgeObj;
-    this._edgeCount++;
-    return this;
-  }
-  edge(v, w, name) {
-    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
-    return this._edgeLabels[e];
-  }
-  hasEdge(v, w, name) {
-    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
-    return _.has(this._edgeLabels, e);
-  }
-  removeEdge(v, w, name) {
-    var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
-    var edge = this._edgeObjs[e];
-    if (edge) {
-      v = edge.v;
-      w = edge.w;
-      delete this._edgeLabels[e];
-      delete this._edgeObjs[e];
-      decrementOrRemoveEntry(this._preds[w], v);
-      decrementOrRemoveEntry(this._sucs[v], w);
-      delete this._in[w][e];
-      delete this._out[v][e];
-      this._edgeCount--;
-    }
-    return this;
-  }
-  inEdges(v, u) {
-    var inV = this._in[v];
-    if (inV) {
-      var edges = _.values(inV);
-      if (!u) {
-        return edges;
-      }
-      return _.filter(edges, (edge) => edge.v === u);
-    }
-  }
-  outEdges(v, w) {
-    var outV = this._out[v];
-    if (outV) {
-      var edges = _.values(outV);
-      if (!w) {
-        return edges;
-      }
-      return _.filter(edges, (edge) => edge.w === w);
-    }
-  }
-  nodeEdges(v, w) {
-    var inEdges = this.inEdges(v, w);
-    if (inEdges) {
-      return inEdges.concat(this.outEdges(v, w));
-    }
-  }
-};
-Graph.prototype._nodeCount = 0;
-Graph.prototype._edgeCount = 0;
-function incrementOrInitEntry(map, k) {
-  if (map[k]) {
-    map[k]++;
-  } else {
-    map[k] = 1;
-  }
-}
-function decrementOrRemoveEntry(map, k) {
-  if (!--map[k]) {
-    delete map[k];
-  }
-}
-function edgeArgsToId(isDirected, v_, w_, name) {
-  var v = `${v_}`;
-  var w = `${w_}`;
-  if (!isDirected && v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
-  }
-  return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name);
-}
-function edgeArgsToObj(isDirected, v_, w_, name) {
-  var v = `${v_}`;
-  var w = `${w_}`;
-  if (!isDirected && v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
-  }
-  var edgeObj = { v, w };
-  if (name) {
-    edgeObj.name = name;
-  }
-  return edgeObj;
-}
-function edgeObjToId(isDirected, edgeObj) {
-  return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
-}
-
-// src/dagre/data/list.js
-var List = class {
-  constructor() {
-    var sentinel = {};
-    sentinel._next = sentinel._prev = sentinel;
-    this._sentinel = sentinel;
-  }
-  dequeue() {
-    var sentinel = this._sentinel;
-    var entry = sentinel._prev;
-    if (entry !== sentinel) {
-      unlink(entry);
-      return entry;
-    }
-  }
-  enqueue(entry) {
-    var sentinel = this._sentinel;
-    if (entry._prev && entry._next) {
-      unlink(entry);
-    }
-    entry._next = sentinel._next;
-    sentinel._next._prev = entry;
-    sentinel._next = entry;
-    entry._prev = sentinel;
-  }
-  toString() {
-    var strs = [];
-    var sentinel = this._sentinel;
-    var curr = sentinel._prev;
-    while (curr !== sentinel) {
-      strs.push(JSON.stringify(curr, filterOutLinks));
-      curr = curr._prev;
-    }
-    return `[${strs.join(", ")}]`;
-  }
-};
-function unlink(entry) {
-  entry._prev._next = entry._next;
-  entry._next._prev = entry._prev;
-  delete entry._next;
-  delete entry._prev;
-}
-function filterOutLinks(k, v) {
-  if (k !== "_next" && k !== "_prev") {
-    return v;
-  }
-}
-
-// src/dagre/greedy-fas.js
-var DEFAULT_WEIGHT_FN = _.constant(1);
-function greedyFAS(g, weightFn) {
-  if (g.nodeCount() <= 1) {
-    return [];
-  }
-  var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
-  return _.flatten(_.map(results, (e) => g.outEdges(e.v, e.w)));
-}
-function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
-  var 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 (var 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;
-}
-function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : void 0;
-  _.forEach(g.inEdges(entry.v), (edge) => {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
-    if (collectPredecessors) {
-      results.push({ v: edge.v, w: edge.w });
-    }
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-  _.forEach(g.outEdges(entry.v), (edge) => {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
-    wEntry.in -= weight;
-    assignBucket(buckets, zeroIdx, wEntry);
-  });
-  g.removeNode(entry.v);
-  return results;
-}
-function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
-  _.forEach(g.nodes(), (v) => {
-    fasGraph.setNode(v, { v, in: 0, out: 0 });
-  });
-  _.forEach(g.edges(), (e) => {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var 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);
-  });
-  var buckets = _.range(maxOut + maxIn + 3).map(() => new List());
-  var zeroIdx = maxIn + 1;
-  _.forEach(fasGraph.nodes(), (v) => {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-  return { graph: fasGraph, buckets, zeroIdx };
-}
-function 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);
-  }
-}
-
-// src/dagre/acyclic.js
-function run(g) {
-  var fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
-  _.forEach(fas, (e) => {
-    var label = g.edge(e);
-    g.removeEdge(e);
-    label.forwardName = e.name;
-    label.reversed = true;
-    g.setEdge(e.w, e.v, label, _.uniqueId("rev"));
-  });
-  function weightFn(g2) {
-    return (e) => g2.edge(e).weight;
-  }
-}
-function dfsFAS(g) {
-  var fas = [];
-  var stack = {};
-  var visited = {};
-  function dfs3(v) {
-    if (_.has(visited, v)) {
-      return;
-    }
-    visited[v] = true;
-    stack[v] = true;
-    _.forEach(g.outEdges(v), (e) => {
-      if (_.has(stack, e.w)) {
-        fas.push(e);
-      } else {
-        dfs3(e.w);
-      }
-    });
-    delete stack[v];
-  }
-  _.forEach(g.nodes(), dfs3);
-  return fas;
-}
-function undo(g) {
-  _.forEach(g.edges(), (e) => {
-    var label = g.edge(e);
-    if (label.reversed) {
-      g.removeEdge(e);
-      var forwardName = label.forwardName;
-      delete label.reversed;
-      delete label.forwardName;
-      g.setEdge(e.w, e.v, label, forwardName);
-    }
-  });
-}
-
-// src/dagre/util.js
-function addDummyNode(g, type, attrs, name) {
-  var v;
-  do {
-    v = _.uniqueId(name);
-  } while (g.hasNode(v));
-  attrs.dummy = type;
-  g.setNode(v, attrs);
-  return v;
-}
-function simplify(g) {
-  var simplified = new Graph().setGraph(g.graph());
-  _.forEach(g.nodes(), (v) => {
-    simplified.setNode(v, g.node(v));
-  });
-  _.forEach(g.edges(), (e) => {
-    var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
-    var label = g.edge(e);
-    simplified.setEdge(e.v, e.w, {
-      weight: simpleLabel.weight + label.weight,
-      minlen: Math.max(simpleLabel.minlen, label.minlen)
-    });
-  });
-  return simplified;
-}
-function asNonCompoundGraph(g) {
-  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(
-    g.graph()
-  );
-  _.forEach(g.nodes(), (v) => {
-    if (!g.children(v).length) {
-      simplified.setNode(v, g.node(v));
-    }
-  });
-  _.forEach(g.edges(), (e) => {
-    simplified.setEdge(e, g.edge(e));
-  });
-  return simplified;
-}
-function intersectRect(rect, point) {
-  var x = rect.x;
-  var y = rect.y;
-  var dx = point.x - x;
-  var dy = point.y - y;
-  var w = rect.width / 2;
-  var h = rect.height / 2;
-  if (!dx && !dy) {
-    throw new Error(
-      "Not possible to find intersection inside of the rectangle"
-    );
-  }
-  var sx, sy;
-  if (Math.abs(dy) * w > Math.abs(dx) * h) {
-    if (dy < 0) {
-      h = -h;
-    }
-    sx = h * dx / dy;
-    sy = h;
-  } else {
-    if (dx < 0) {
-      w = -w;
-    }
-    sx = w;
-    sy = w * dy / dx;
-  }
-  return { x: x + sx, y: y + sy };
-}
-function buildLayerMatrix(g) {
-  var layering = _.map(_.range(maxRank(g) + 1), () => []);
-  _.forEach(g.nodes(), (v) => {
-    var node = g.node(v);
-    var rank2 = node.rank;
-    if (!_.isUndefined(rank2)) {
-      layering[rank2][node.order] = v;
-    }
-  });
-  return layering;
-}
-function normalizeRanks(g) {
-  var min = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
-  _.forEach(g.nodes(), (v) => {
-    var node = g.node(v);
-    if (_.has(node, "rank")) {
-      node.rank -= min;
-    }
-  });
-}
-function removeEmptyRanks(g) {
-  var offset = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
-  var layers = [];
-  _.forEach(g.nodes(), (v) => {
-    var rank2 = g.node(v).rank - offset;
-    if (!layers[rank2]) {
-      layers[rank2] = [];
-    }
-    layers[rank2].push(v);
-  });
-  var delta = 0;
-  var nodeRankFactor = g.graph().nodeRankFactor;
-  _.forEach(layers, (vs, i) => {
-    if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {
-      --delta;
-    } else if (delta) {
-      _.forEach(vs, (v) => {
-        g.node(v).rank += delta;
-      });
-    }
-  });
-}
-function addBorderNode(g, prefix, rank2, order2) {
-  var node = {
-    width: 0,
-    height: 0
-  };
-  if (arguments.length >= 4) {
-    node.rank = rank2;
-    node.order = order2;
-  }
-  return addDummyNode(g, "border", node, prefix);
-}
-function maxRank(g) {
-  return _.max(
-    _.map(g.nodes(), (v) => {
-      var rank2 = g.node(v).rank;
-      if (!_.isUndefined(rank2)) {
-        return rank2;
-      }
-    })
-  );
-}
-function partition(collection, fn) {
-  var result = { lhs: [], rhs: [] };
-  _.forEach(collection, (value) => {
-    if (fn(value)) {
-      result.lhs.push(value);
-    } else {
-      result.rhs.push(value);
-    }
-  });
-  return result;
-}
-function time(name, fn) {
-  var start = _.now();
-  try {
-    return fn();
-  } finally {
-    console.log(`${name} time: ${_.now() - start}ms`);
-  }
-}
-function notime(_name, fn) {
-  return fn();
-}
-
-// src/dagre/add-border-segments.js
-function addBorderSegments(g) {
-  function dfs3(v) {
-    var children = g.children(v);
-    var node = g.node(v);
-    if (children.length) {
-      _.forEach(children, dfs3);
-    }
-    if (_.has(node, "minRank")) {
-      node.borderLeft = [];
-      node.borderRight = [];
-      for (var rank2 = node.minRank, maxRank2 = node.maxRank + 1; rank2 < maxRank2; ++rank2) {
-        addBorderNode2(g, "borderLeft", "_bl", v, node, rank2);
-        addBorderNode2(g, "borderRight", "_br", v, node, rank2);
-      }
-    }
-  }
-  _.forEach(g.children(), dfs3);
-}
-function addBorderNode2(g, prop, prefix, sg, sgNode, rank2) {
-  var label = { width: 0, height: 0, rank: rank2, borderType: prop };
-  var prev = sgNode[prop][rank2 - 1];
-  var curr = addDummyNode(g, "border", label, prefix);
-  sgNode[prop][rank2] = curr;
-  g.setParent(curr, sg);
-  if (prev) {
-    g.setEdge(prev, curr, { weight: 1 });
-  }
-}
-
-// src/dagre/coordinate-system.js
-function adjust(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapWidthHeight(g);
-  }
-}
-function undo2(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "bt" || rankDir === "rl") {
-    reverseY(g);
-  }
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapXY(g);
-    swapWidthHeight(g);
-  }
-}
-function swapWidthHeight(g) {
-  _.forEach(g.nodes(), (v) => {
-    swapWidthHeightOne(g.node(v));
-  });
-  _.forEach(g.edges(), (e) => {
-    swapWidthHeightOne(g.edge(e));
-  });
-}
-function swapWidthHeightOne(attrs) {
-  var w = attrs.width;
-  attrs.width = attrs.height;
-  attrs.height = w;
-}
-function reverseY(g) {
-  _.forEach(g.nodes(), (v) => {
-    reverseYOne(g.node(v));
-  });
-  _.forEach(g.edges(), (e) => {
-    var edge = g.edge(e);
-    _.forEach(edge.points, reverseYOne);
-    if (_.has(edge, "y")) {
-      reverseYOne(edge);
-    }
-  });
-}
-function reverseYOne(attrs) {
-  attrs.y = -attrs.y;
-}
-function swapXY(g) {
-  _.forEach(g.nodes(), (v) => {
-    swapXYOne(g.node(v));
-  });
-  _.forEach(g.edges(), (e) => {
-    var edge = g.edge(e);
-    _.forEach(edge.points, swapXYOne);
-    if (_.has(edge, "x")) {
-      swapXYOne(edge);
-    }
-  });
-}
-function swapXYOne(attrs) {
-  var x = attrs.x;
-  attrs.x = attrs.y;
-  attrs.y = x;
-}
-
-// src/dagre/nesting-graph.js
-function run2(g) {
-  var root = addDummyNode(g, "root", {}, "_root");
-  var depths = treeDepths(g);
-  var height = _.max(_.values(depths)) - 1;
-  var nodeSep = 2 * height + 1;
-  g.graph().nestingRoot = root;
-  _.forEach(g.edges(), (e) => {
-    g.edge(e).minlen *= nodeSep;
-  });
-  var weight = sumWeights(g) + 1;
-  _.forEach(g.children(), (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 = 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, (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 dfs3(v, depth) {
-    var children = g.children(v);
-    if (children?.length) {
-      _.forEach(children, (child) => {
-        dfs3(child, depth + 1);
-      });
-    }
-    depths[v] = depth;
-  }
-  _.forEach(g.children(), (v) => {
-    dfs3(v, 1);
-  });
-  return depths;
-}
-function sumWeights(g) {
-  return _.reduce(g.edges(), (acc, e) => acc + g.edge(e).weight, 0);
-}
-function cleanup(g) {
-  var graphLabel = g.graph();
-  g.removeNode(graphLabel.nestingRoot);
-  delete graphLabel.nestingRoot;
-  _.forEach(g.edges(), (e) => {
-    var edge = g.edge(e);
-    if (edge.nestingEdge) {
-      g.removeEdge(e);
-    }
-  });
-}
-
-// src/dagre/normalize.js
-function run3(g) {
-  g.graph().dummyChains = [];
-  _.forEach(g.edges(), (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 dummy, attrs, i;
-  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
-    edgeLabel.points = [];
-    attrs = {
-      width: 0,
-      height: 0,
-      edgeLabel,
-      edgeObj: e,
-      rank: vRank
-    };
-    dummy = 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 undo3(g) {
-  _.forEach(g.graph().dummyChains, (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);
-    }
-  });
-}
-
-// src/dagre/order/add-subgraph-constraints.js
-function addSubgraphConstraints(g, cg, vs) {
-  var prev = {}, rootPrev;
-  _.forEach(vs, (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;
-    }
-  });
-}
-
-// src/dagre/order/build-layer-graph.js
-function buildLayerGraph(g, rank2, relationship) {
-  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel((v) => g.node(v));
-  _.forEach(g.nodes(), (v) => {
-    var node = g.node(v), parent = g.parent(v);
-    if (node.rank === rank2 || node.minRank <= rank2 && rank2 <= node.maxRank) {
-      result.setNode(v);
-      result.setParent(v, parent || root);
-      _.forEach(g[relationship](v), (e) => {
-        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !_.isUndefined(edge) ? edge.weight : 0;
-        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
-      });
-      if (_.has(node, "minRank")) {
-        result.setNode(v, {
-          borderLeft: node.borderLeft[rank2],
-          borderRight: node.borderRight[rank2]
-        });
-      }
-    }
-  });
-  return result;
-}
-function createRootNode(g) {
-  var v;
-  while (g.hasNode(v = _.uniqueId("_root"))) ;
-  return v;
-}
-
-// src/dagre/order/cross-count.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(
-    southLayer,
-    _.map(southLayer, (_v, i) => i)
-  );
-  var southEntries = _.flatten(
-    _.map(
-      northLayer,
-      (v) => _.sortBy(
-        _.map(g.outEdges(v), (e) => ({
-          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(new Array(treeSize), () => 0);
-  var cc = 0;
-  _.forEach(
-    // @ts-expect-error
-    southEntries.forEach((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;
-}
-
-// src/dagre/order/init-order.js
-function initOrder(g) {
-  var visited = {};
-  var simpleNodes = _.filter(g.nodes(), (v) => !g.children(v).length);
-  var maxRank2 = _.max(_.map(simpleNodes, (v) => g.node(v).rank));
-  var layers = _.map(_.range(maxRank2 + 1), () => []);
-  function dfs3(v) {
-    if (_.has(visited, v)) return;
-    visited[v] = true;
-    var node = g.node(v);
-    layers[node.rank].push(v);
-    _.forEach(g.successors(v), dfs3);
-  }
-  var orderedVs = _.sortBy(simpleNodes, (v) => g.node(v).rank);
-  _.forEach(orderedVs, dfs3);
-  return layers;
-}
-
-// src/dagre/order/barycenter.js
-function barycenter(g, movable) {
-  return _.map(movable, (v) => {
-    var inV = g.inEdges(v);
-    if (!inV.length) {
-      return { v };
-    } else {
-      var result = _.reduce(
-        inV,
-        (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
-      };
-    }
-  });
-}
-
-// src/dagre/order/resolve-conflicts.js
-function resolveConflicts(entries, cg) {
-  var mappedEntries = {};
-  _.forEach(entries, (entry, i) => {
-    var tmp = mappedEntries[entry.v] = {
-      indegree: 0,
-      in: [],
-      out: [],
-      vs: [entry.v],
-      i
-    };
-    if (!_.isUndefined(entry.barycenter)) {
-      tmp.barycenter = entry.barycenter;
-      tmp.weight = entry.weight;
-    }
-  });
-  _.forEach(cg.edges(), (e) => {
-    var entryV = mappedEntries[e.v];
-    var entryW = mappedEntries[e.w];
-    if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
-      entryW.indegree++;
-      entryV.out.push(mappedEntries[e.w]);
-    }
-  });
-  var sourceSet = _.filter(mappedEntries, (entry) => {
-    return !entry.indegree;
-  });
-  return doResolveConflicts(sourceSet);
-}
-function doResolveConflicts(sourceSet) {
-  var entries = [];
-  function handleIn(vEntry) {
-    return (uEntry) => {
-      if (uEntry.merged) {
-        return;
-      }
-      if (_.isUndefined(uEntry.barycenter) || _.isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) {
-        mergeEntries(vEntry, uEntry);
-      }
-    };
-  }
-  function handleOut(vEntry) {
-    return (wEntry) => {
-      wEntry.in.push(vEntry);
-      if (--wEntry.indegree === 0) {
-        sourceSet.push(wEntry);
-      }
-    };
-  }
-  while (sourceSet.length) {
-    var entry = sourceSet.pop();
-    entries.push(entry);
-    _.forEach(entry.in.reverse(), handleIn(entry));
-    _.forEach(entry.out, handleOut(entry));
-  }
-  return _.map(
-    _.filter(entries, (entry2) => !entry2.merged),
-    (entry2) => _.pick(entry2, ["vs", "i", "barycenter", "weight"])
-  );
-}
-function mergeEntries(target, source) {
-  var sum = 0;
-  var weight = 0;
-  if (target.weight) {
-    sum += target.barycenter * target.weight;
-    weight += target.weight;
-  }
-  if (source.weight) {
-    sum += source.barycenter * source.weight;
-    weight += source.weight;
-  }
-  target.vs = source.vs.concat(target.vs);
-  target.barycenter = sum / weight;
-  target.weight = weight;
-  target.i = Math.min(source.i, target.i);
-  source.merged = true;
-}
-
-// src/dagre/order/sort.js
-function sort(entries, biasRight) {
-  var parts = partition(entries, (entry) => _.has(entry, "barycenter"));
-  var sortable = parts.lhs, unsortable = _.sortBy(parts.rhs, (entry) => -entry.i), vs = [], sum = 0, weight = 0, vsIndex = 0;
-  sortable.sort(compareWithBias(!!biasRight));
-  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-  _.forEach(sortable, (entry) => {
-    vsIndex += entry.vs.length;
-    vs.push(entry.vs);
-    sum += entry.barycenter * entry.weight;
-    weight += entry.weight;
-    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-  });
-  var result = { vs: _.flatten(vs) };
-  if (weight) {
-    result.barycenter = sum / weight;
-    result.weight = weight;
-  }
-  return result;
-}
-function consumeUnsortable(vs, unsortable, index) {
-  var last;
-  while (unsortable.length && (last = _.last(unsortable)).i <= index) {
-    unsortable.pop();
-    vs.push(last.vs);
-    index++;
-  }
-  return index;
-}
-function compareWithBias(bias) {
-  return (entryV, entryW) => {
-    if (entryV.barycenter < entryW.barycenter) {
-      return -1;
-    } else if (entryV.barycenter > entryW.barycenter) {
-      return 1;
-    }
-    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
-  };
-}
-
-// src/dagre/order/sort-subgraph.js
-function sortSubgraph(g, v, cg, biasRight) {
-  var movable = g.children(v);
-  var node = g.node(v);
-  var bl = node ? node.borderLeft : void 0;
-  var br = node ? node.borderRight : void 0;
-  var subgraphs = {};
-  if (bl) {
-    movable = _.filter(movable, (w) => w !== bl && w !== br);
-  }
-  var barycenters = barycenter(g, movable);
-  _.forEach(barycenters, (entry) => {
-    if (g.children(entry.v).length) {
-      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
-      subgraphs[entry.v] = subgraphResult;
-      if (_.has(subgraphResult, "barycenter")) {
-        mergeBarycenters(entry, subgraphResult);
-      }
-    }
-  });
-  var entries = resolveConflicts(barycenters, cg);
-  expandSubgraphs(entries, subgraphs);
-  var result = sort(entries, biasRight);
-  if (bl) {
-    result.vs = _.flatten([bl, result.vs, br]);
-    if (g.predecessors(bl).length) {
-      var blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
-      if (!_.has(result, "barycenter")) {
-        result.barycenter = 0;
-        result.weight = 0;
-      }
-      result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
-      result.weight += 2;
-    }
-  }
-  return result;
-}
-function expandSubgraphs(entries, subgraphs) {
-  _.forEach(entries, (entry) => {
-    entry.vs = _.flatten(
-      entry.vs.map((v) => {
-        if (subgraphs[v]) {
-          return subgraphs[v].vs;
-        }
-        return v;
-      })
-    );
-  });
-}
-function mergeBarycenters(target, other) {
-  if (!_.isUndefined(target.barycenter)) {
-    target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
-    target.weight += other.weight;
-  } else {
-    target.barycenter = other.barycenter;
-    target.weight = other.weight;
-  }
-}
-
-// src/dagre/order/index.js
-function order(g) {
-  var maxRank2 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank2 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(
-    g,
-    _.range(maxRank2 - 1, -1, -1),
-    "outEdges"
-  );
-  var layering = initOrder(g);
-  assignOrder(g, layering);
-  var bestCC = Number.POSITIVE_INFINITY, best;
-  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
-    sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
-    layering = buildLayerMatrix(g);
-    var cc = crossCount(g, layering);
-    if (cc < bestCC) {
-      lastBest = 0;
-      best = _.cloneDeep(layering);
-      bestCC = cc;
-    }
-  }
-  assignOrder(g, best);
-}
-function buildLayerGraphs(g, ranks, relationship) {
-  return _.map(ranks, (rank2) => buildLayerGraph(g, rank2, relationship));
-}
-function sweepLayerGraphs(layerGraphs, biasRight) {
-  var cg = new Graph();
-  _.forEach(layerGraphs, (lg) => {
-    var root = lg.graph().root;
-    var sorted = sortSubgraph(lg, root, cg, biasRight);
-    _.forEach(sorted.vs, (v, i) => {
-      lg.node(v).order = i;
-    });
-    addSubgraphConstraints(lg, cg, sorted.vs);
-  });
-}
-function assignOrder(g, layering) {
-  _.forEach(layering, (layer) => {
-    _.forEach(layer, (v, i) => {
-      g.node(v).order = i;
-    });
-  });
-}
-
-// src/dagre/parent-dummy-chains.js
-function parentDummyChains(g) {
-  var postorderNums = postorder(g);
-  _.forEach(g.graph().dummyChains, (v) => {
-    var node = g.node(v);
-    var edgeObj = node.edgeObj;
-    var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-    var path = pathData.path;
-    var lca = pathData.lca;
-    var pathIdx = 0;
-    var pathV = path[pathIdx];
-    var ascending = true;
-    while (v !== edgeObj.w) {
-      node = g.node(v);
-      if (ascending) {
-        while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
-          pathIdx++;
-        }
-        if (pathV === lca) {
-          ascending = false;
-        }
-      }
-      if (!ascending) {
-        while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
-          pathIdx++;
-        }
-        pathV = path[pathIdx];
-      }
-      g.setParent(v, pathV);
-      v = g.successors(v)[0];
-    }
-  });
-}
-function findPath(g, postorderNums, v, w) {
-  var vPath = [];
-  var wPath = [];
-  var low = Math.min(postorderNums[v].low, postorderNums[w].low);
-  var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
-  var parent;
-  var lca;
-  parent = v;
-  do {
-    parent = g.parent(parent);
-    vPath.push(parent);
-  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
-  lca = parent;
-  parent = w;
-  while ((parent = g.parent(parent)) !== lca) {
-    wPath.push(parent);
-  }
-  return { path: vPath.concat(wPath.reverse()), lca };
-}
-function postorder(g) {
-  var result = {};
-  var lim = 0;
-  function dfs3(v) {
-    var low = lim;
-    _.forEach(g.children(v), dfs3);
-    result[v] = { low, lim: lim++ };
-  }
-  _.forEach(g.children(), dfs3);
-  return result;
-}
-
-// src/dagre/position/bk.js
-function findType1Conflicts(g, layering) {
-  var conflicts = {};
-  function visitLayer(prevLayer, layer) {
-    var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = _.last(layer);
-    _.forEach(layer, (v, i) => {
-      var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
-      if (w || v === lastNode) {
-        _.forEach(layer.slice(scanPos, i + 1), (scanNode) => {
-          _.forEach(g.predecessors(scanNode), (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), (i) => {
-      v = south[i];
-      if (g.node(v).dummy) {
-        _.forEach(g.predecessors(v), (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, (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), (u) => 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, (layer) => {
-    _.forEach(layer, (v, order2) => {
-      root[v] = v;
-      align[v] = v;
-      pos[v] = order2;
-    });
-  });
-  _.forEach(layering, (layer) => {
-    var prevIdx = -1;
-    _.forEach(layer, (v) => {
-      var ws = neighborFn(v);
-      if (ws.length) {
-        ws = _.sortBy(ws, (w2) => 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((acc, e) => Math.max(acc, xs[e.v] + blockG.edge(e)), 0);
-  }
-  function pass2(elem) {
-    var min = blockG.outEdges(elem).reduce(
-      (acc, e) => 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, (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, (layer) => {
-    var u;
-    _.forEach(layer, (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), (xs) => {
-    var max = Number.NEGATIVE_INFINITY;
-    var min = Number.POSITIVE_INFINITY;
-    _.forIn(xs, (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"], (vert) => {
-    _.forEach(["l", "r"], (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, (x) => x + delta);
-      }
-    });
-  });
-}
-function balance(xss, align) {
-  return _.mapValues(xss.ul, (_ignore, v) => {
-    if (align) {
-      return xss[align.toLowerCase()][v];
-    } else {
-      var xs = _.sortBy(_.map(xss, v));
-      return (xs[1] + xs[2]) / 2;
-    }
-  });
-}
-function positionX(g) {
-  var layering = buildLayerMatrix(g);
-  var conflicts = _.merge(
-    findType1Conflicts(g, layering),
-    findType2Conflicts(g, layering)
-  );
-  var xss = {};
-  var adjustedLayering;
-  _.forEach(["u", "d"], (vert) => {
-    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
-    _.forEach(["l", "r"], (horiz) => {
-      if (horiz === "r") {
-        adjustedLayering = _.map(
-          adjustedLayering,
-          (inner) => _.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, (x) => -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 (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;
-}
-
-// src/dagre/position/index.js
-function position(g) {
-  g = asNonCompoundGraph(g);
-  positionY(g);
-  _.forOwn(positionX(g), (x, v) => {
-    g.node(v).x = x;
-  });
-}
-function positionY(g) {
-  var layering = buildLayerMatrix(g);
-  var rankSep = g.graph().ranksep;
-  var prevY = 0;
-  _.forEach(layering, (layer) => {
-    var maxHeight = _.max(_.map(layer, (v) => g.node(v).height));
-    _.forEach(layer, (v) => {
-      g.node(v).y = prevY + maxHeight / 2;
-    });
-    prevY += maxHeight + rankSep;
-  });
-}
-
-// src/dagre/rank/util.js
-function longestPath(g) {
-  var visited = {};
-  function dfs3(v) {
-    var label = g.node(v);
-    if (_.has(visited, v)) {
-      return label.rank;
-    }
-    visited[v] = true;
-    var rank2 = _.min(_.map(g.outEdges(v), (e) => dfs3(e.w) - g.edge(e).minlen));
-    if (rank2 === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
-    rank2 === void 0 || // return value of _.map([]) for Lodash 4
-    rank2 === null) {
-      rank2 = 0;
-    }
-    return label.rank = rank2;
-  }
-  _.forEach(g.sources(), dfs3);
-}
-function slack(g, e) {
-  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
-}
-
-// src/dagre/rank/feasible-tree.js
-function feasibleTree(g) {
-  var t = new Graph({ directed: false });
-  var start = g.nodes()[0];
-  var size = g.nodeCount();
-  t.setNode(start, {});
-  var edge, delta;
-  while (tightTree(t, g) < size) {
-    edge = findMinSlackEdge(t, g);
-    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
-    shiftRanks(t, g, delta);
-  }
-  return t;
-}
-function tightTree(t, g) {
-  function dfs3(v) {
-    _.forEach(g.nodeEdges(v), (e) => {
-      var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
-      if (!t.hasNode(w) && !slack(g, e)) {
-        t.setNode(w, {});
-        t.setEdge(v, w, {});
-        dfs3(w);
-      }
-    });
-  }
-  _.forEach(t.nodes(), dfs3);
-  return t.nodeCount();
-}
-function findMinSlackEdge(t, g) {
-  return _.minBy(g.edges(), (e) => {
-    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
-      return slack(g, e);
-    }
-  });
-}
-function shiftRanks(t, g, delta) {
-  _.forEach(t.nodes(), (v) => {
-    g.node(v).rank += delta;
-  });
-}
-
-// src/graphlib/alg/dijkstra.js
-_.constant(1);
-
-// src/graphlib/alg/floyd-warshall.js
-_.constant(1);
-function CycleException() {
-}
-CycleException.prototype = new Error();
-
-// src/graphlib/alg/dfs.js
-function dfs2(g, vs, order2) {
-  if (!_.isArray(vs)) {
-    vs = [vs];
-  }
-  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
-  var acc = [];
-  var visited = {};
-  _.each(vs, (v) => {
-    if (!g.hasNode(v)) {
-      throw new Error(`Graph does not have node: ${v}`);
-    }
-    doDfs(g, v, order2 === "post", visited, navigation, acc);
-  });
-  return acc;
-}
-function doDfs(g, v, postorder3, visited, navigation, acc) {
-  if (!_.has(visited, v)) {
-    visited[v] = true;
-    if (!postorder3) {
-      acc.push(v);
-    }
-    _.each(navigation(v), (w) => {
-      doDfs(g, w, postorder3, visited, navigation, acc);
-    });
-    if (postorder3) {
-      acc.push(v);
-    }
-  }
-}
-
-// src/graphlib/alg/postorder.js
-function postorder2(g, vs) {
-  return dfs2(g, vs, "post");
-}
-
-// src/graphlib/alg/preorder.js
-function preorder(g, vs) {
-  return dfs2(g, vs, "pre");
-}
-
-// src/dagre/rank/network-simplex.js
-networkSimplex.initLowLimValues = initLowLimValues;
-networkSimplex.initCutValues = initCutValues;
-networkSimplex.calcCutValue = calcCutValue;
-networkSimplex.leaveEdge = leaveEdge;
-networkSimplex.enterEdge = enterEdge;
-networkSimplex.exchangeEdges = exchangeEdges;
-function networkSimplex(g) {
-  g = simplify(g);
-  longestPath(g);
-  var t = feasibleTree(g);
-  initLowLimValues(t);
-  initCutValues(t, g);
-  var e, f;
-  while (e = leaveEdge(t)) {
-    f = enterEdge(t, g, e);
-    exchangeEdges(t, g, e, f);
-  }
-}
-function initCutValues(t, g) {
-  var vs = postorder2(t, t.nodes());
-  vs = vs.slice(0, vs.length - 1);
-  _.forEach(vs, (v) => {
-    assignCutValue(t, g, v);
-  });
-}
-function assignCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
-}
-function calcCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  var childIsTail = true;
-  var graphEdge = g.edge(child, parent);
-  var cutValue = 0;
-  if (!graphEdge) {
-    childIsTail = false;
-    graphEdge = g.edge(parent, child);
-  }
-  cutValue = graphEdge.weight;
-  _.forEach(g.nodeEdges(child), (e) => {
-    var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
-    if (other !== parent) {
-      var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
-      cutValue += pointsToHead ? otherWeight : -otherWeight;
-      if (isTreeEdge(t, child, other)) {
-        var otherCutValue = t.edge(child, other).cutvalue;
-        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
-      }
-    }
-  });
-  return cutValue;
-}
-function initLowLimValues(tree, root) {
-  if (arguments.length < 2) {
-    root = tree.nodes()[0];
-  }
-  dfsAssignLowLim(tree, {}, 1, root);
-}
-function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
-  var low = nextLim;
-  var label = tree.node(v);
-  visited[v] = true;
-  _.forEach(tree.neighbors(v), (w) => {
-    if (!_.has(visited, w)) {
-      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
-    }
-  });
-  label.low = low;
-  label.lim = nextLim++;
-  if (parent) {
-    label.parent = parent;
-  } else {
-    delete label.parent;
-  }
-  return nextLim;
-}
-function leaveEdge(tree) {
-  return _.find(tree.edges(), (e) => tree.edge(e).cutvalue < 0);
-}
-function enterEdge(t, g, edge) {
-  var v = edge.v;
-  var w = edge.w;
-  if (!g.hasEdge(v, w)) {
-    v = edge.w;
-    w = edge.v;
-  }
-  var vLabel = t.node(v);
-  var wLabel = t.node(w);
-  var tailLabel = vLabel;
-  var flip = false;
-  if (vLabel.lim > wLabel.lim) {
-    tailLabel = wLabel;
-    flip = true;
-  }
-  var candidates = _.filter(
-    g.edges(),
-    (edge2) => flip === isDescendant(t, t.node(edge2.v), tailLabel) && flip !== isDescendant(t, t.node(edge2.w), tailLabel)
-  );
-  return _.minBy(candidates, (edge2) => slack(g, edge2));
-}
-function exchangeEdges(t, g, e, f) {
-  var v = e.v;
-  var w = e.w;
-  t.removeEdge(v, w);
-  t.setEdge(f.v, f.w, {});
-  initLowLimValues(t);
-  initCutValues(t, g);
-  updateRanks(t, g);
-}
-function updateRanks(t, g) {
-  var root = _.find(t.nodes(), (v) => !g.node(v).parent);
-  var vs = preorder(t, root);
-  vs = vs.slice(1);
-  _.forEach(vs, (v) => {
-    var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
-    if (!edge) {
-      edge = g.edge(parent, v);
-      flipped = true;
-    }
-    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
-  });
-}
-function isTreeEdge(tree, u, v) {
-  return tree.hasEdge(u, v);
-}
-function isDescendant(_tree, vLabel, rootLabel) {
-  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
-}
-
-// src/dagre/rank/index.js
-function rank(g) {
-  switch (g.graph().ranker) {
-    case "network-simplex":
-      networkSimplexRanker(g);
-      break;
-    case "tight-tree":
-      tightTreeRanker(g);
-      break;
-    case "longest-path":
-      longestPathRanker(g);
-      break;
-    default:
-      networkSimplexRanker(g);
-  }
-}
-var longestPathRanker = longestPath;
-function tightTreeRanker(g) {
-  longestPath(g);
-  feasibleTree(g);
-}
-function networkSimplexRanker(g) {
-  networkSimplex(g);
-}
-
-// src/dagre/layout.js
-function layout(g, opts) {
-  var time2 = opts?.debugTiming ? time : notime;
-  time2("layout", () => {
-    var layoutGraph = time2("  buildLayoutGraph", () => buildLayoutGraph(g));
-    time2("  runLayout", () => {
-      runLayout(layoutGraph, time2);
-    });
-    time2("  updateInputGraph", () => {
-      updateInputGraph(g, layoutGraph);
-    });
-  });
-}
-function runLayout(g, time2) {
-  time2("    makeSpaceForEdgeLabels", () => {
-    makeSpaceForEdgeLabels(g);
-  });
-  time2("    removeSelfEdges", () => {
-    removeSelfEdges(g);
-  });
-  time2("    acyclic", () => {
-    run(g);
-  });
-  time2("    nestingGraph.run", () => {
-    run2(g);
-  });
-  time2("    rank", () => {
-    rank(asNonCompoundGraph(g));
-  });
-  time2("    injectEdgeLabelProxies", () => {
-    injectEdgeLabelProxies(g);
-  });
-  time2("    removeEmptyRanks", () => {
-    removeEmptyRanks(g);
-  });
-  time2("    nestingGraph.cleanup", () => {
-    cleanup(g);
-  });
-  time2("    normalizeRanks", () => {
-    normalizeRanks(g);
-  });
-  time2("    assignRankMinMax", () => {
-    assignRankMinMax(g);
-  });
-  time2("    removeEdgeLabelProxies", () => {
-    removeEdgeLabelProxies(g);
-  });
-  time2("    normalize.run", () => {
-    run3(g);
-  });
-  time2("    parentDummyChains", () => {
-    parentDummyChains(g);
-  });
-  time2("    addBorderSegments", () => {
-    addBorderSegments(g);
-  });
-  time2("    order", () => {
-    order(g);
-  });
-  time2("    insertSelfEdges", () => {
-    insertSelfEdges(g);
-  });
-  time2("    adjustCoordinateSystem", () => {
-    adjust(g);
-  });
-  time2("    position", () => {
-    position(g);
-  });
-  time2("    positionSelfEdges", () => {
-    positionSelfEdges(g);
-  });
-  time2("    removeBorderNodes", () => {
-    removeBorderNodes(g);
-  });
-  time2("    normalize.undo", () => {
-    undo3(g);
-  });
-  time2("    fixupEdgeLabelCoords", () => {
-    fixupEdgeLabelCoords(g);
-  });
-  time2("    undoCoordinateSystem", () => {
-    undo2(g);
-  });
-  time2("    translateGraph", () => {
-    translateGraph(g);
-  });
-  time2("    assignNodeIntersects", () => {
-    assignNodeIntersects(g);
-  });
-  time2("    reversePoints", () => {
-    reversePointsForReversedEdges(g);
-  });
-  time2("    acyclic.undo", () => {
-    undo(g);
-  });
-}
-function updateInputGraph(inputGraph, layoutGraph) {
-  _.forEach(inputGraph.nodes(), (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(), (e) => {
-    var inputLabel = inputGraph.edge(e);
-    var layoutLabel = layoutGraph.edge(e);
-    inputLabel.points = layoutLabel.points;
-    if (_.has(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({ multigraph: true, compound: true });
-  var graph = canonicalize(inputGraph.graph());
-  g.setGraph(
-    _.merge(
-      {},
-      graphDefaults,
-      selectNumberAttrs(graph, graphNumAttrs),
-      _.pick(graph, graphAttrs)
-    )
-  );
-  _.forEach(inputGraph.nodes(), (v) => {
-    var node = canonicalize(inputGraph.node(v));
-    g.setNode(
-      v,
-      _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults)
-    );
-    g.setParent(v, inputGraph.parent(v));
-  });
-  _.forEach(inputGraph.edges(), (e) => {
-    var edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(
-      e,
-      _.merge(
-        {},
-        edgeDefaults,
-        selectNumberAttrs(edge, edgeNumAttrs),
-        _.pick(edge, edgeAttrs)
-      )
-    );
-  });
-  return g;
-}
-function makeSpaceForEdgeLabels(g) {
-  var graph = g.graph();
-  graph.ranksep /= 2;
-  _.forEach(g.edges(), (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;
-      }
-    }
-  });
-}
-function injectEdgeLabelProxies(g) {
-  _.forEach(g.edges(), (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 };
-      addDummyNode(g, "edge-proxy", label, "_ep");
-    }
-  });
-}
-function assignRankMinMax(g) {
-  var maxRank2 = 0;
-  _.forEach(g.nodes(), (v) => {
-    var node = g.node(v);
-    if (node.borderTop) {
-      node.minRank = g.node(node.borderTop).rank;
-      node.maxRank = g.node(node.borderBottom).rank;
-      maxRank2 = _.max(maxRank2, node.maxRank);
-    }
-  });
-  g.graph().maxRank = maxRank2;
-}
-function removeEdgeLabelProxies(g) {
-  _.forEach(g.nodes(), (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(), (v) => {
-    getExtremes(g.node(v));
-  });
-  _.forEach(g.edges(), (e) => {
-    var edge = g.edge(e);
-    if (_.has(edge, "x")) {
-      getExtremes(edge);
-    }
-  });
-  minX -= marginX;
-  minY -= marginY;
-  _.forEach(g.nodes(), (v) => {
-    var node = g.node(v);
-    node.x -= minX;
-    node.y -= minY;
-  });
-  _.forEach(g.edges(), (e) => {
-    var edge = g.edge(e);
-    _.forEach(edge.points, (p) => {
-      p.x -= minX;
-      p.y -= minY;
-    });
-    if (_.has(edge, "x")) {
-      edge.x -= minX;
-    }
-    if (_.has(edge, "y")) {
-      edge.y -= minY;
-    }
-  });
-  graphLabel.width = maxX - minX + marginX;
-  graphLabel.height = maxY - minY + marginY;
-}
-function assignNodeIntersects(g) {
-  _.forEach(g.edges(), (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(), (e) => {
-    var edge = g.edge(e);
-    if (_.has(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(), (e) => {
-    var edge = g.edge(e);
-    if (edge.reversed) {
-      edge.points.reverse();
-    }
-  });
-}
-function removeBorderNodes(g) {
-  _.forEach(g.nodes(), (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(), (v) => {
-    if (g.node(v).dummy === "border") {
-      g.removeNode(v);
-    }
-  });
-}
-function removeSelfEdges(g) {
-  _.forEach(g.edges(), (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 = buildLayerMatrix(g);
-  _.forEach(layers, (layer) => {
-    var orderShift = 0;
-    _.forEach(layer, (v, i) => {
-      var node = g.node(v);
-      node.order = i + orderShift;
-      _.forEach(node.selfEdges, (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(), (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(_.pick(obj, attrs), Number);
-}
-function canonicalize(attrs) {
-  var newAttrs = {};
-  _.forEach(attrs, (v, k) => {
-    newAttrs[k.toLowerCase()] = v;
-  });
-  return newAttrs;
-}
-
-// src/layout/buildFlatCharts.ts
-function buildFlatCharts({
-  lodash,
-  transitions = [],
-  newId,
-  getStateParams,
-  getTransitionParams,
-  padding = [5, 5],
-  initialStateKey = "<initial>",
-  finalStateKey = "<final>",
-  vertical = false,
-  direction
-}) {
-  const prevLodash = getLodash();
-  try {
-    setLodash(lodash);
-    const rankdir = direction || (vertical ? "tb" : "lr");
-    const graph = new Graph({
-      directed: true,
-      multigraph: true
-    }).setGraph({ rankdir, multigraph: true });
-    const nodesIndex = {};
-    const getStateNodeId = (key, state = key) => {
-      let id = nodesIndex[key];
-      if (!id) {
-        id = nodesIndex[key] = newId("s");
-        const params = getStateParams(key, state);
-        graph.setNode(id, { id, ...params });
-      }
-      return id;
-    };
-    for (const [fromState, event, toState] of transitions) {
-      const fromStateKey = fromState || initialStateKey;
-      const from = getStateNodeId(fromStateKey, fromState);
-      const toStateKey = toState || finalStateKey;
-      const to = getStateNodeId(toStateKey, toState);
-      const params = getTransitionParams(fromStateKey, event, toStateKey);
-      const edgeId = newId("t");
-      graph.setEdge(
-        from,
-        to,
-        {
-          id: edgeId,
-          ...params
-        },
-        edgeId
-      );
-    }
-    layout(graph, { rankdir });
-    const [top, right, bottom, left] = getPadding(padding);
-    const nodes = graph.nodes().map((id) => {
-      const n = graph.node(id);
-      n.x += -n.width / 2;
-      n.y += -n.height / 2;
-      return n;
-    });
-    const edges = graph.edges().map(({ v, w, name }) => {
-      const e = graph.edge(v, w, name);
-      e.x += -e.width / 2;
-      e.y += -e.height / 2;
-      return e;
-    });
-    let x = 0;
-    let y = 0;
-    let width2 = 0;
-    let height = 0;
-    const addCoords = (node) => {
-      x = Math.min(x, node.x);
-      y = Math.min(y, node.y);
-      width2 = Math.max(width2, node.x + node.width);
-      height = Math.max(height, node.y + node.height);
-    };
-    nodes.forEach(addCoords);
-    edges.forEach(addCoords);
-    edges.forEach((edge) => {
-      for (const point of edge.points) {
-        x = Math.min(x, edge.x);
-        y = Math.min(y, edge.y);
-        width2 = Math.max(width2, point.x);
-        height = Math.max(height, point.y);
-      }
-    });
-    width2 += left + right;
-    height += bottom + top;
-    const updateCoords = (node) => {
-      node.x = Math.round(node.x + left);
-      node.y = Math.round(node.y + bottom);
-    };
-    const updateBox = (node) => {
-      updateCoords(node);
-      node.y = Math.round(node.y + node.height);
-    };
-    nodes.forEach(updateBox);
-    edges.forEach(updateBox);
-    edges.forEach((edge) => {
-      edge.points.forEach(updateCoords);
-    });
-    return { x, y, width: width2, height, nodes, edges };
-  } finally {
-    setLodash(prevLodash);
-  }
-}
-
-// src/layout/buildCharts.ts
-function buildCharts({
-  lodash,
-  config,
-  newId,
-  getStateParams,
-  getStateLabel = (stateKey) => stateKey.replace(/([a-z])([A-Z])/g, "$1 $2"),
-  getTransitionParams,
-  padding = [5, 5],
-  vertical = false,
-  initialStateKey = "<initial>",
-  finalStateKey = "<final>",
-  direction
-}) {
-  return buildChart(config);
-  function buildChart(config2, id = newId("s"), stack = []) {
-    stack.push(config2);
-    try {
-      const buildStateLabel = (state, key = state) => {
-        if (key === initialStateKey || key === finalStateKey) {
-          return "";
-        }
-        let result;
-        for (let i = stack.length - 1; result === void 0 && i >= 0; i--) {
-          const conf = stack[i];
-          if (!conf.states) continue;
-          for (const subState of conf.states) {
-            if (subState.key !== state) continue;
-            result = subState.label ?? getStateLabel(state);
-            break;
-          }
-        }
-        return result ?? getStateLabel(state) ?? state;
-      };
-      const graph = buildFlatCharts({
-        lodash,
-        transitions: config2.transitions || [],
-        newId,
-        getStateParams: (state, key) => {
-          const params = getStateParams(state, key);
-          delete params.state;
-          params.text = buildStateLabel(state, key);
-          return params;
-        },
-        getTransitionParams,
-        padding,
-        initialStateKey,
-        finalStateKey,
-        vertical,
-        direction
-      });
-      const index = graph.nodes.reduce(
-        (index2, node) => {
-          index2[node.key] = node.id;
-          return index2;
-        },
-        {}
-      );
-      const text = config2.label ?? getStateLabel(config2.key) ?? config2.key;
-      const children = [];
-      if (config2.states) {
-        for (const child of config2.states) {
-          const childId = index[child.key];
-          children.push(buildChart(child, childId, [...stack]));
-        }
-      }
-      return {
-        id,
-        key: config2.key,
-        // state,
-        text,
-        ...graph,
-        children
-      };
-    } finally {
-    }
-  }
-}
-
-// src/layout/getLabelDimensions.ts
-function getLabelDimensions(label, {
-  padding = 0,
-  fontSize = 14,
-  getCharWidth = () => fontSize / 1.61,
-  // Golden ratio and all that jazz :-)
-  lineGap = fontSize * 0.2
-} = {}) {
-  const lines = [label];
-  let dimensions = { width: 0, height: 0 };
-  let lineNumber = 0;
-  for (const line of lines) {
-    if (lineNumber++) dimensions.height += lineGap;
-    dimensions = expandBox(
-      dimensions,
-      getLineDimensions({
-        line,
-        fontSize,
-        getCharWidth
-      })
-    );
-  }
-  const [top, right, bottom, left] = getPadding(padding);
-  return {
-    width: Math.round(dimensions.width + left + right),
-    height: Math.round(dimensions.height + top + bottom)
-  };
-  function expandBox(dim1, dim2) {
-    return {
-      width: Math.round(Math.max(dim1.width, dim2.width)),
-      height: Math.round(dim1.height + dim2.height)
-    };
-  }
-  function getLineDimensions({
-    line,
-    fontSize: fontSize2 = 14,
-    getCharWidth: getCharWidth2 = () => fontSize2
-  }) {
-    return {
-      width: line.split("").reduce((w, c) => w += getCharWidth2(c), 0),
-      height: fontSize2
-    };
-  }
-}
-
-// src/layout/getGraphParamsProvider.ts
-function getGraphParamsProvider({
-  fontSize = 14,
-  stateFontSize = fontSize,
-  stateTextPadding = 0,
-  transitionsFontSize = fontSize,
-  transitionsTextPadding = 0,
-  getStateLabel = (state) => state,
-  getTransitionLabel = (_fromState, event, _toState) => event
-} = {}) {
-  return {
-    getStateParams: (stateKey, state = stateKey) => {
-      const padding = getPadding(stateTextPadding);
-      const fontSize2 = stateFontSize;
-      const stateLabel = getStateLabel(state);
-      return {
-        ...getLabelDimensions(stateLabel, {
-          padding,
-          fontSize: fontSize2
-        }),
-        state,
-        text: stateLabel,
-        key: stateKey,
-        padding,
-        fontSize: fontSize2
-      };
-    },
-    getTransitionParams: (fromStateKey, event, toStateKey) => {
-      const padding = getPadding(transitionsTextPadding);
-      const fontSize2 = transitionsFontSize;
-      const eventLabel = getTransitionLabel(fromStateKey, event, toStateKey);
-      return {
-        ...getLabelDimensions(eventLabel, {
-          padding,
-          fontSize: fontSize2
-        }),
-        from: fromStateKey,
-        event,
-        to: toStateKey,
-        text: eventLabel,
-        padding,
-        fontSize: fontSize2
-      };
-    }
-  };
-}
-
-export { buildCharts, buildFlatCharts, getGraphParamsProvider, getLabelDimensions };