@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/dagre/lib/layout.js

@@ -0,0 +1,267 @@
+import { __require as ae } from "./lodash.js";
+import { __require as oe } from "./acyclic.js";
+import { __require as ie } from "./normalize.js";
+import { __require as te } from "./rank/index.js";
+import { __require as m } from "./util.js";
+import { __require as de } from "./parent-dummy-chains.js";
+import { __require as se } from "./nesting-graph.js";
+import { __require as ue } from "./add-border-segments.js";
+import { __require as fe } from "./coordinate-system.js";
+import { __require as ce } from "./order/index.js";
+import { __require as he } from "./position/index.js";
+import { __require as le } from "./graphlib.js";
+var p, w;
+function Le() {
+  if (w) return p;
+  w = 1;
+  var o = ae(), b = oe(), g = ie(), q = te(), L = m().normalizeRanks, N = de(), R = m().removeEmptyRanks, E = se(), S = ue(), y = fe(), I = ce(), C = he(), c = m(), M = le().Graph;
+  p = P;
+  function P(e, r) {
+    var n = r && r.debugTiming ? c.time : c.notime;
+    n("layout", function() {
+      var a = n("  buildLayoutGraph", function() {
+        return X(e);
+      });
+      n("  runLayout", function() {
+        T(a, n);
+      }), n("  updateInputGraph", function() {
+        A(e, a);
+      });
+    });
+  }
+  function T(e, r) {
+    r("    makeSpaceForEdgeLabels", function() {
+      G(e);
+    }), r("    removeSelfEdges", function() {
+      ee(e);
+    }), r("    acyclic", function() {
+      b.run(e);
+    }), r("    nestingGraph.run", function() {
+      E.run(e);
+    }), r("    rank", function() {
+      q(c.asNonCompoundGraph(e));
+    }), r("    injectEdgeLabelProxies", function() {
+      U(e);
+    }), r("    removeEmptyRanks", function() {
+      R(e);
+    }), r("    nestingGraph.cleanup", function() {
+      E.cleanup(e);
+    }), r("    normalizeRanks", function() {
+      L(e);
+    }), r("    assignRankMinMax", function() {
+      W(e);
+    }), r("    removeEdgeLabelProxies", function() {
+      H(e);
+    }), r("    normalize.run", function() {
+      g.run(e);
+    }), r("    parentDummyChains", function() {
+      N(e);
+    }), r("    addBorderSegments", function() {
+      S(e);
+    }), r("    order", function() {
+      I(e);
+    }), r("    insertSelfEdges", function() {
+      re(e);
+    }), r("    adjustCoordinateSystem", function() {
+      y.adjust(e);
+    }), r("    position", function() {
+      C(e);
+    }), r("    positionSelfEdges", function() {
+      ne(e);
+    }), r("    removeBorderNodes", function() {
+      $(e);
+    }), r("    normalize.undo", function() {
+      g.undo(e);
+    }), r("    fixupEdgeLabelCoords", function() {
+      Q(e);
+    }), r("    undoCoordinateSystem", function() {
+      y.undo(e);
+    }), r("    translateGraph", function() {
+      J(e);
+    }), r("    assignNodeIntersects", function() {
+      K(e);
+    }), r("    reversePoints", function() {
+      Z(e);
+    }), r("    acyclic.undo", function() {
+      b.undo(e);
+    });
+  }
+  function A(e, r) {
+    o.forEach(e.nodes(), function(n) {
+      var a = e.node(n), i = r.node(n);
+      a && (a.x = i.x, a.y = i.y, r.children(n).length && (a.width = i.width, a.height = i.height));
+    }), o.forEach(e.edges(), function(n) {
+      var a = e.edge(n), i = r.edge(n);
+      a.points = i.points, o.has(i, "x") && (a.x = i.x, a.y = i.y);
+    }), e.graph().width = r.graph().width, e.graph().height = r.graph().height;
+  }
+  var B = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"], z = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }, D = ["acyclicer", "ranker", "rankdir", "align"], F = ["width", "height"], Y = { width: 0, height: 0 }, j = ["minlen", "weight", "width", "height", "labeloffset"], V = {
+    minlen: 1,
+    weight: 1,
+    width: 0,
+    height: 0,
+    labeloffset: 10,
+    labelpos: "r"
+  }, O = ["labelpos"];
+  function X(e) {
+    var r = new M({ multigraph: !0, compound: !0 }), n = v(e.graph());
+    return r.setGraph(o.merge(
+      {},
+      z,
+      l(n, B),
+      o.pick(n, D)
+    )), o.forEach(e.nodes(), function(a) {
+      var i = v(e.node(a));
+      r.setNode(a, o.defaults(l(i, F), Y)), r.setParent(a, e.parent(a));
+    }), o.forEach(e.edges(), function(a) {
+      var i = v(e.edge(a));
+      r.setEdge(a, o.merge(
+        {},
+        V,
+        l(i, j),
+        o.pick(i, O)
+      ));
+    }), r;
+  }
+  function G(e) {
+    var r = e.graph();
+    r.ranksep /= 2, o.forEach(e.edges(), function(n) {
+      var a = e.edge(n);
+      a.minlen *= 2, a.labelpos.toLowerCase() !== "c" && (r.rankdir === "TB" || r.rankdir === "BT" ? a.width += a.labeloffset : a.height += a.labeloffset);
+    });
+  }
+  function U(e) {
+    o.forEach(e.edges(), function(r) {
+      var n = e.edge(r);
+      if (n.width && n.height) {
+        var a = e.node(r.v), i = e.node(r.w), t = { rank: (i.rank - a.rank) / 2 + a.rank, e: r };
+        c.addDummyNode(e, "edge-proxy", t, "_ep");
+      }
+    });
+  }
+  function W(e) {
+    var r = 0;
+    o.forEach(e.nodes(), function(n) {
+      var a = e.node(n);
+      a.borderTop && (a.minRank = e.node(a.borderTop).rank, a.maxRank = e.node(a.borderBottom).rank, r = o.max(r, a.maxRank));
+    }), e.graph().maxRank = r;
+  }
+  function H(e) {
+    o.forEach(e.nodes(), function(r) {
+      var n = e.node(r);
+      n.dummy === "edge-proxy" && (e.edge(n.e).labelRank = n.rank, e.removeNode(r));
+    });
+  }
+  function J(e) {
+    var r = Number.POSITIVE_INFINITY, n = 0, a = Number.POSITIVE_INFINITY, i = 0, t = e.graph(), d = t.marginx || 0, u = t.marginy || 0;
+    function x(f) {
+      var s = f.x, h = f.y, k = f.width, _ = f.height;
+      r = Math.min(r, s - k / 2), n = Math.max(n, s + k / 2), a = Math.min(a, h - _ / 2), i = Math.max(i, h + _ / 2);
+    }
+    o.forEach(e.nodes(), function(f) {
+      x(e.node(f));
+    }), o.forEach(e.edges(), function(f) {
+      var s = e.edge(f);
+      o.has(s, "x") && x(s);
+    }), r -= d, a -= u, o.forEach(e.nodes(), function(f) {
+      var s = e.node(f);
+      s.x -= r, s.y -= a;
+    }), o.forEach(e.edges(), function(f) {
+      var s = e.edge(f);
+      o.forEach(s.points, function(h) {
+        h.x -= r, h.y -= a;
+      }), o.has(s, "x") && (s.x -= r), o.has(s, "y") && (s.y -= a);
+    }), t.width = n - r + d, t.height = i - a + u;
+  }
+  function K(e) {
+    o.forEach(e.edges(), function(r) {
+      var n = e.edge(r), a = e.node(r.v), i = e.node(r.w), t, d;
+      n.points ? (t = n.points[0], d = n.points[n.points.length - 1]) : (n.points = [], t = i, d = a), n.points.unshift(c.intersectRect(a, t)), n.points.push(c.intersectRect(i, d));
+    });
+  }
+  function Q(e) {
+    o.forEach(e.edges(), function(r) {
+      var n = e.edge(r);
+      if (o.has(n, "x"))
+        switch ((n.labelpos === "l" || n.labelpos === "r") && (n.width -= n.labeloffset), n.labelpos) {
+          case "l":
+            n.x -= n.width / 2 + n.labeloffset;
+            break;
+          case "r":
+            n.x += n.width / 2 + n.labeloffset;
+            break;
+        }
+    });
+  }
+  function Z(e) {
+    o.forEach(e.edges(), function(r) {
+      var n = e.edge(r);
+      n.reversed && n.points.reverse();
+    });
+  }
+  function $(e) {
+    o.forEach(e.nodes(), function(r) {
+      if (e.children(r).length) {
+        var n = e.node(r), a = e.node(n.borderTop), i = e.node(n.borderBottom), t = e.node(o.last(n.borderLeft)), d = e.node(o.last(n.borderRight));
+        n.width = Math.abs(d.x - t.x), n.height = Math.abs(i.y - a.y), n.x = t.x + n.width / 2, n.y = a.y + n.height / 2;
+      }
+    }), o.forEach(e.nodes(), function(r) {
+      e.node(r).dummy === "border" && e.removeNode(r);
+    });
+  }
+  function ee(e) {
+    o.forEach(e.edges(), function(r) {
+      if (r.v === r.w) {
+        var n = e.node(r.v);
+        n.selfEdges || (n.selfEdges = []), n.selfEdges.push({ e: r, label: e.edge(r) }), e.removeEdge(r);
+      }
+    });
+  }
+  function re(e) {
+    var r = c.buildLayerMatrix(e);
+    o.forEach(r, function(n) {
+      var a = 0;
+      o.forEach(n, function(i, t) {
+        var d = e.node(i);
+        d.order = t + a, o.forEach(d.selfEdges, function(u) {
+          c.addDummyNode(e, "selfedge", {
+            width: u.label.width,
+            height: u.label.height,
+            rank: d.rank,
+            order: t + ++a,
+            e: u.e,
+            label: u.label
+          }, "_se");
+        }), delete d.selfEdges;
+      });
+    });
+  }
+  function ne(e) {
+    o.forEach(e.nodes(), function(r) {
+      var n = e.node(r);
+      if (n.dummy === "selfedge") {
+        var a = e.node(n.e.v), i = a.x + a.width / 2, t = a.y, d = n.x - i, u = a.height / 2;
+        e.setEdge(n.e, n.label), e.removeNode(r), n.label.points = [
+          { x: i + 2 * d / 3, y: t - u },
+          { x: i + 5 * d / 6, y: t - u },
+          { x: i + d, y: t },
+          { x: i + 5 * d / 6, y: t + u },
+          { x: i + 2 * d / 3, y: t + u }
+        ], n.label.x = n.x, n.label.y = n.y;
+      }
+    });
+  }
+  function l(e, r) {
+    return o.mapValues(o.pick(e, r), Number);
+  }
+  function v(e) {
+    var r = {};
+    return o.forEach(e, function(n, a) {
+      r[a.toLowerCase()] = n;
+    }), r;
+  }
+  return p;
+}
+export {
+  Le as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/lodash.js

@@ -0,0 +1,69 @@
+import { commonjsRequire as o } from "../../../../../_virtual/_commonjs-dynamic-modules.js";
+import { __require as u } from "../../lodash/cloneDeep.js";
+import { __require as a } from "../../lodash/constant.js";
+import { __require as m } from "../../lodash/defaults.js";
+import { __require as q } from "../../lodash/each.js";
+import { __require as _ } from "../../lodash/filter.js";
+import { __require as t } from "../../lodash/find.js";
+import { __require as s } from "../../lodash/flatten.js";
+import { __require as f } from "../../lodash/forEach.js";
+import { __require as p } from "../../lodash/forIn.js";
+import { __require as n } from "../../lodash/has.js";
+import { __require as c } from "../../lodash/isUndefined.js";
+import { __require as d } from "../../lodash/last.js";
+import { __require as l } from "../../lodash/map.js";
+import { __require as h } from "../../lodash/mapValues.js";
+import { __require as y } from "../../lodash/max.js";
+import { __require as M } from "../../lodash/merge.js";
+import { __require as F } from "../../lodash/min.js";
+import { __require as I } from "../../lodash/minBy.js";
+import { __require as g } from "../../lodash/now.js";
+import { __require as v } from "../../lodash/pick.js";
+import { __require as w } from "../../lodash/range.js";
+import { __require as B } from "../../lodash/reduce.js";
+import { __require as R } from "../../lodash/sortBy.js";
+import { __require as j } from "../../lodash/uniqueId.js";
+import { __require as x } from "../../lodash/values.js";
+import { __require as D } from "../../lodash/zipObject.js";
+var e, i;
+function ur() {
+  if (i) return e;
+  i = 1;
+  var r;
+  if (typeof o == "function")
+    try {
+      r = {
+        cloneDeep: u(),
+        constant: a(),
+        defaults: m(),
+        each: q(),
+        filter: _(),
+        find: t(),
+        flatten: s(),
+        forEach: f(),
+        forIn: p(),
+        has: n(),
+        isUndefined: c(),
+        last: d(),
+        map: l(),
+        mapValues: h(),
+        max: y(),
+        merge: M(),
+        min: F(),
+        minBy: I(),
+        now: g(),
+        pick: v(),
+        range: w(),
+        reduce: B(),
+        sortBy: R(),
+        uniqueId: j(),
+        values: x(),
+        zipObject: D()
+      };
+    } catch {
+    }
+  return r || (r = window._), e = r, e;
+}
+export {
+  ur as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/nesting-graph.js

@@ -0,0 +1,71 @@
+import { __require as w } from "./lodash.js";
+import { __require as G } from "./util.js";
+var l, q;
+function L() {
+  if (q) return l;
+  q = 1;
+  var a = w(), s = G();
+  l = {
+    run: N,
+    cleanup: T
+  };
+  function N(e) {
+    var r = s.addDummyNode(e, "root", {}, "_root"), t = B(e), o = a.max(a.values(t)) - 1, i = 2 * o + 1;
+    e.graph().nestingRoot = r, a.forEach(e.edges(), function(n) {
+      e.edge(n).minlen *= i;
+    });
+    var d = R(e) + 1;
+    a.forEach(e.children(), function(n) {
+      m(e, r, i, d, o, t, n);
+    }), e.graph().nodeRankFactor = i;
+  }
+  function m(e, r, t, o, i, d, n) {
+    var p = e.children(n);
+    if (!p.length) {
+      n !== r && e.setEdge(r, n, { weight: 0, minlen: t });
+      return;
+    }
+    var c = s.addBorderNode(e, "_bt"), h = s.addBorderNode(e, "_bb"), v = e.node(n);
+    e.setParent(c, n), v.borderTop = c, e.setParent(h, n), v.borderBottom = h, a.forEach(p, function(f) {
+      m(e, r, t, o, i, d, f);
+      var u = e.node(f), E = u.borderTop ? u.borderTop : f, b = u.borderBottom ? u.borderBottom : f, _ = u.borderTop ? o : 2 * o, g = E !== b ? 1 : i - d[n] + 1;
+      e.setEdge(c, E, {
+        weight: _,
+        minlen: g,
+        nestingEdge: !0
+      }), e.setEdge(b, h, {
+        weight: _,
+        minlen: g,
+        nestingEdge: !0
+      });
+    }), e.parent(n) || e.setEdge(r, c, { weight: 0, minlen: i + d[n] });
+  }
+  function B(e) {
+    var r = {};
+    function t(o, i) {
+      var d = e.children(o);
+      d && d.length && a.forEach(d, function(n) {
+        t(n, i + 1);
+      }), r[o] = i;
+    }
+    return a.forEach(e.children(), function(o) {
+      t(o, 1);
+    }), r;
+  }
+  function R(e) {
+    return a.reduce(e.edges(), function(r, t) {
+      return r + e.edge(t).weight;
+    }, 0);
+  }
+  function T(e) {
+    var r = e.graph();
+    e.removeNode(r.nestingRoot), delete r.nestingRoot, a.forEach(e.edges(), function(t) {
+      var o = e.edge(t);
+      o.nestingEdge && e.removeEdge(t);
+    });
+  }
+  return l;
+}
+export {
+  L as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/normalize.js

@@ -0,0 +1,44 @@
+import { __require as y } from "./lodash.js";
+import { __require as c } from "./util.js";
+var u, f;
+function q() {
+  if (f) return u;
+  f = 1;
+  var m = y(), v = c();
+  u = {
+    run: g,
+    undo: b
+  };
+  function g(e) {
+    e.graph().dummyChains = [], m.forEach(e.edges(), function(a) {
+      w(e, a);
+    });
+  }
+  function w(e, a) {
+    var r = a.v, i = e.node(r).rank, o = a.w, l = e.node(o).rank, s = a.name, d = e.edge(a), p = d.labelRank;
+    if (l !== i + 1) {
+      e.removeEdge(a);
+      var t, n, h;
+      for (h = 0, ++i; i < l; ++h, ++i)
+        d.points = [], n = {
+          width: 0,
+          height: 0,
+          edgeLabel: d,
+          edgeObj: a,
+          rank: i
+        }, t = v.addDummyNode(e, "edge", n, "_d"), i === p && (n.width = d.width, n.height = d.height, n.dummy = "edge-label", n.labelpos = d.labelpos), e.setEdge(r, t, { weight: d.weight }, s), h === 0 && e.graph().dummyChains.push(t), r = t;
+      e.setEdge(r, o, { weight: d.weight }, s);
+    }
+  }
+  function b(e) {
+    m.forEach(e.graph().dummyChains, function(a) {
+      var r = e.node(a), i = r.edgeLabel, o;
+      for (e.setEdge(r.edgeObj, i); r.dummy; )
+        o = e.successors(a)[0], e.removeNode(a), i.points.push({ x: r.x, y: r.y }), r.dummy === "edge-label" && (i.x = r.x, i.y = r.y, i.width = r.width, i.height = r.height), a = o, r = e.node(a);
+    });
+  }
+  return u;
+}
+export {
+  q as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/add-subgraph-constraints.js

@@ -0,0 +1,24 @@
+import { __require as v } from "../lodash.js";
+var t, o;
+function c() {
+  if (o) return t;
+  o = 1;
+  var s = v();
+  t = d;
+  function d(n, p, h) {
+    var i = {}, u;
+    s.forEach(h, function(f) {
+      for (var r = n.parent(f), e, a; r; ) {
+        if (e = n.parent(r), e ? (a = i[e], i[e] = r) : (a = u, u = r), a && a !== r) {
+          p.setEdge(a, r);
+          return;
+        }
+        r = e;
+      }
+    });
+  }
+  return t;
+}
+export {
+  c as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/barycenter.js

@@ -0,0 +1,32 @@
+import { __require as w } from "../lodash.js";
+var t, g;
+function m() {
+  if (g) return t;
+  g = 1;
+  var i = w();
+  t = d;
+  function d(e, c) {
+    return i.map(c, function(r) {
+      var u = e.inEdges(r);
+      if (u.length) {
+        var n = i.reduce(u, function(a, h) {
+          var o = e.edge(h), s = e.node(h.v);
+          return {
+            sum: a.sum + o.weight * s.order,
+            weight: a.weight + o.weight
+          };
+        }, { sum: 0, weight: 0 });
+        return {
+          v: r,
+          barycenter: n.sum / n.weight,
+          weight: n.weight
+        };
+      } else
+        return { v: r };
+    });
+  }
+  return t;
+}
+export {
+  m as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/build-layer-graph.js

@@ -0,0 +1,32 @@
+import { __require as q } from "../lodash.js";
+import { __require as G } from "../graphlib.js";
+var u, s;
+function R() {
+  if (s) return u;
+  s = 1;
+  var i = q(), p = G().Graph;
+  u = c;
+  function c(r, t, _) {
+    var d = l(r), o = new p({ compound: !0 }).setGraph({ root: d }).setDefaultNodeLabel(function(e) {
+      return r.node(e);
+    });
+    return i.forEach(r.nodes(), function(e) {
+      var a = r.node(e), b = r.parent(e);
+      (a.rank === t || a.minRank <= t && t <= a.maxRank) && (o.setNode(e), o.setParent(e, b || d), i.forEach(r[_](e), function(n) {
+        var h = n.v === e ? n.w : n.v, f = o.edge(h, e), m = i.isUndefined(f) ? 0 : f.weight;
+        o.setEdge(h, e, { weight: r.edge(n).weight + m });
+      }), i.has(a, "minRank") && o.setNode(e, {
+        borderLeft: a.borderLeft[t],
+        borderRight: a.borderRight[t]
+      }));
+    }), o;
+  }
+  function l(r) {
+    for (var t; r.hasNode(t = i.uniqueId("_root")); ) ;
+    return t;
+  }
+  return u;
+}
+export {
+  R as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/cross-count.js

@@ -0,0 +1,41 @@
+import { __require as m } from "../lodash.js";
+var c, v;
+function _() {
+  if (v) return c;
+  v = 1;
+  var t = m();
+  c = w;
+  function w(a, u) {
+    for (var o = 0, n = 1; n < u.length; ++n)
+      o += p(a, u[n - 1], u[n]);
+    return o;
+  }
+  function p(a, u, o) {
+    for (var n = t.zipObject(
+      o,
+      t.map(o, function(e, r) {
+        return r;
+      })
+    ), C = t.flatten(t.map(u, function(e) {
+      return t.sortBy(t.map(a.outEdges(e), function(r) {
+        return { pos: n[r.w], weight: a.edge(r).weight };
+      }), "pos");
+    }), !0), i = 1; i < o.length; ) i <<= 1;
+    var g = 2 * i - 1;
+    i -= 1;
+    var s = t.map(new Array(g), function() {
+      return 0;
+    }), f = 0;
+    return t.forEach(C.forEach(function(e) {
+      var r = e.pos + i;
+      s[r] += e.weight;
+      for (var h = 0; r > 0; )
+        r % 2 && (h += s[r + 1]), r = r - 1 >> 1, s[r] += e.weight;
+      f += e.weight * h;
+    })), f;
+  }
+  return c;
+}
+export {
+  _ as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/index.js

@@ -0,0 +1,50 @@
+import { __require as I } from "../lodash.js";
+import { __require as O } from "./init-order.js";
+import { __require as S } from "./cross-count.js";
+import { __require as l } from "./sort-subgraph.js";
+import { __require as x } from "./build-layer-graph.js";
+import { __require as w } from "./add-subgraph-constraints.js";
+import { __require as N } from "../graphlib.js";
+import { __require as R } from "../util.js";
+var d, v;
+function U() {
+  if (v) return d;
+  v = 1;
+  var a = I(), q = O(), c = S(), b = l(), G = x(), y = w(), L = N().Graph, f = R();
+  d = C;
+  function C(r) {
+    var o = f.maxRank(r), i = _(r, a.range(1, o + 1), "inEdges"), e = _(r, a.range(o - 1, -1, -1), "outEdges"), u = q(r);
+    h(r, u);
+    for (var n = Number.POSITIVE_INFINITY, s, t = 0, p = 0; p < 4; ++t, ++p) {
+      E(t % 2 ? i : e, t % 4 >= 2), u = f.buildLayerMatrix(r);
+      var m = c(r, u);
+      m < n && (p = 0, s = a.cloneDeep(u), n = m);
+    }
+    h(r, s);
+  }
+  function _(r, o, i) {
+    return a.map(o, function(e) {
+      return G(r, e, i);
+    });
+  }
+  function E(r, o) {
+    var i = new L();
+    a.forEach(r, function(e) {
+      var u = e.graph().root, n = b(e, u, i, o);
+      a.forEach(n.vs, function(s, t) {
+        e.node(s).order = t;
+      }), y(e, i, n.vs);
+    });
+  }
+  function h(r, o) {
+    a.forEach(o, function(i) {
+      a.forEach(i, function(e, u) {
+        r.node(e).order = u;
+      });
+    });
+  }
+  return d;
+}
+export {
+  U as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/order/init-order.js

@@ -0,0 +1,32 @@
+import { __require as m } from "../lodash.js";
+var a, s;
+function v() {
+  if (s) return a;
+  s = 1;
+  var e = m();
+  a = d;
+  function d(n) {
+    var i = {}, t = e.filter(n.nodes(), function(r) {
+      return !n.children(r).length;
+    }), f = e.max(e.map(t, function(r) {
+      return n.node(r).rank;
+    })), u = e.map(e.range(f + 1), function() {
+      return [];
+    });
+    function o(r) {
+      if (!e.has(i, r)) {
+        i[r] = !0;
+        var h = n.node(r);
+        u[h.rank].push(r), e.forEach(n.successors(r), o);
+      }
+    }
+    var c = e.sortBy(t, function(r) {
+      return n.node(r).rank;
+    });
+    return e.forEach(c, o), u;
+  }
+  return a;
+}
+export {
+  v as __require
+};