@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,144 @@
+import { __require as G } from "./lodash.js";
+import { __require as _ } from "./graphlib.js";
+var h, l;
+function L() {
+  if (l) return h;
+  l = 1;
+  var i = G(), c = _().Graph;
+  h = {
+    addDummyNode: m,
+    simplify: v,
+    asNonCompoundGraph: w,
+    successorWeights: k,
+    predecessorWeights: y,
+    intersectRect: E,
+    buildLayerMatrix: x,
+    normalizeRanks: b,
+    removeEmptyRanks: N,
+    addBorderNode: R,
+    maxRank: p,
+    partition: g,
+    time: q,
+    notime: M
+  };
+  function m(n, r, e, a) {
+    var o;
+    do
+      o = i.uniqueId(a);
+    while (n.hasNode(o));
+    return e.dummy = r, n.setNode(o, e), o;
+  }
+  function v(n) {
+    var r = new c().setGraph(n.graph());
+    return i.forEach(n.nodes(), function(e) {
+      r.setNode(e, n.node(e));
+    }), i.forEach(n.edges(), function(e) {
+      var a = r.edge(e.v, e.w) || { weight: 0, minlen: 1 }, o = n.edge(e);
+      r.setEdge(e.v, e.w, {
+        weight: a.weight + o.weight,
+        minlen: Math.max(a.minlen, o.minlen)
+      });
+    }), r;
+  }
+  function w(n) {
+    var r = new c({ multigraph: n.isMultigraph() }).setGraph(n.graph());
+    return i.forEach(n.nodes(), function(e) {
+      n.children(e).length || r.setNode(e, n.node(e));
+    }), i.forEach(n.edges(), function(e) {
+      r.setEdge(e, n.edge(e));
+    }), r;
+  }
+  function k(n) {
+    var r = i.map(n.nodes(), function(e) {
+      var a = {};
+      return i.forEach(n.outEdges(e), function(o) {
+        a[o.w] = (a[o.w] || 0) + n.edge(o).weight;
+      }), a;
+    });
+    return i.zipObject(n.nodes(), r);
+  }
+  function y(n) {
+    var r = i.map(n.nodes(), function(e) {
+      var a = {};
+      return i.forEach(n.inEdges(e), function(o) {
+        a[o.v] = (a[o.v] || 0) + n.edge(o).weight;
+      }), a;
+    });
+    return i.zipObject(n.nodes(), r);
+  }
+  function E(n, r) {
+    var e = n.x, a = n.y, o = r.x - e, t = r.y - a, s = n.width / 2, d = n.height / 2;
+    if (!o && !t)
+      throw new Error("Not possible to find intersection inside of the rectangle");
+    var u, f;
+    return Math.abs(t) * s > Math.abs(o) * d ? (t < 0 && (d = -d), u = d * o / t, f = d) : (o < 0 && (s = -s), u = s, f = s * t / o), { x: e + u, y: a + f };
+  }
+  function x(n) {
+    var r = i.map(i.range(p(n) + 1), function() {
+      return [];
+    });
+    return i.forEach(n.nodes(), function(e) {
+      var a = n.node(e), o = a.rank;
+      i.isUndefined(o) || (r[o][a.order] = e);
+    }), r;
+  }
+  function b(n) {
+    var r = i.min(i.map(n.nodes(), function(e) {
+      return n.node(e).rank;
+    }));
+    i.forEach(n.nodes(), function(e) {
+      var a = n.node(e);
+      i.has(a, "rank") && (a.rank -= r);
+    });
+  }
+  function N(n) {
+    var r = i.min(i.map(n.nodes(), function(t) {
+      return n.node(t).rank;
+    })), e = [];
+    i.forEach(n.nodes(), function(t) {
+      var s = n.node(t).rank - r;
+      e[s] || (e[s] = []), e[s].push(t);
+    });
+    var a = 0, o = n.graph().nodeRankFactor;
+    i.forEach(e, function(t, s) {
+      i.isUndefined(t) && s % o !== 0 ? --a : a && i.forEach(t, function(d) {
+        n.node(d).rank += a;
+      });
+    });
+  }
+  function R(n, r, e, a) {
+    var o = {
+      width: 0,
+      height: 0
+    };
+    return arguments.length >= 4 && (o.rank = e, o.order = a), m(n, "border", o, r);
+  }
+  function p(n) {
+    return i.max(i.map(n.nodes(), function(r) {
+      var e = n.node(r).rank;
+      if (!i.isUndefined(e))
+        return e;
+    }));
+  }
+  function g(n, r) {
+    var e = { lhs: [], rhs: [] };
+    return i.forEach(n, function(a) {
+      r(a) ? e.lhs.push(a) : e.rhs.push(a);
+    }), e;
+  }
+  function q(n, r) {
+    var e = i.now();
+    try {
+      return r();
+    } finally {
+      console.log(n + " time: " + (i.now() - e) + "ms");
+    }
+  }
+  function M(n, r) {
+    return r();
+  }
+  return h;
+}
+export {
+  L as __require
+};

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

