@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/rectangle.js

@@ -0,0 +1,361 @@
+import { GeometryUtil as m } from "./util.js";
+import { Angle as M } from "./angle.js";
+import { Line as a } from "./line.js";
+import { Point as c } from "./point.js";
+import { Geometry as C } from "./geometry.js";
+class y extends C {
+  get left() {
+    return this.x;
+  }
+  get top() {
+    return this.y;
+  }
+  get right() {
+    return this.x + this.width;
+  }
+  get bottom() {
+    return this.y + this.height;
+  }
+  get origin() {
+    return new c(this.x, this.y);
+  }
+  get topLeft() {
+    return new c(this.x, this.y);
+  }
+  get topCenter() {
+    return new c(this.x + this.width / 2, this.y);
+  }
+  get topRight() {
+    return new c(this.x + this.width, this.y);
+  }
+  get center() {
+    return new c(this.x + this.width / 2, this.y + this.height / 2);
+  }
+  get bottomLeft() {
+    return new c(this.x, this.y + this.height);
+  }
+  get bottomCenter() {
+    return new c(this.x + this.width / 2, this.y + this.height);
+  }
+  get bottomRight() {
+    return new c(this.x + this.width, this.y + this.height);
+  }
+  get corner() {
+    return new c(this.x + this.width, this.y + this.height);
+  }
+  get rightMiddle() {
+    return new c(this.x + this.width, this.y + this.height / 2);
+  }
+  get leftMiddle() {
+    return new c(this.x, this.y + this.height / 2);
+  }
+  get topLine() {
+    return new a(this.topLeft, this.topRight);
+  }
+  get rightLine() {
+    return new a(this.topRight, this.bottomRight);
+  }
+  get bottomLine() {
+    return new a(this.bottomLeft, this.bottomRight);
+  }
+  get leftLine() {
+    return new a(this.topLeft, this.bottomLeft);
+  }
+  constructor(i, t, e, n) {
+    super(), this.x = i ?? 0, this.y = t ?? 0, this.width = e ?? 0, this.height = n ?? 0;
+  }
+  getOrigin() {
+    return this.origin;
+  }
+  getTopLeft() {
+    return this.topLeft;
+  }
+  getTopCenter() {
+    return this.topCenter;
+  }
+  getTopRight() {
+    return this.topRight;
+  }
+  getCenter() {
+    return this.center;
+  }
+  getCenterX() {
+    return this.x + this.width / 2;
+  }
+  getCenterY() {
+    return this.y + this.height / 2;
+  }
+  getBottomLeft() {
+    return this.bottomLeft;
+  }
+  getBottomCenter() {
+    return this.bottomCenter;
+  }
+  getBottomRight() {
+    return this.bottomRight;
+  }
+  getCorner() {
+    return this.corner;
+  }
+  getRightMiddle() {
+    return this.rightMiddle;
+  }
+  getLeftMiddle() {
+    return this.leftMiddle;
+  }
+  getTopLine() {
+    return this.topLine;
+  }
+  getRightLine() {
+    return this.rightLine;
+  }
+  getBottomLine() {
+    return this.bottomLine;
+  }
+  getLeftLine() {
+    return this.leftLine;
+  }
+  /**
+   * Returns a rectangle that is the bounding box of the rectangle.
+   *
+   * If `angle` is specified, the bounding box calculation will take into
+   * account the rotation of the rectangle by angle degrees around its center.
+   */
+  bbox(i) {
+    if (!i)
+      return this.clone();
+    const t = M.toRad(i), e = Math.abs(Math.sin(t)), n = Math.abs(Math.cos(t)), s = this.width * n + this.height * e, h = this.width * e + this.height * n;
+    return new y(this.x + (this.width - s) / 2, this.y + (this.height - h) / 2, s, h);
+  }
+  round(i = 0) {
+    return this.x = m.round(this.x, i), this.y = m.round(this.y, i), this.width = m.round(this.width, i), this.height = m.round(this.height, i), this;
+  }
+  add(i, t, e, n) {
+    const s = y.create(i, t, e, n), h = Math.min(this.x, s.x), r = Math.min(this.y, s.y), o = Math.max(this.x + this.width, s.x + s.width), u = Math.max(this.y + this.height, s.y + s.height);
+    return this.x = h, this.y = r, this.width = o - h, this.height = u - r, this;
+  }
+  update(i, t, e, n) {
+    const s = y.create(i, t, e, n);
+    return this.x = s.x, this.y = s.y, this.width = s.width, this.height = s.height, this;
+  }
+  inflate(i, t) {
+    const e = i, n = t ?? i;
+    return this.x -= e, this.y -= n, this.width += 2 * e, this.height += 2 * n, this;
+  }
+  snapToGrid(i, t) {
+    const e = this.origin.snapToGrid(i, t), n = this.corner.snapToGrid(i, t);
+    return this.x = e.x, this.y = e.y, this.width = n.x - e.x, this.height = n.y - e.y, this;
+  }
+  translate(i, t) {
+    const e = c.create(i, t);
+    return this.x += e.x, this.y += e.y, this;
+  }
+  scale(i, t, e = new c()) {
+    const n = this.origin.scale(i, t, e);
+    return this.x = n.x, this.y = n.y, this.width *= i, this.height *= t, this;
+  }
+  rotate(i, t = this.getCenter()) {
+    if (i !== 0) {
+      const e = M.toRad(i), n = Math.cos(e), s = Math.sin(e);
+      let h = this.getOrigin(), r = this.getTopRight(), o = this.getBottomRight(), u = this.getBottomLeft();
+      h = c.rotateEx(h, n, s, t), r = c.rotateEx(r, n, s, t), o = c.rotateEx(o, n, s, t), u = c.rotateEx(u, n, s, t);
+      const x = new y(h.x, h.y, 0, 0);
+      x.add(r.x, r.y, 0, 0), x.add(o.x, o.y, 0, 0), x.add(u.x, u.y, 0, 0), this.update(x);
+    }
+    return this;
+  }
+  rotate90() {
+    const i = (this.width - this.height) / 2;
+    this.x += i, this.y -= i;
+    const t = this.width;
+    return this.width = this.height, this.height = t, this;
+  }
+  /**
+   * Translates the rectangle by `rect.x` and `rect.y` and expand it by
+   * `rect.width` and `rect.height`.
+   */
+  moveAndExpand(i) {
+    const t = y.clone(i);
+    return this.x += t.x || 0, this.y += t.y || 0, this.width += t.width || 0, this.height += t.height || 0, this;
+  }
+  /**
+   * Returns an object where `sx` and `sy` give the maximum scaling that can be
+   * applied to the rectangle so that it would still fit into `limit`. If
+   * `origin` is specified, the rectangle is scaled around it; otherwise, it is
+   * scaled around its center.
+   */
+  getMaxScaleToFit(i, t = this.center) {
+    const e = y.clone(i), n = t.x, s = t.y;
+    let h = 1 / 0, r = 1 / 0, o = 1 / 0, u = 1 / 0, x = 1 / 0, f = 1 / 0, d = 1 / 0, w = 1 / 0;
+    const l = e.topLeft;
+    l.x < n && (h = (this.x - n) / (l.x - n)), l.y < s && (x = (this.y - s) / (l.y - s));
+    const p = e.bottomRight;
+    p.x > n && (r = (this.x + this.width - n) / (p.x - n)), p.y > s && (f = (this.y + this.height - s) / (p.y - s));
+    const L = e.topRight;
+    L.x > n && (o = (this.x + this.width - n) / (L.x - n)), L.y < s && (d = (this.y - s) / (L.y - s));
+    const b = e.bottomLeft;
+    return b.x < n && (u = (this.x - n) / (b.x - n)), b.y > s && (w = (this.y + this.height - s) / (b.y - s)), {
+      sx: Math.min(h, r, o, u),
+      sy: Math.min(x, f, d, w)
+    };
+  }
+  /**
+   * Returns a number that specifies the maximum scaling that can be applied to
+   * the rectangle along both axes so that it would still fit into `limit`. If
+   * `origin` is specified, the rectangle is scaled around it; otherwise, it is
+   * scaled around its center.
+   */
+  getMaxUniformScaleToFit(i, t = this.center) {
+    const e = this.getMaxScaleToFit(i, t);
+    return Math.min(e.sx, e.sy);
+  }
+  containsPoint(i, t) {
+    return m.containsPoint(this, c.create(i, t));
+  }
+  containsRect(i, t, e, n) {
+    const s = y.create(i, t, e, n), h = this.x, r = this.y, o = this.width, u = this.height, x = s.x, f = s.y, d = s.width, w = s.height;
+    return o === 0 || u === 0 || d === 0 || w === 0 ? !1 : x >= h && f >= r && x + d <= h + o && f + w <= r + u;
+  }
+  /**
+   * Returns an array of the intersection points of the rectangle and the line.
+   * Return `null` if no intersection exists.
+   */
+  intersectsWithLine(i) {
+    const t = [
+      this.topLine,
+      this.rightLine,
+      this.bottomLine,
+      this.leftLine
+    ], e = [], n = [];
+    return t.forEach((s) => {
+      const h = i.intersectsWithLine(s);
+      h !== null && n.indexOf(h.toString()) < 0 && (e.push(h), n.push(h.toString()));
+    }), e.length > 0 ? e : null;
+  }
+  /**
+   * Returns the point on the boundary of the rectangle that is the intersection
+   * of the rectangle with a line starting in the center the rectangle ending in
+   * the point `p`.
+   *
+   * If `angle` is specified, the intersection will take into account the
+   * rotation of the rectangle by `angle` degrees around its center.
+   */
+  intersectsWithLineFromCenterToPoint(i, t) {
+    const e = c.clone(i), n = this.center;
+    let s = null;
+    t != null && t !== 0 && e.rotate(t, n);
+    const h = [this.topLine, this.rightLine, this.bottomLine, this.leftLine], r = new a(n, e);
+    for (let o = h.length - 1; o >= 0; o -= 1) {
+      const u = h[o].intersectsWithLine(r);
+      if (u !== null) {
+        s = u;
+        break;
+      }
+    }
+    return s && t != null && t !== 0 && s.rotate(-t, n), s;
+  }
+  intersectsWithRect(i, t, e, n) {
+    const s = y.create(i, t, e, n);
+    if (!this.isIntersectWithRect(s))
+      return null;
+    const h = this.origin, r = this.corner, o = s.origin, u = s.corner, x = Math.max(h.x, o.x), f = Math.max(h.y, o.y);
+    return new y(x, f, Math.min(r.x, u.x) - x, Math.min(r.y, u.y) - f);
+  }
+  isIntersectWithRect(i, t, e, n) {
+    const s = y.create(i, t, e, n), h = this.origin, r = this.corner, o = s.origin, u = s.corner;
+    return !(u.x <= h.x || u.y <= h.y || o.x >= r.x || o.y >= r.y);
+  }
+  /**
+   * Normalize the rectangle, i.e. make it so that it has non-negative
+   * width and height. If width is less than `0`, the function swaps left and
+   * right corners and if height is less than `0`, the top and bottom corners
+   * are swapped.
+   */
+  normalize() {
+    let i = this.x, t = this.y, e = this.width, n = this.height;
+    return this.width < 0 && (i = this.x + this.width, e = -this.width), this.height < 0 && (t = this.y + this.height, n = -this.height), this.x = i, this.y = t, this.width = e, this.height = n, this;
+  }
+  /**
+   * Returns a rectangle that is a union of this rectangle and rectangle `rect`.
+   */
+  union(i) {
+    const t = y.clone(i), e = this.origin, n = this.corner, s = t.origin, h = t.corner, r = Math.min(e.x, s.x), o = Math.min(e.y, s.y), u = Math.max(n.x, h.x), x = Math.max(n.y, h.y);
+    return new y(r, o, u - r, x - o);
+  }
+  /**
+   * Returns a string ("top", "left", "right" or "bottom") denoting the side of
+   * the rectangle which is nearest to the point `p`.
+   */
+  getNearestSideToPoint(i) {
+    const t = c.clone(i), e = t.x - this.x, n = this.x + this.width - t.x, s = t.y - this.y, h = this.y + this.height - t.y;
+    let r = e, o = "left";
+    return n < r && (r = n, o = "right"), s < r && (r = s, o = "top"), h < r && (o = "bottom"), o;
+  }
+  /**
+   * Returns a point on the boundary of the rectangle nearest to the point `p`.
+   */
+  getNearestPointToPoint(i) {
+    const t = c.clone(i);
+    if (this.containsPoint(t)) {
+      const e = this.getNearestSideToPoint(t);
+      if (e === "left")
+        return new c(this.x, t.y);
+      if (e === "top")
+        return new c(t.x, this.y);
+      if (e === "right")
+        return new c(this.x + this.width, t.y);
+      if (e === "bottom")
+        return new c(t.x, this.y + this.height);
+    }
+    return t.adhereToRect(this);
+  }
+  equals(i) {
+    return i != null && i.x === this.x && i.y === this.y && i.width === this.width && i.height === this.height;
+  }
+  clone() {
+    return new y(this.x, this.y, this.width, this.height);
+  }
+  toJSON() {
+    return { x: this.x, y: this.y, width: this.width, height: this.height };
+  }
+  serialize() {
+    return `${this.x} ${this.y} ${this.width} ${this.height}`;
+  }
+}
+(function(g) {
+  function i(t) {
+    return t != null && t instanceof g;
+  }
+  g.isRectangle = i;
+})(y || (y = {}));
+(function(g) {
+  function i(t) {
+    return t != null && typeof t == "object" && typeof t.x == "number" && typeof t.y == "number" && typeof t.width == "number" && typeof t.height == "number";
+  }
+  g.isRectangleLike = i;
+})(y || (y = {}));
+(function(g) {
+  function i(h, r, o, u) {
+    return h == null || typeof h == "number" ? new g(h, r, o, u) : t(h);
+  }
+  g.create = i;
+  function t(h) {
+    return g.isRectangle(h) ? h.clone() : Array.isArray(h) ? new g(h[0], h[1], h[2], h[3]) : new g(h.x, h.y, h.width, h.height);
+  }
+  g.clone = t;
+  function e(h) {
+    return new g(h.x - h.a, h.y - h.b, 2 * h.a, 2 * h.b);
+  }
+  g.fromEllipse = e;
+  function n(h) {
+    return new g(0, 0, h.width, h.height);
+  }
+  g.fromSize = n;
+  function s(h, r) {
+    return new g(h.x, h.y, r.width, r.height);
+  }
+  g.fromPositionAndSize = s;
+})(y || (y = {}));
+export {
+  y as Rectangle
+};

