@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/util.mjs

@@ -1,164 +0,0 @@
-import * as _ from "lodash-es";
-import { Graph } from "../graphlib/graph.mjs";
-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(), function(v) {
-    simplified.setNode(v, g.node(v));
-  });
-  _.forEach(g.edges(), function(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(), function(v) {
-    if (!g.children(v).length) {
-      simplified.setNode(v, g.node(v));
-    }
-  });
-  _.forEach(g.edges(), function(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), function() {
-    return [];
-  });
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    var rank = node.rank;
-    if (!_.isUndefined(rank)) {
-      layering[rank][node.order] = v;
-    }
-  });
-  return layering;
-}
-function normalizeRanks(g) {
-  var min = _.min(
-    _.map(g.nodes(), function(v) {
-      return g.node(v).rank;
-    })
-  );
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    if (_.has(node, "rank")) {
-      node.rank -= min;
-    }
-  });
-}
-function removeEmptyRanks(g) {
-  var offset = _.min(
-    _.map(g.nodes(), function(v) {
-      return g.node(v).rank;
-    })
-  );
-  var layers = [];
-  _.forEach(g.nodes(), function(v) {
-    var rank = g.node(v).rank - offset;
-    if (!layers[rank]) {
-      layers[rank] = [];
-    }
-    layers[rank].push(v);
-  });
-  var delta = 0;
-  var nodeRankFactor = g.graph().nodeRankFactor;
-  _.forEach(layers, function(vs, i) {
-    if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {
-      --delta;
-    } else if (delta) {
-      _.forEach(vs, function(v) {
-        g.node(v).rank += delta;
-      });
-    }
-  });
-}
-function addBorderNode(g, prefix, rank, order) {
-  var node = {
-    width: 0,
-    height: 0
-  };
-  if (arguments.length >= 4) {
-    node.rank = rank;
-    node.order = order;
-  }
-  return addDummyNode(g, "border", node, prefix);
-}
-function maxRank(g) {
-  return _.max(
-    _.map(g.nodes(), function(v) {
-      var rank = g.node(v).rank;
-      if (!_.isUndefined(rank)) {
-        return rank;
-      }
-    })
-  );
-}
-function partition(collection, fn) {
-  var result = { lhs: [], rhs: [] };
-  _.forEach(collection, function(value) {
-    if (fn(value)) {
-      result.lhs.push(value);
-    } else {
-      result.rhs.push(value);
-    }
-  });
-  return result;
-}
-function notime(name, fn) {
-  return fn();
-}
-export {
-  addBorderNode,
-  addDummyNode,
-  asNonCompoundGraph,
-  buildLayerMatrix,
-  intersectRect,
-  maxRank,
-  normalizeRanks,
-  notime,
-  partition,
-  removeEmptyRanks,
-  simplify
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/dfs.mjs

@@ -1,33 +0,0 @@
-import * as _ from "lodash-es";
-function dfs(g, vs, order) {
-  if (!_.isArray(vs)) {
-    vs = [vs];
-  }
-  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
-  var acc = [];
-  var visited = {};
-  _.each(vs, function(v) {
-    if (!g.hasNode(v)) {
-      throw new Error("Graph does not have node: " + v);
-    }
-    doDfs(g, v, order === "post", visited, navigation, acc);
-  });
-  return acc;
-}
-function doDfs(g, v, postorder, visited, navigation, acc) {
-  if (!Object.prototype.hasOwnProperty.call(visited, v)) {
-    visited[v] = true;
-    if (!postorder) {
-      acc.push(v);
-    }
-    _.each(navigation(v), function(w) {
-      doDfs(g, w, postorder, visited, navigation, acc);
-    });
-    if (postorder) {
-      acc.push(v);
-    }
-  }
-}
-export {
-  dfs
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.mjs

@@ -1,2 +0,0 @@
-import * as _ from "lodash-es";
-_.constant(1);

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.mjs

@@ -1,2 +0,0 @@
-import * as _ from "lodash-es";
-_.constant(1);

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/postorder.mjs

@@ -1,7 +0,0 @@
-import { dfs } from "./dfs.mjs";
-function postorder(g, vs) {
-  return dfs(g, vs, "post");
-}
-export {
-  postorder
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/preorder.mjs

@@ -1,7 +0,0 @@
-import { dfs } from "./dfs.mjs";
-function preorder(g, vs) {
-  return dfs(g, vs, "pre");
-}
-export {
-  preorder
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/alg/topsort.mjs

@@ -1,7 +0,0 @@
-import "lodash-es";
-function CycleException() {
-}
-CycleException.prototype = new Error();
-export {
-  CycleException
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/graph.mjs

@@ -1,420 +0,0 @@
-import * as _ from "lodash-es";
-var DEFAULT_EDGE_NAME = "\0";
-var GRAPH_NODE = "\0";
-var EDGE_KEY_DELIM = "
";
-class Graph {
-  constructor(opts = {}) {
-    this._isDirected = Object.prototype.hasOwnProperty.call(opts, "directed") ? opts.directed : true;
-    this._isMultigraph = Object.prototype.hasOwnProperty.call(opts, "multigraph") ? opts.multigraph : false;
-    this._isCompound = Object.prototype.hasOwnProperty.call(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() {
-    var self = this;
-    return _.filter(this.nodes(), function(v) {
-      return _.isEmpty(self._in[v]);
-    });
-  }
-  sinks() {
-    var self = this;
-    return _.filter(this.nodes(), function(v) {
-      return _.isEmpty(self._out[v]);
-    });
-  }
-  setNodes(vs, value) {
-    var args = arguments;
-    var self = this;
-    _.each(vs, function(v) {
-      if (args.length > 1) {
-        self.setNode(v, value);
-      } else {
-        self.setNode(v);
-      }
-    });
-    return this;
-  }
-  setNode(v, value) {
-    if (Object.prototype.hasOwnProperty.call(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 Object.prototype.hasOwnProperty.call(this._nodes, v);
-  }
-  removeNode(v) {
-    if (Object.prototype.hasOwnProperty.call(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, function(value, v) {
-      if (filter(v)) {
-        copy.setNode(v, value);
-      }
-    });
-    _.each(this._edgeObjs, function(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(), function(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 self = this;
-    var args = arguments;
-    _.reduce(vs, function(v, w) {
-      if (args.length > 1) {
-        self.setEdge(v, w, value);
-      } else {
-        self.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 (Object.prototype.hasOwnProperty.call(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 Object.prototype.hasOwnProperty.call(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, function(edge) {
-        return edge.v === u;
-      });
-    }
-  }
-  outEdges(v, w) {
-    var outV = this._out[v];
-    if (outV) {
-      var edges = _.values(outV);
-      if (!w) {
-        return edges;
-      }
-      return _.filter(edges, function(edge) {
-        return 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);
-}
-export {
-  Graph
-};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/graphlib/json.mjs

@@ -1,47 +0,0 @@
-import * as _ from "lodash-es";
-import "./graph.mjs";
-function write(g) {
-  var json = {
-    options: {
-      directed: g.isDirected(),
-      multigraph: g.isMultigraph(),
-      compound: g.isCompound()
-    },
-    nodes: writeNodes(g),
-    edges: writeEdges(g)
-  };
-  if (!_.isUndefined(g.graph())) {
-    json.value = _.clone(g.graph());
-  }
-  return json;
-}
-function writeNodes(g) {
-  return _.map(g.nodes(), function(v) {
-    var nodeValue = g.node(v);
-    var parent = g.parent(v);
-    var node = { v };
-    if (!_.isUndefined(nodeValue)) {
-      node.value = nodeValue;
-    }
-    if (!_.isUndefined(parent)) {
-      node.parent = parent;
-    }
-    return node;
-  });
-}
-function writeEdges(g) {
-  return _.map(g.edges(), function(e) {
-    var edgeValue = g.edge(e);
-    var edge = { v: e.v, w: e.w };
-    if (!_.isUndefined(e.name)) {
-      edge.name = e.name;
-    }
-    if (!_.isUndefined(edgeValue)) {
-      edge.value = edgeValue;
-    }
-    return edge;
-  });
-}
-export {
-  write
-};