@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/dagre/lib/order/resolve-conflicts.js

@@ -0,0 +1,61 @@
+import { __require as v } from "../lodash.js";
+var a, u;
+function p() {
+  if (u) return a;
+  u = 1;
+  var f = v();
+  a = s;
+  function s(i, t) {
+    var o = {};
+    f.forEach(i, function(e, n) {
+      var r = o[e.v] = {
+        indegree: 0,
+        in: [],
+        out: [],
+        vs: [e.v],
+        i: n
+      };
+      f.isUndefined(e.barycenter) || (r.barycenter = e.barycenter, r.weight = e.weight);
+    }), f.forEach(t.edges(), function(e) {
+      var n = o[e.v], r = o[e.w];
+      !f.isUndefined(n) && !f.isUndefined(r) && (r.indegree++, n.out.push(o[e.w]));
+    });
+    var c = f.filter(o, function(e) {
+      return !e.indegree;
+    });
+    return h(c);
+  }
+  function h(i) {
+    var t = [];
+    function o(n) {
+      return function(r) {
+        r.merged || (f.isUndefined(r.barycenter) || f.isUndefined(n.barycenter) || r.barycenter >= n.barycenter) && d(n, r);
+      };
+    }
+    function c(n) {
+      return function(r) {
+        r.in.push(n), --r.indegree === 0 && i.push(r);
+      };
+    }
+    for (; i.length; ) {
+      var e = i.pop();
+      t.push(e), f.forEach(e.in.reverse(), o(e)), f.forEach(e.out, c(e));
+    }
+    return f.map(
+      f.filter(t, function(n) {
+        return !n.merged;
+      }),
+      function(n) {
+        return f.pick(n, ["vs", "i", "barycenter", "weight"]);
+      }
+    );
+  }
+  function d(i, t) {
+    var o = 0, c = 0;
+    i.weight && (o += i.barycenter * i.weight, c += i.weight), t.weight && (o += t.barycenter * t.weight, c += t.weight), i.vs = t.vs.concat(i.vs), i.barycenter = o / c, i.weight = c, i.i = Math.min(t.i, i.i), t.merged = !0;
+  }
+  return a;
+}
+export {
+  p as __require
+};

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

@@ -0,0 +1,46 @@
+import { __require as C } from "../lodash.js";
+import { __require as E } from "./barycenter.js";
+import { __require as L } from "./resolve-conflicts.js";
+import { __require as g } from "./sort.js";
+var d, _;
+function A() {
+  if (_) return d;
+  _ = 1;
+  var n = C(), m = E(), q = L(), w = g();
+  d = b;
+  function b(r, e, f, t) {
+    var c = r.children(e), s = r.node(e), o = s ? s.borderLeft : void 0, u = s ? s.borderRight : void 0, h = {};
+    o && (c = n.filter(c, function(a) {
+      return a !== o && a !== u;
+    }));
+    var l = m(r, c);
+    n.forEach(l, function(a) {
+      if (r.children(a.v).length) {
+        var v = b(r, a.v, f, t);
+        h[a.v] = v, n.has(v, "barycenter") && S(a, v);
+      }
+    });
+    var p = q(l, f);
+    y(p, h);
+    var i = w(p, t);
+    if (o && (i.vs = n.flatten([o, i.vs, u], !0), r.predecessors(o).length)) {
+      var x = r.node(r.predecessors(o)[0]), B = r.node(r.predecessors(u)[0]);
+      n.has(i, "barycenter") || (i.barycenter = 0, i.weight = 0), i.barycenter = (i.barycenter * i.weight + x.order + B.order) / (i.weight + 2), i.weight += 2;
+    }
+    return i;
+  }
+  function y(r, e) {
+    n.forEach(r, function(f) {
+      f.vs = n.flatten(f.vs.map(function(t) {
+        return e[t] ? e[t].vs : t;
+      }), !0);
+    });
+  }
+  function S(r, e) {
+    n.isUndefined(r.barycenter) ? (r.barycenter = e.barycenter, r.weight = e.weight) : (r.barycenter = (r.barycenter * r.weight + e.barycenter * e.weight) / (r.weight + e.weight), r.weight += e.weight);
+  }
+  return d;
+}
+export {
+  A as __require
+};

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