package/lib/packages/hooks/node_modules/@antv/x6-geometry/es/util.js

@@ -0,0 +1,36 @@
+var s;
+(function(t) {
+  function d(n, r = 0) {
+    return Number.isInteger(n) ? n : +n.toFixed(r);
+  }
+  t.round = d;
+  function f(n, r) {
+    let u, o;
+    if (r == null ? (o = n ?? 1, u = 0) : (o = r, u = n ?? 0), o < u) {
+      const i = u;
+      u = o, o = i;
+    }
+    return Math.floor(Math.random() * (o - u + 1) + u);
+  }
+  t.random = f;
+  function N(n, r, u) {
+    return Number.isNaN(n) ? NaN : Number.isNaN(r) || Number.isNaN(u) ? 0 : r < u ? n < r ? r : n > u ? u : n : n < u ? u : n > r ? r : n;
+  }
+  t.clamp = N;
+  function a(n, r) {
+    return r * Math.round(n / r);
+  }
+  t.snapToGrid = a;
+  function c(n, r) {
+    return r != null && n != null && r.x >= n.x && r.x <= n.x + n.width && r.y >= n.y && r.y <= n.y + n.height;
+  }
+  t.containsPoint = c;
+  function h(n, r) {
+    const u = n.x - r.x, o = n.y - r.y;
+    return u * u + o * o;
+  }
+  t.squaredLength = h;
+})(s || (s = {}));
+export {
+  s as GeometryUtil
+};

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