@@ -0,0 +1,7 @@
+var r, e;
+function i() {
+  return e || (e = 1, r = "0.8.5"), r;
+}
+export {
+  i as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as a } from "./lib/index.js";
+import { __require as o } from "./lib/json.js";
+import { __require as u } from "./lib/alg/index.js";
+var r, i;
+function n() {
+  if (i) return r;
+  i = 1;
+  var e = a();
+  return r = {
+    Graph: e.Graph,
+    json: o(),
+    alg: u(),
+    version: e.version
+  }, r;
+}
+export {
+  n as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/components.js

@@ -0,0 +1,21 @@
+import { __require as p } from "../lodash.js";
+var t, a;
+function h() {
+  if (a) return t;
+  a = 1;
+  var r = p();
+  t = c;
+  function c(s) {
+    var u = {}, i = [], n;
+    function o(e) {
+      r.has(u, e) || (u[e] = !0, n.push(e), r.each(s.successors(e), o), r.each(s.predecessors(e), o));
+    }
+    return r.each(s.nodes(), function(e) {
+      n = [], o(e), n.length && i.push(n);
+    }), i;
+  }
+  return t;
+}
+export {
+  h as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/dfs.js

@@ -0,0 +1,26 @@
+import { __require as d } from "../lodash.js";
+var o, t;
+function q() {
+  if (t) return o;
+  t = 1;
+  var s = d();
+  o = c;
+  function c(e, r, i) {
+    s.isArray(r) || (r = [r]);
+    var n = (e.isDirected() ? e.successors : e.neighbors).bind(e), f = [], u = {};
+    return s.each(r, function(a) {
+      if (!e.hasNode(a))
+        throw new Error("Graph does not have node: " + a);
+      h(e, a, i === "post", u, n, f);
+    }), f;
+  }
+  function h(e, r, i, n, f, u) {
+    s.has(n, r) || (n[r] = !0, i || u.push(r), s.each(f(r), function(a) {
+      h(e, a, i, n, f, u);
+    }), i && u.push(r));
+  }
+  return o;
+}
+export {
+  q as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/dijkstra-all.js

@@ -0,0 +1,18 @@
+import { __require as _ } from "./dijkstra.js";
+import { __require as f } from "../lodash.js";
+var r, a;
+function j() {
+  if (a) return r;
+  a = 1;
+  var t = _(), s = f();
+  r = u;
+  function u(e, n, o) {
+    return s.transform(e.nodes(), function(l, i) {
+      l[i] = t(e, i, n, o);
+    }, {});
+  }
+  return r;
+}
+export {
+  j as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/dijkstra.js

@@ -0,0 +1,38 @@
+import { __require as m } from "../lodash.js";
+import { __require as j } from "../data/priority-queue.js";
+var _, I;
+function b() {
+  if (I) return _;
+  I = 1;
+  var h = m(), w = j();
+  _ = q;
+  var E = h.constant(1);
+  function q(a, s, u, o) {
+    return N(
+      a,
+      String(s),
+      u || E,
+      o || function(e) {
+        return a.outEdges(e);
+      }
+    );
+  }
+  function N(a, s, u, o) {
+    var e = {}, n = new w(), i, d, k = function(r) {
+      var t = r.v !== i ? r.v : r.w, c = e[t], v = u(r), f = d.distance + v;
+      if (v < 0)
+        throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + r + " Weight: " + v);
+      f < c.distance && (c.distance = f, c.predecessor = i, n.decrease(t, f));
+    };
+    for (a.nodes().forEach(function(r) {
+      var t = r === s ? 0 : Number.POSITIVE_INFINITY;
+      e[r] = { distance: t }, n.add(r, t);
+    }); n.size() > 0 && (i = n.removeMin(), d = e[i], d.distance !== Number.POSITIVE_INFINITY); )
+      o(i).forEach(k);
+    return e;
+  }
+  return _;
+}
+export {
+  b as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/find-cycles.js

@@ -0,0 +1,18 @@
+import { __require as s } from "../lodash.js";
+import { __require as f } from "./tarjan.js";
+var e, n;
+function d() {
+  if (n) return e;
+  n = 1;
+  var a = s(), u = f();
+  e = t;
+  function t(i) {
+    return a.filter(u(i), function(r) {
+      return r.length > 1 || r.length === 1 && i.hasEdge(r[0], r[0]);
+    });
+  }
+  return e;
+}
+export {
+  d as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/floyd-warshall.js

@@ -0,0 +1,42 @@
+import { __require as p } from "../lodash.js";
+var f, E;
+function y() {
+  if (E) return f;
+  E = 1;
+  var _ = p();
+  f = I;
+  var v = _.constant(1);
+  function I(e, i, s) {
+    return F(
+      e,
+      i || v,
+      s || function(a) {
+        return e.outEdges(a);
+      }
+    );
+  }
+  function F(e, i, s) {
+    var a = {}, o = e.nodes();
+    return o.forEach(function(r) {
+      a[r] = {}, a[r][r] = { distance: 0 }, o.forEach(function(n) {
+        r !== n && (a[r][n] = { distance: Number.POSITIVE_INFINITY });
+      }), s(r).forEach(function(n) {
+        var c = n.v === r ? n.w : n.v, t = i(n);
+        a[r][c] = { distance: t, predecessor: r };
+      });
+    }), o.forEach(function(r) {
+      var n = a[r];
+      o.forEach(function(c) {
+        var t = a[c];
+        o.forEach(function(d) {
+          var W = t[r], l = n[d], u = t[d], h = W.distance + l.distance;
+          h < u.distance && (u.distance = h, u.predecessor = l.predecessor);
+        });
+      });
+    }), a;
+  }
+  return f;
+}
+export {
+  y as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/index.js

@@ -0,0 +1,30 @@
+import { __require as i } from "./components.js";
+import { __require as o } from "./dijkstra.js";
+import { __require as s } from "./dijkstra-all.js";
+import { __require as a } from "./find-cycles.js";
+import { __require as u } from "./floyd-warshall.js";
+import { __require as t } from "./is-acyclic.js";
+import { __require as m } from "./postorder.js";
+import { __require as q } from "./preorder.js";
+import { __require as _ } from "./prim.js";
+import { __require as p } from "./tarjan.js";
+import { __require as l } from "./topsort.js";
+var r, e;
+function P() {
+  return e || (e = 1, r = {
+    components: i(),
+    dijkstra: o(),
+    dijkstraAll: s(),
+    findCycles: a(),
+    floydWarshall: u(),
+    isAcyclic: t(),
+    postorder: m(),
+    preorder: q(),
+    prim: _(),
+    tarjan: p(),
+    topsort: l()
+  }), r;
+}
+export {
+  P as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/is-acyclic.js

@@ -0,0 +1,22 @@
+import { __require as u } from "./topsort.js";
+var r, i;
+function s() {
+  if (i) return r;
+  i = 1;
+  var e = u();
+  r = t;
+  function t(o) {
+    try {
+      e(o);
+    } catch (c) {
+      if (c instanceof e.CycleException)
+        return !1;
+      throw c;
+    }
+    return !0;
+  }
+  return r;
+}
+export {
+  s as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/postorder.js

@@ -0,0 +1,15 @@
+import { __require as i } from "./dfs.js";
+var r, e;
+function a() {
+  if (e) return r;
+  e = 1;
+  var o = i();
+  r = t;
+  function t(s, u) {
+    return o(s, u, "post");
+  }
+  return r;
+}
+export {
+  a as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/preorder.js

@@ -0,0 +1,15 @@
+import { __require as t } from "./dfs.js";
+var r, e;
+function d() {
+  if (e) return r;
+  e = 1;
+  var u = t();
+  r = i;
+  function i(o, n) {
+    return u(o, n, "pre");
+  }
+  return r;
+}
+export {
+  d as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/prim.js

@@ -0,0 +1,40 @@
+import { __require as w } from "../lodash.js";
+import { __require as I } from "../graph.js";
+import { __require as l } from "../data/priority-queue.js";
+var t, d;
+function y() {
+  if (d) return t;
+  d = 1;
+  var s = w(), m = I(), _ = l();
+  t = c;
+  function c(a, h) {
+    var n = new m(), o = {}, i = new _(), r;
+    function q(e) {
+      var u = e.v === r ? e.w : e.v, v = i.priority(u);
+      if (v !== void 0) {
+        var p = h(e);
+        p < v && (o[u] = r, i.decrease(u, p));
+      }
+    }
+    if (a.nodeCount() === 0)
+      return n;
+    s.each(a.nodes(), function(e) {
+      i.add(e, Number.POSITIVE_INFINITY), n.setNode(e);
+    }), i.decrease(a.nodes()[0], 0);
+    for (var f = !1; i.size() > 0; ) {
+      if (r = i.removeMin(), s.has(o, r))
+        n.setEdge(r, o[r]);
+      else {
+        if (f)
+          throw new Error("Input graph is not connected: " + a);
+        f = !0;
+      }
+      a.nodeEdges(r).forEach(q);
+    }
+    return n;
+  }
+  return t;
+}
+export {
+  y as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/tarjan.js

@@ -0,0 +1,34 @@
+import { __require as v } from "../lodash.js";
+var o, k;
+function _() {
+  if (k) return o;
+  k = 1;
+  var s = v();
+  o = d;
+  function d(t) {
+    var u = 0, l = [], r = {}, f = [];
+    function c(n) {
+      var a = r[n] = {
+        onStack: !0,
+        lowlink: u,
+        index: u++
+      };
+      if (l.push(n), t.successors(n).forEach(function(i) {
+        s.has(r, i) ? r[i].onStack && (a.lowlink = Math.min(a.lowlink, r[i].index)) : (c(i), a.lowlink = Math.min(a.lowlink, r[i].lowlink));
+      }), a.lowlink === a.index) {
+        var h = [], e;
+        do
+          e = l.pop(), r[e].onStack = !1, h.push(e);
+        while (n !== e);
+        f.push(h);
+      }
+    }
+    return t.nodes().forEach(function(n) {
+      s.has(r, n) || c(n);
+    }), f;
+  }
+  return o;
+}
+export {
+  _ as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/alg/topsort.js

@@ -0,0 +1,25 @@
+import { __require as f } from "../lodash.js";
+var u, p;
+function v() {
+  if (p) return u;
+  p = 1;
+  var e = f();
+  u = a, a.CycleException = t;
+  function a(i) {
+    var s = {}, o = {}, n = [];
+    function c(r) {
+      if (e.has(o, r))
+        throw new t();
+      e.has(s, r) || (o[r] = !0, s[r] = !0, e.each(i.predecessors(r), c), delete o[r], n.push(r));
+    }
+    if (e.each(i.sinks(), c), e.size(s) !== i.nodeCount())
+      throw new t();
+    return n;
+  }
+  function t() {
+  }
+  return t.prototype = new Error(), u;
+}
+export {
+  v as __require
+};

package/lib/packages/hooks/node_modules/graphlib/lib/data/priority-queue.js

@@ -0,0 +1,56 @@
+import { __require as u } from "../lodash.js";
+var n, h;
+function _() {
+  if (h) return n;
+  h = 1;
+  var s = u();
+  n = a;
+  function a() {
+    this._arr = [], this._keyIndices = {};
+  }
+  return a.prototype.size = function() {
+    return this._arr.length;
+  }, a.prototype.keys = function() {
+    return this._arr.map(function(r) {
+      return r.key;
+    });
+  }, a.prototype.has = function(r) {
+    return s.has(this._keyIndices, r);
+  }, a.prototype.priority = function(r) {
+    var t = this._keyIndices[r];
+    if (t !== void 0)
+      return this._arr[t].priority;
+  }, a.prototype.min = function() {
+    if (this.size() === 0)
+      throw new Error("Queue underflow");
+    return this._arr[0].key;
+  }, a.prototype.add = function(r, t) {
+    var i = this._keyIndices;
+    if (r = String(r), !s.has(i, r)) {
+      var o = this._arr, e = o.length;
+      return i[r] = e, o.push({ key: r, priority: t }), this._decrease(e), !0;
+    }
+    return !1;
+  }, a.prototype.removeMin = function() {
+    this._swap(0, this._arr.length - 1);
+    var r = this._arr.pop();
+    return delete this._keyIndices[r.key], this._heapify(0), r.key;
+  }, a.prototype.decrease = function(r, t) {
+    var i = this._keyIndices[r];
+    if (t > this._arr[i].priority)
+      throw new Error("New priority is greater than current priority. Key: " + r + " Old: " + this._arr[i].priority + " New: " + t);
+    this._arr[i].priority = t, this._decrease(i);
+  }, a.prototype._heapify = function(r) {
+    var t = this._arr, i = 2 * r, o = i + 1, e = r;
+    i < t.length && (e = t[i].priority < t[e].priority ? i : e, o < t.length && (e = t[o].priority < t[e].priority ? o : e), e !== r && (this._swap(r, e), this._heapify(e)));
+  }, a.prototype._decrease = function(r) {
+    for (var t = this._arr, i = t[r].priority, o; r !== 0 && (o = r >> 1, !(t[o].priority < i)); )
+      this._swap(r, o), r = o;
+  }, a.prototype._swap = function(r, t) {
+    var i = this._arr, o = this._keyIndices, e = i[r], p = i[t];
+    i[r] = p, i[t] = e, o[p.key] = r, o[e.key] = t;
+  }, n;
+}
+export {
+  _ as __require
+};