@@ -0,0 +1,35 @@
+import { __require as q } from "../lodash.js";
+import { __require as g } from "../util.js";
+var f, p;
+function S() {
+  if (p) return f;
+  p = 1;
+  var i = q(), b = g();
+  f = _;
+  function _(u, e) {
+    var r = b.partition(u, function(t) {
+      return i.has(t, "barycenter");
+    }), a = r.lhs, v = i.sortBy(r.rhs, function(t) {
+      return -t.i;
+    }), n = [], l = 0, o = 0, s = 0;
+    a.sort(m(!!e)), s = h(n, v, s), i.forEach(a, function(t) {
+      s += t.vs.length, n.push(t.vs), l += t.barycenter * t.weight, o += t.weight, s = h(n, v, s);
+    });
+    var c = { vs: i.flatten(n, !0) };
+    return o && (c.barycenter = l / o, c.weight = o), c;
+  }
+  function h(u, e, r) {
+    for (var a; e.length && (a = i.last(e)).i <= r; )
+      e.pop(), u.push(a.vs), r++;
+    return r;
+  }
+  function m(u) {
+    return function(e, r) {
+      return e.barycenter < r.barycenter ? -1 : e.barycenter > r.barycenter ? 1 : u ? r.i - e.i : e.i - r.i;
+    };
+  }
+  return f;
+}
+export {
+  S as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/parent-dummy-chains.js

@@ -0,0 +1,48 @@
+import { __require as w } from "./lodash.js";
+var f, v;
+function _() {
+  if (v) return f;
+  v = 1;
+  var c = w();
+  f = d;
+  function d(r) {
+    var e = p(r);
+    c.forEach(r.graph().dummyChains, function(n) {
+      for (var i = r.node(n), h = i.edgeObj, l = s(r, e, h.v, h.w), o = l.path, u = l.lca, a = 0, t = o[a], m = !0; n !== h.w; ) {
+        if (i = r.node(n), m) {
+          for (; (t = o[a]) !== u && r.node(t).maxRank < i.rank; )
+            a++;
+          t === u && (m = !1);
+        }
+        if (!m) {
+          for (; a < o.length - 1 && r.node(t = o[a + 1]).minRank <= i.rank; )
+            a++;
+          t = o[a];
+        }
+        r.setParent(n, t), n = r.successors(n)[0];
+      }
+    });
+  }
+  function s(r, e, n, i) {
+    var h = [], l = [], o = Math.min(e[n].low, e[i].low), u = Math.max(e[n].lim, e[i].lim), a, t;
+    a = n;
+    do
+      a = r.parent(a), h.push(a);
+    while (a && (e[a].low > o || u > e[a].lim));
+    for (t = a, a = i; (a = r.parent(a)) !== t; )
+      l.push(a);
+    return { path: h.concat(l.reverse()), lca: t };
+  }
+  function p(r) {
+    var e = {}, n = 0;
+    function i(h) {
+      var l = n;
+      c.forEach(r.children(h), i), e[h] = { low: l, lim: n++ };
+    }
+    return c.forEach(r.children(), i), e;
+  }
+  return f;
+}
+export {
+  _ as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/position/bk.js

@@ -0,0 +1,225 @@
+import { __require as A } from "../lodash.js";
+import { __require as O } from "../graphlib.js";
+import { __require as W } from "../util.js";
+var E, M;
+function X() {
+  if (M) return E;
+  M = 1;
+  var n = A(), V = O().Graph, q = W();
+  E = {
+    positionX: G,
+    findType1Conflicts: I,
+    findType2Conflicts: y,
+    addConflict: b,
+    hasConflict: N,
+    verticalAlignment: T,
+    horizontalCompaction: C,
+    alignCoordinates: L,
+    findSmallestWidthAlignment: g,
+    balance: _
+  };
+  function I(r, i) {
+    var u = {};
+    function d(o, f) {
+      var e = 0, c = 0, t = o.length, a = n.last(f);
+      return n.forEach(f, function(l, s) {
+        var h = w(r, l), m = h ? r.node(h).order : t;
+        (h || l === a) && (n.forEach(f.slice(c, s + 1), function(p) {
+          n.forEach(r.predecessors(p), function(v) {
+            var k = r.node(v), x = k.order;
+            (x < e || m < x) && !(k.dummy && r.node(p).dummy) && b(u, v, p);
+          });
+        }), c = s + 1, e = m);
+      }), f;
+    }
+    return n.reduce(i, d), u;
+  }
+  function y(r, i) {
+    var u = {};
+    function d(f, e, c, t, a) {
+      var l;
+      n.forEach(n.range(e, c), function(s) {
+        l = f[s], r.node(l).dummy && n.forEach(r.predecessors(l), function(h) {
+          var m = r.node(h);
+          m.dummy && (m.order < t || m.order > a) && b(u, h, l);
+        });
+      });
+    }
+    function o(f, e) {
+      var c = -1, t, a = 0;
+      return n.forEach(e, function(l, s) {
+        if (r.node(l).dummy === "border") {
+          var h = r.predecessors(l);
+          h.length && (t = r.node(h[0]).order, d(e, a, s, c, t), a = s, c = t);
+        }
+        d(e, a, e.length, t, f.length);
+      }), e;
+    }
+    return n.reduce(i, o), u;
+  }
+  function w(r, i) {
+    if (r.node(i).dummy)
+      return n.find(r.predecessors(i), function(u) {
+        return r.node(u).dummy;
+      });
+  }
+  function b(r, i, u) {
+    if (i > u) {
+      var d = i;
+      i = u, u = d;
+    }
+    var o = r[i];
+    o || (r[i] = o = {}), o[u] = !0;
+  }
+  function N(r, i, u) {
+    if (i > u) {
+      var d = i;
+      i = u, u = d;
+    }
+    return n.has(r[i], u);
+  }
+  function T(r, i, u, d) {
+    var o = {}, f = {}, e = {};
+    return n.forEach(i, function(c) {
+      n.forEach(c, function(t, a) {
+        o[t] = t, f[t] = t, e[t] = a;
+      });
+    }), n.forEach(i, function(c) {
+      var t = -1;
+      n.forEach(c, function(a) {
+        var l = d(a);
+        if (l.length) {
+          l = n.sortBy(l, function(v) {
+            return e[v];
+          });
+          for (var s = (l.length - 1) / 2, h = Math.floor(s), m = Math.ceil(s); h <= m; ++h) {
+            var p = l[h];
+            f[a] === a && t < e[p] && !N(u, a, p) && (f[p] = a, f[a] = o[a] = o[p], t = e[p]);
+          }
+        }
+      });
+    }), { root: o, align: f };
+  }
+  function C(r, i, u, d, o) {
+    var f = {}, e = P(r, i, u, o), c = o ? "borderLeft" : "borderRight";
+    function t(s, h) {
+      for (var m = e.nodes(), p = m.pop(), v = {}; p; )
+        v[p] ? s(p) : (v[p] = !0, m.push(p), m = m.concat(h(p))), p = m.pop();
+    }
+    function a(s) {
+      f[s] = e.inEdges(s).reduce(function(h, m) {
+        return Math.max(h, f[m.v] + e.edge(m));
+      }, 0);
+    }
+    function l(s) {
+      var h = e.outEdges(s).reduce(function(p, v) {
+        return Math.min(p, f[v.w] - e.edge(v));
+      }, Number.POSITIVE_INFINITY), m = r.node(s);
+      h !== Number.POSITIVE_INFINITY && m.borderType !== c && (f[s] = Math.max(f[s], h));
+    }
+    return t(a, e.predecessors.bind(e)), t(l, e.successors.bind(e)), n.forEach(d, function(s) {
+      f[s] = f[u[s]];
+    }), f;
+  }
+  function P(r, i, u, d) {
+    var o = new V(), f = r.graph(), e = B(f.nodesep, f.edgesep, d);
+    return n.forEach(i, function(c) {
+      var t;
+      n.forEach(c, function(a) {
+        var l = u[a];
+        if (o.setNode(l), t) {
+          var s = u[t], h = o.edge(s, l);
+          o.setEdge(s, l, Math.max(e(r, a, t), h || 0));
+        }
+        t = a;
+      });
+    }), o;
+  }
+  function g(r, i) {
+    return n.minBy(n.values(i), function(u) {
+      var d = Number.NEGATIVE_INFINITY, o = Number.POSITIVE_INFINITY;
+      return n.forIn(u, function(f, e) {
+        var c = F(r, e) / 2;
+        d = Math.max(f + c, d), o = Math.min(f - c, o);
+      }), d - o;
+    });
+  }
+  function L(r, i) {
+    var u = n.values(i), d = n.min(u), o = n.max(u);
+    n.forEach(["u", "d"], function(f) {
+      n.forEach(["l", "r"], function(e) {
+        var c = f + e, t = r[c], a;
+        if (t !== i) {
+          var l = n.values(t);
+          a = e === "l" ? d - n.min(l) : o - n.max(l), a && (r[c] = n.mapValues(t, function(s) {
+            return s + a;
+          }));
+        }
+      });
+    });
+  }
+  function _(r, i) {
+    return n.mapValues(r.ul, function(u, d) {
+      if (i)
+        return r[i.toLowerCase()][d];
+      var o = n.sortBy(n.map(r, d));
+      return (o[1] + o[2]) / 2;
+    });
+  }
+  function G(r) {
+    var i = q.buildLayerMatrix(r), u = n.merge(
+      I(r, i),
+      y(r, i)
+    ), d = {}, o;
+    n.forEach(["u", "d"], function(e) {
+      o = e === "u" ? i : n.values(i).reverse(), n.forEach(["l", "r"], function(c) {
+        c === "r" && (o = n.map(o, function(s) {
+          return n.values(s).reverse();
+        }));
+        var t = (e === "u" ? r.predecessors : r.successors).bind(r), a = T(r, o, u, t), l = C(
+          r,
+          o,
+          a.root,
+          a.align,
+          c === "r"
+        );
+        c === "r" && (l = n.mapValues(l, function(s) {
+          return -s;
+        })), d[e + c] = l;
+      });
+    });
+    var f = g(r, d);
+    return L(d, f), _(d, r.graph().align);
+  }
+  function B(r, i, u) {
+    return function(d, o, f) {
+      var e = d.node(o), c = d.node(f), t = 0, a;
+      if (t += e.width / 2, n.has(e, "labelpos"))
+        switch (e.labelpos.toLowerCase()) {
+          case "l":
+            a = -e.width / 2;
+            break;
+          case "r":
+            a = e.width / 2;
+            break;
+        }
+      if (a && (t += u ? a : -a), a = 0, t += (e.dummy ? i : r) / 2, t += (c.dummy ? i : r) / 2, t += c.width / 2, n.has(c, "labelpos"))
+        switch (c.labelpos.toLowerCase()) {
+          case "l":
+            a = c.width / 2;
+            break;
+          case "r":
+            a = -c.width / 2;
+            break;
+        }
+      return a && (t += u ? a : -a), a = 0, t;
+    };
+  }
+  function F(r, i) {
+    return r.node(i).width;
+  }
+  return E;
+}
+export {
+  X as __require
+};

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

@@ -0,0 +1,30 @@
+import { __require as v } from "../lodash.js";
+import { __require as _ } from "../util.js";
+import { __require as q } from "./bk.js";
+var a, f;
+function l() {
+  if (f) return a;
+  f = 1;
+  var i = v(), t = _(), c = q().positionX;
+  a = h;
+  function h(r) {
+    r = t.asNonCompoundGraph(r), m(r), i.forEach(c(r), function(o, n) {
+      r.node(n).x = o;
+    });
+  }
+  function m(r) {
+    var o = t.buildLayerMatrix(r), n = r.graph().ranksep, u = 0;
+    i.forEach(o, function(p) {
+      var s = i.max(i.map(p, function(e) {
+        return r.node(e).height;
+      }));
+      i.forEach(p, function(e) {
+        r.node(e).y = u + s / 2;
+      }), u += s + n;
+    });
+  }
+  return a;
+}
+export {
+  l as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/rank/feasible-tree.js

@@ -0,0 +1,41 @@
+import { __require as q } from "../lodash.js";
+import { __require as m } from "../graphlib.js";
+import { __require as p } from "./util.js";
+var u, f;
+function k() {
+  if (f) return u;
+  f = 1;
+  var s = q(), c = m().Graph, t = p().slack;
+  u = h;
+  function h(e) {
+    var r = new c({ directed: !1 }), n = e.nodes()[0], i = e.nodeCount();
+    r.setNode(n, {});
+    for (var a, o; l(r, e) < i; )
+      a = v(r, e), o = r.hasNode(a.v) ? t(e, a) : -t(e, a), _(r, e, o);
+    return r;
+  }
+  function l(e, r) {
+    function n(i) {
+      s.forEach(r.nodeEdges(i), function(a) {
+        var o = a.v, d = i === o ? a.w : o;
+        !e.hasNode(d) && !t(r, a) && (e.setNode(d, {}), e.setEdge(i, d, {}), n(d));
+      });
+    }
+    return s.forEach(e.nodes(), n), e.nodeCount();
+  }
+  function v(e, r) {
+    return s.minBy(r.edges(), function(n) {
+      if (e.hasNode(n.v) !== e.hasNode(n.w))
+        return t(r, n);
+    });
+  }
+  function _(e, r, n) {
+    s.forEach(e.nodes(), function(i) {
+      r.node(i).rank += n;
+    });
+  }
+  return u;
+}
+export {
+  k as __require
+};

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

@@ -0,0 +1,36 @@
+import { __require as f } from "./util.js";
+import { __require as m } from "./feasible-tree.js";
+import { __require as p } from "./network-simplex.js";
+var r, i;
+function c() {
+  if (i) return r;
+  i = 1;
+  var n = f(), a = n.longestPath, o = m(), k = p();
+  r = s;
+  function s(e) {
+    switch (e.graph().ranker) {
+      case "network-simplex":
+        t(e);
+        break;
+      case "tight-tree":
+        l(e);
+        break;
+      case "longest-path":
+        u(e);
+        break;
+      default:
+        t(e);
+    }
+  }
+  var u = a;
+  function l(e) {
+    a(e), o(e);
+  }
+  function t(e) {
+    k(e);
+  }
+  return r;
+}
+export {
+  c as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/rank/network-simplex.js

@@ -0,0 +1,91 @@
+import { __require as F } from "../lodash.js";
+import { __require as G } from "./feasible-tree.js";
+import { __require as L } from "./util.js";
+import { __require as C } from "../graphlib.js";
+import { __require as I } from "../util.js";
+var m, S;
+function J() {
+  if (S) return m;
+  S = 1;
+  var l = F(), x = G(), y = L().slack, R = L().longestPath, T = C().alg.preorder, N = C().alg.postorder, U = I().simplify;
+  m = v, v.initLowLimValues = p, v.initCutValues = c, v.calcCutValue = w, v.leaveEdge = E, v.enterEdge = _, v.exchangeEdges = h;
+  function v(e) {
+    e = U(e), R(e);
+    var r = x(e);
+    p(r), c(r, e);
+    for (var n, a; n = E(r); )
+      a = _(r, e, n), h(r, e, n, a);
+  }
+  function c(e, r) {
+    var n = N(e, e.nodes());
+    n = n.slice(0, n.length - 1), l.forEach(n, function(a) {
+      A(e, r, a);
+    });
+  }
+  function A(e, r, n) {
+    var a = e.node(n), i = a.parent;
+    e.edge(n, i).cutvalue = w(e, r, n);
+  }
+  function w(e, r, n) {
+    var a = e.node(n), i = a.parent, t = !0, u = r.edge(n, i), o = 0;
+    return u || (t = !1, u = r.edge(i, n)), o = u.weight, l.forEach(r.nodeEdges(n), function(f) {
+      var d = f.v === n, s = d ? f.w : f.v;
+      if (s !== i) {
+        var k = d === t, b = r.edge(f).weight;
+        if (o += k ? b : -b, D(e, n, s)) {
+          var V = e.edge(n, s).cutvalue;
+          o += k ? -V : V;
+        }
+      }
+    }), o;
+  }
+  function p(e, r) {
+    arguments.length < 2 && (r = e.nodes()[0]), g(e, {}, 1, r);
+  }
+  function g(e, r, n, a, i) {
+    var t = n, u = e.node(a);
+    return r[a] = !0, l.forEach(e.neighbors(a), function(o) {
+      l.has(r, o) || (n = g(e, r, n, o, a));
+    }), u.low = t, u.lim = n++, i ? u.parent = i : delete u.parent, n;
+  }
+  function E(e) {
+    return l.find(e.edges(), function(r) {
+      return e.edge(r).cutvalue < 0;
+    });
+  }
+  function _(e, r, n) {
+    var a = n.v, i = n.w;
+    r.hasEdge(a, i) || (a = n.w, i = n.v);
+    var t = e.node(a), u = e.node(i), o = t, f = !1;
+    t.lim > u.lim && (o = u, f = !0);
+    var d = l.filter(r.edges(), function(s) {
+      return f === q(e, e.node(s.v), o) && f !== q(e, e.node(s.w), o);
+    });
+    return l.minBy(d, function(s) {
+      return y(r, s);
+    });
+  }
+  function h(e, r, n, a) {
+    var i = n.v, t = n.w;
+    e.removeEdge(i, t), e.setEdge(a.v, a.w, {}), p(e), c(e, r), B(e, r);
+  }
+  function B(e, r) {
+    var n = l.find(e.nodes(), function(i) {
+      return !r.node(i).parent;
+    }), a = T(e, n);
+    a = a.slice(1), l.forEach(a, function(i) {
+      var t = e.node(i).parent, u = r.edge(i, t), o = !1;
+      u || (u = r.edge(t, i), o = !0), r.node(i).rank = r.node(t).rank + (o ? u.minlen : -u.minlen);
+    });
+  }
+  function D(e, r, n) {
+    return e.hasEdge(r, n);
+  }
+  function q(e, r, n) {
+    return n.low <= r.lim && r.lim <= n.lim;
+  }
+  return m;
+}
+export {
+  J as __require
+};

package/lib/packages/hooks/node_modules/dagre/lib/rank/util.js

@@ -0,0 +1,34 @@
+import { __require as c } from "../lodash.js";
+var t, l;
+function m() {
+  if (l) return t;
+  l = 1;
+  var a = c();
+  t = {
+    longestPath: d,
+    slack: f
+  };
+  function d(r) {
+    var n = {};
+    function u(i) {
+      var o = r.node(i);
+      if (a.has(n, i))
+        return o.rank;
+      n[i] = !0;
+      var e = a.min(a.map(r.outEdges(i), function(s) {
+        return u(s.w) - r.edge(s).minlen;
+      }));
+      return (e === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+      e === void 0 || // return value of _.map([]) for Lodash 4
+      e === null) && (e = 0), o.rank = e;
+    }
+    a.forEach(r.sources(), u);
+  }
+  function f(r, n) {
+    return r.node(n.w).rank - r.node(n.v).rank - r.edge(n).minlen;
+  }
+  return t;
+}
+export {
+  m as __require
+};