@@ -0,0 +1,21 @@
+import { __require as u } from "./lib/graphlib.js";
+import { __require as o } from "./lib/layout.js";
+import { __require as t } from "./lib/debug.js";
+import { __require as e } from "./lib/util.js";
+import { __require as a } from "./lib/version.js";
+var r, i;
+function p() {
+  return i || (i = 1, r = {
+    graphlib: u(),
+    layout: o(),
+    debug: t(),
+    util: {
+      time: e().time,
+      notime: e().notime
+    },
+    version: a()
+  }), r;
+}
+export {
+  p as __require
+};

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

@@ -0,0 +1,47 @@
+import { __require as l } from "./lodash.js";
+import { __require as m } from "./greedy-fas.js";
+var o, c;
+function q() {
+  if (c) return o;
+  c = 1;
+  var i = l(), f = m();
+  o = {
+    run: s,
+    undo: h
+  };
+  function s(e) {
+    var n = e.graph().acyclicer === "greedy" ? f(e, a(e)) : v(e);
+    i.forEach(n, function(r) {
+      var u = e.edge(r);
+      e.removeEdge(r), u.forwardName = r.name, u.reversed = !0, e.setEdge(r.w, r.v, u, i.uniqueId("rev"));
+    });
+    function a(r) {
+      return function(u) {
+        return r.edge(u).weight;
+      };
+    }
+  }
+  function v(e) {
+    var n = [], a = {}, r = {};
+    function u(t) {
+      i.has(r, t) || (r[t] = !0, a[t] = !0, i.forEach(e.outEdges(t), function(d) {
+        i.has(a, d.w) ? n.push(d) : u(d.w);
+      }), delete a[t]);
+    }
+    return i.forEach(e.nodes(), u), n;
+  }
+  function h(e) {
+    i.forEach(e.edges(), function(n) {
+      var a = e.edge(n);
+      if (a.reversed) {
+        e.removeEdge(n);
+        var r = a.forwardName;
+        delete a.reversed, delete a.forwardName, e.setEdge(n.w, n.v, a, r);
+      }
+    });
+  }
+  return o;
+}
+export {
+  q as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/add-border-segments.js

@@ -0,0 +1,28 @@
+import { __require as b } from "./lodash.js";
+import { __require as l } from "./util.js";
+var u, s;
+function R() {
+  if (s) return u;
+  s = 1;
+  var a = b(), c = l();
+  u = _;
+  function _(e) {
+    function i(t) {
+      var o = e.children(t), r = e.node(t);
+      if (o.length && a.forEach(o, i), a.has(r, "minRank")) {
+        r.borderLeft = [], r.borderRight = [];
+        for (var d = r.minRank, n = r.maxRank + 1; d < n; ++d)
+          h(e, "borderLeft", "_bl", t, r, d), h(e, "borderRight", "_br", t, r, d);
+      }
+    }
+    a.forEach(e.children(), i);
+  }
+  function h(e, i, t, o, r, d) {
+    var n = { width: 0, height: 0, rank: d, borderType: i }, m = r[i][d - 1], f = c.addDummyNode(e, "border", n, t);
+    r[i][d] = f, e.setParent(f, o), m && e.setEdge(m, f, { weight: 1 });
+  }
+  return u;
+}
+export {
+  R as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/coordinate-system.js

@@ -0,0 +1,57 @@
+import { __require as p } from "./lodash.js";
+var f, u;
+function y() {
+  if (u) return f;
+  u = 1;
+  var r = p();
+  f = {
+    adjust: c,
+    undo: h
+  };
+  function c(e) {
+    var n = e.graph().rankdir.toLowerCase();
+    (n === "lr" || n === "rl") && d(e);
+  }
+  function h(e) {
+    var n = e.graph().rankdir.toLowerCase();
+    (n === "bt" || n === "rl") && s(e), (n === "lr" || n === "rl") && (v(e), d(e));
+  }
+  function d(e) {
+    r.forEach(e.nodes(), function(n) {
+      t(e.node(n));
+    }), r.forEach(e.edges(), function(n) {
+      t(e.edge(n));
+    });
+  }
+  function t(e) {
+    var n = e.width;
+    e.width = e.height, e.height = n;
+  }
+  function s(e) {
+    r.forEach(e.nodes(), function(n) {
+      i(e.node(n));
+    }), r.forEach(e.edges(), function(n) {
+      var o = e.edge(n);
+      r.forEach(o.points, i), r.has(o, "y") && i(o);
+    });
+  }
+  function i(e) {
+    e.y = -e.y;
+  }
+  function v(e) {
+    r.forEach(e.nodes(), function(n) {
+      a(e.node(n));
+    }), r.forEach(e.edges(), function(n) {
+      var o = e.edge(n);
+      r.forEach(o.points, a), r.has(o, "x") && a(o);
+    });
+  }
+  function a(e) {
+    var n = e.x;
+    e.x = e.y, e.y = n;
+  }
+  return f;
+}
+export {
+  y as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/data/list.js

@@ -0,0 +1,32 @@
+var r, s;
+function v() {
+  if (s) return r;
+  s = 1, r = n;
+  function n() {
+    var e = {};
+    e._next = e._prev = e, this._sentinel = e;
+  }
+  n.prototype.dequeue = function() {
+    var e = this._sentinel, t = e._prev;
+    if (t !== e)
+      return _(t), t;
+  }, n.prototype.enqueue = function(e) {
+    var t = this._sentinel;
+    e._prev && e._next && _(e), e._next = t._next, t._next._prev = e, t._next = e, e._prev = t;
+  }, n.prototype.toString = function() {
+    for (var e = [], t = this._sentinel, i = t._prev; i !== t; )
+      e.push(JSON.stringify(i, u)), i = i._prev;
+    return "[" + e.join(", ") + "]";
+  };
+  function _(e) {
+    e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+  }
+  function u(e, t) {
+    if (e !== "_next" && e !== "_prev")
+      return t;
+  }
+  return r;
+}
+export {
+  v as __require
+};

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

@@ -0,0 +1,29 @@
+import { __require as m } from "./lodash.js";
+import { __require as p } from "./util.js";
+import { __require as q } from "./graphlib.js";
+var i, n;
+function v() {
+  if (n) return i;
+  n = 1;
+  var a = m(), o = p(), d = q().Graph;
+  i = {
+    debugOrdering: s
+  };
+  function s(u) {
+    var f = o.buildLayerMatrix(u), e = new d({ compound: !0, multigraph: !0 }).setGraph({});
+    return a.forEach(u.nodes(), function(r) {
+      e.setNode(r, { label: r }), e.setParent(r, "layer" + u.node(r).rank);
+    }), a.forEach(u.edges(), function(r) {
+      e.setEdge(r.v, r.w, {}, r.name);
+    }), a.forEach(f, function(r, l) {
+      var c = "layer" + l;
+      e.setNode(c, { rank: "same" }), a.reduce(r, function(h, t) {
+        return e.setEdge(h, t, { style: "invis" }), t;
+      });
+    }), e;
+  }
+  return i;
+}
+export {
+  v as __require
+};

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

@@ -0,0 +1,17 @@
+import { commonjsRequire as a } from "../../../../../_virtual/_commonjs-dynamic-modules.js";
+import { __require as o } from "../../graphlib/index.js";
+var i, e;
+function f() {
+  if (e) return i;
+  e = 1;
+  var r;
+  if (typeof a == "function")
+    try {
+      r = o();
+    } catch {
+    }
+  return r || (r = window.graphlib), i = r, i;
+}
+export {
+  f as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/greedy-fas.js

@@ -0,0 +1,67 @@
+import { __require as F } from "./lodash.js";
+import { __require as g } from "./graphlib.js";
+import { __require as x } from "./data/list.js";
+var w, q;
+function C() {
+  if (q) return w;
+  q = 1;
+  var i = F(), m = g().Graph, p = x();
+  w = c;
+  var E = i.constant(1);
+  function c(e, u) {
+    if (e.nodeCount() <= 1)
+      return [];
+    var r = _(e, u || E), o = l(r.graph, r.buckets, r.zeroIdx);
+    return i.flatten(i.map(o, function(t) {
+      return e.outEdges(t.v, t.w);
+    }), !0);
+  }
+  function l(e, u, r) {
+    for (var o = [], t = u[u.length - 1], v = u[0], a; e.nodeCount(); ) {
+      for (; a = v.dequeue(); )
+        h(e, u, r, a);
+      for (; a = t.dequeue(); )
+        h(e, u, r, a);
+      if (e.nodeCount()) {
+        for (var n = u.length - 2; n > 0; --n)
+          if (a = u[n].dequeue(), a) {
+            o = o.concat(h(e, u, r, a, !0));
+            break;
+          }
+      }
+    }
+    return o;
+  }
+  function h(e, u, r, o, t) {
+    var v = t ? [] : void 0;
+    return i.forEach(e.inEdges(o.v), function(a) {
+      var n = e.edge(a), f = e.node(a.v);
+      t && v.push({ v: a.v, w: a.w }), f.out -= n, s(u, r, f);
+    }), i.forEach(e.outEdges(o.v), function(a) {
+      var n = e.edge(a), f = a.w, d = e.node(f);
+      d.in -= n, s(u, r, d);
+    }), e.removeNode(o.v), v;
+  }
+  function _(e, u) {
+    var r = new m(), o = 0, t = 0;
+    i.forEach(e.nodes(), function(n) {
+      r.setNode(n, { v: n, in: 0, out: 0 });
+    }), i.forEach(e.edges(), function(n) {
+      var f = r.edge(n.v, n.w) || 0, d = u(n), G = f + d;
+      r.setEdge(n.v, n.w, G), t = Math.max(t, r.node(n.v).out += d), o = Math.max(o, r.node(n.w).in += d);
+    });
+    var v = i.range(t + o + 3).map(function() {
+      return new p();
+    }), a = o + 1;
+    return i.forEach(r.nodes(), function(n) {
+      s(v, a, r.node(n));
+    }), { graph: r, buckets: v, zeroIdx: a };
+  }
+  function s(e, u, r) {
+    r.out ? r.in ? e[r.out - r.in + u].enqueue(r) : e[e.length - 1].enqueue(r) : e[0].enqueue(r);
+  }
+  return w;
+}
+export {
+  C as __require
+};