@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/coordinate-system.mjs

@@ -1,66 +0,0 @@
-import * as _ from "lodash-es";
-function adjust(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapWidthHeight(g);
-  }
-}
-function undo(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "bt" || rankDir === "rl") {
-    reverseY(g);
-  }
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapXY(g);
-    swapWidthHeight(g);
-  }
-}
-function swapWidthHeight(g) {
-  _.forEach(g.nodes(), function(v) {
-    swapWidthHeightOne(g.node(v));
-  });
-  _.forEach(g.edges(), function(e) {
-    swapWidthHeightOne(g.edge(e));
-  });
-}
-function swapWidthHeightOne(attrs) {
-  var w = attrs.width;
-  attrs.width = attrs.height;
-  attrs.height = w;
-}
-function reverseY(g) {
-  _.forEach(g.nodes(), function(v) {
-    reverseYOne(g.node(v));
-  });
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, reverseYOne);
-    if (Object.prototype.hasOwnProperty.call(edge, "y")) {
-      reverseYOne(edge);
-    }
-  });
-}
-function reverseYOne(attrs) {
-  attrs.y = -attrs.y;
-}
-function swapXY(g) {
-  _.forEach(g.nodes(), function(v) {
-    swapXYOne(g.node(v));
-  });
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, swapXYOne);
-    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
-      swapXYOne(edge);
-    }
-  });
-}
-function swapXYOne(attrs) {
-  var x = attrs.x;
-  attrs.x = attrs.y;
-  attrs.y = x;
-}
-export {
-  adjust,
-  undo
-};

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

@@ -1,49 +0,0 @@
-class List {
-  constructor() {
-    var sentinel = {};
-    sentinel._next = sentinel._prev = sentinel;
-    this._sentinel = sentinel;
-  }
-  dequeue() {
-    var sentinel = this._sentinel;
-    var entry = sentinel._prev;
-    if (entry !== sentinel) {
-      unlink(entry);
-      return entry;
-    }
-  }
-  enqueue(entry) {
-    var sentinel = this._sentinel;
-    if (entry._prev && entry._next) {
-      unlink(entry);
-    }
-    entry._next = sentinel._next;
-    sentinel._next._prev = entry;
-    sentinel._next = entry;
-    entry._prev = sentinel;
-  }
-  toString() {
-    var strs = [];
-    var sentinel = this._sentinel;
-    var curr = sentinel._prev;
-    while (curr !== sentinel) {
-      strs.push(JSON.stringify(curr, filterOutLinks));
-      curr = curr._prev;
-    }
-    return "[" + strs.join(", ") + "]";
-  }
-}
-function unlink(entry) {
-  entry._prev._next = entry._next;
-  entry._next._prev = entry._prev;
-  delete entry._next;
-  delete entry._prev;
-}
-function filterOutLinks(k, v) {
-  if (k !== "_next" && k !== "_prev") {
-    return v;
-  }
-}
-export {
-  List
-};

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

@@ -1,97 +0,0 @@
-import * as _ from "lodash-es";
-import { Graph } from "../graphlib/graph.mjs";
-import { List } from "./data/list.mjs";
-var DEFAULT_WEIGHT_FN = _.constant(1);
-function greedyFAS(g, weightFn) {
-  if (g.nodeCount() <= 1) {
-    return [];
-  }
-  var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
-  return _.flatten(
-    _.map(results, function(e) {
-      return g.outEdges(e.v, e.w);
-    })
-  );
-}
-function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
-  var entry;
-  while (g.nodeCount()) {
-    while (entry = sinks.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    while (entry = sources.dequeue()) {
-      removeNode(g, buckets, zeroIdx, entry);
-    }
-    if (g.nodeCount()) {
-      for (var i = buckets.length - 2; i > 0; --i) {
-        entry = buckets[i].dequeue();
-        if (entry) {
-          results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
-          break;
-        }
-      }
-    }
-  }
-  return results;
-}
-function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : void 0;
-  _.forEach(g.inEdges(entry.v), function(edge) {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
-    if (collectPredecessors) {
-      results.push({ v: edge.v, w: edge.w });
-    }
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-  _.forEach(g.outEdges(entry.v), function(edge) {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
-    wEntry["in"] -= weight;
-    assignBucket(buckets, zeroIdx, wEntry);
-  });
-  g.removeNode(entry.v);
-  return results;
-}
-function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
-  _.forEach(g.nodes(), function(v) {
-    fasGraph.setNode(v, { v, in: 0, out: 0 });
-  });
-  _.forEach(g.edges(), function(e) {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var edgeWeight = prevWeight + weight;
-    fasGraph.setEdge(e.v, e.w, edgeWeight);
-    maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
-    maxIn = Math.max(maxIn, fasGraph.node(e.w)["in"] += weight);
-  });
-  var buckets = _.range(maxOut + maxIn + 3).map(function() {
-    return new List();
-  });
-  var zeroIdx = maxIn + 1;
-  _.forEach(fasGraph.nodes(), function(v) {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-  return { graph: fasGraph, buckets, zeroIdx };
-}
-function assignBucket(buckets, zeroIdx, entry) {
-  if (!entry.out) {
-    buckets[0].enqueue(entry);
-  } else if (!entry["in"]) {
-    buckets[buckets.length - 1].enqueue(entry);
-  } else {
-    buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
-  }
-}
-export {
-  greedyFAS
-};

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

@@ -1,344 +0,0 @@
-import * as _ from "lodash-es";
-import { Graph } from "../graphlib/graph.mjs";
-import { addBorderSegments } from "./add-border-segments.mjs";
-import { adjust, undo as undo$1 } from "./coordinate-system.mjs";
-import { run, undo as undo$2 } from "./acyclic.mjs";
-import { run as run$2, undo } from "./normalize.mjs";
-import { rank } from "./rank/index.mjs";
-import { run as run$1, cleanup } from "./nesting-graph.mjs";
-import { order } from "./order/index.mjs";
-import { parentDummyChains } from "./parent-dummy-chains.mjs";
-import { position } from "./position/index.mjs";
-import { notime, asNonCompoundGraph, removeEmptyRanks, normalizeRanks, addDummyNode, intersectRect, buildLayerMatrix } from "./util.mjs";
-function layout(g, opts) {
-  var time = notime;
-  time("layout", () => {
-    var layoutGraph = time("  buildLayoutGraph", () => buildLayoutGraph(g));
-    time("  runLayout", () => runLayout(layoutGraph, time));
-    time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
-  });
-}
-function runLayout(g, time) {
-  time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
-  time("    removeSelfEdges", () => removeSelfEdges(g));
-  time("    acyclic", () => run(g));
-  time("    nestingGraph.run", () => run$1(g));
-  time("    rank", () => rank(asNonCompoundGraph(g)));
-  time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
-  time("    removeEmptyRanks", () => removeEmptyRanks(g));
-  time("    nestingGraph.cleanup", () => cleanup(g));
-  time("    normalizeRanks", () => normalizeRanks(g));
-  time("    assignRankMinMax", () => assignRankMinMax(g));
-  time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
-  time("    normalize.run", () => run$2(g));
-  time("    parentDummyChains", () => parentDummyChains(g));
-  time("    addBorderSegments", () => addBorderSegments(g));
-  time("    order", () => order(g));
-  time("    insertSelfEdges", () => insertSelfEdges(g));
-  time("    adjustCoordinateSystem", () => adjust(g));
-  time("    position", () => position(g));
-  time("    positionSelfEdges", () => positionSelfEdges(g));
-  time("    removeBorderNodes", () => removeBorderNodes(g));
-  time("    normalize.undo", () => undo(g));
-  time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
-  time("    undoCoordinateSystem", () => undo$1(g));
-  time("    translateGraph", () => translateGraph(g));
-  time("    assignNodeIntersects", () => assignNodeIntersects(g));
-  time("    reversePoints", () => reversePointsForReversedEdges(g));
-  time("    acyclic.undo", () => undo$2(g));
-}
-function updateInputGraph(inputGraph, layoutGraph) {
-  _.forEach(inputGraph.nodes(), function(v) {
-    var inputLabel = inputGraph.node(v);
-    var layoutLabel = layoutGraph.node(v);
-    if (inputLabel) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-      if (layoutGraph.children(v).length) {
-        inputLabel.width = layoutLabel.width;
-        inputLabel.height = layoutLabel.height;
-      }
-    }
-  });
-  _.forEach(inputGraph.edges(), function(e) {
-    var inputLabel = inputGraph.edge(e);
-    var layoutLabel = layoutGraph.edge(e);
-    inputLabel.points = layoutLabel.points;
-    if (Object.prototype.hasOwnProperty.call(layoutLabel, "x")) {
-      inputLabel.x = layoutLabel.x;
-      inputLabel.y = layoutLabel.y;
-    }
-  });
-  inputGraph.graph().width = layoutGraph.graph().width;
-  inputGraph.graph().height = layoutGraph.graph().height;
-}
-var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
-var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
-var graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
-var nodeNumAttrs = ["width", "height"];
-var nodeDefaults = { width: 0, height: 0 };
-var edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
-var edgeDefaults = {
-  minlen: 1,
-  weight: 1,
-  width: 0,
-  height: 0,
-  labeloffset: 10,
-  labelpos: "r"
-};
-var edgeAttrs = ["labelpos"];
-function buildLayoutGraph(inputGraph) {
-  var g = new Graph({ multigraph: true, compound: true });
-  var graph = canonicalize(inputGraph.graph());
-  g.setGraph(
-    _.merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), _.pick(graph, graphAttrs))
-  );
-  _.forEach(inputGraph.nodes(), function(v) {
-    var node = canonicalize(inputGraph.node(v));
-    g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
-    g.setParent(v, inputGraph.parent(v));
-  });
-  _.forEach(inputGraph.edges(), function(e) {
-    var edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(
-      e,
-      _.merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), _.pick(edge, edgeAttrs))
-    );
-  });
-  return g;
-}
-function makeSpaceForEdgeLabels(g) {
-  var graph = g.graph();
-  graph.ranksep /= 2;
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    edge.minlen *= 2;
-    if (edge.labelpos.toLowerCase() !== "c") {
-      if (graph.rankdir === "TB" || graph.rankdir === "BT") {
-        edge.width += edge.labeloffset;
-      } else {
-        edge.height += edge.labeloffset;
-      }
-    }
-  });
-}
-function injectEdgeLabelProxies(g) {
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (edge.width && edge.height) {
-      var v = g.node(e.v);
-      var w = g.node(e.w);
-      var label = { rank: (w.rank - v.rank) / 2 + v.rank, e };
-      addDummyNode(g, "edge-proxy", label, "_ep");
-    }
-  });
-}
-function assignRankMinMax(g) {
-  var maxRank = 0;
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    if (node.borderTop) {
-      node.minRank = g.node(node.borderTop).rank;
-      node.maxRank = g.node(node.borderBottom).rank;
-      maxRank = _.max(maxRank, node.maxRank);
-    }
-  });
-  g.graph().maxRank = maxRank;
-}
-function removeEdgeLabelProxies(g) {
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    if (node.dummy === "edge-proxy") {
-      g.edge(node.e).labelRank = node.rank;
-      g.removeNode(v);
-    }
-  });
-}
-function translateGraph(g) {
-  var minX = Number.POSITIVE_INFINITY;
-  var maxX = 0;
-  var minY = Number.POSITIVE_INFINITY;
-  var maxY = 0;
-  var graphLabel = g.graph();
-  var marginX = graphLabel.marginx || 0;
-  var marginY = graphLabel.marginy || 0;
-  function getExtremes(attrs) {
-    var x = attrs.x;
-    var y = attrs.y;
-    var w = attrs.width;
-    var h = attrs.height;
-    minX = Math.min(minX, x - w / 2);
-    maxX = Math.max(maxX, x + w / 2);
-    minY = Math.min(minY, y - h / 2);
-    maxY = Math.max(maxY, y + h / 2);
-  }
-  _.forEach(g.nodes(), function(v) {
-    getExtremes(g.node(v));
-  });
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
-      getExtremes(edge);
-    }
-  });
-  minX -= marginX;
-  minY -= marginY;
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    node.x -= minX;
-    node.y -= minY;
-  });
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    _.forEach(edge.points, function(p) {
-      p.x -= minX;
-      p.y -= minY;
-    });
-    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
-      edge.x -= minX;
-    }
-    if (Object.prototype.hasOwnProperty.call(edge, "y")) {
-      edge.y -= minY;
-    }
-  });
-  graphLabel.width = maxX - minX + marginX;
-  graphLabel.height = maxY - minY + marginY;
-}
-function assignNodeIntersects(g) {
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    var nodeV = g.node(e.v);
-    var nodeW = g.node(e.w);
-    var p1, p2;
-    if (!edge.points) {
-      edge.points = [];
-      p1 = nodeW;
-      p2 = nodeV;
-    } else {
-      p1 = edge.points[0];
-      p2 = edge.points[edge.points.length - 1];
-    }
-    edge.points.unshift(intersectRect(nodeV, p1));
-    edge.points.push(intersectRect(nodeW, p2));
-  });
-}
-function fixupEdgeLabelCoords(g) {
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (Object.prototype.hasOwnProperty.call(edge, "x")) {
-      if (edge.labelpos === "l" || edge.labelpos === "r") {
-        edge.width -= edge.labeloffset;
-      }
-      switch (edge.labelpos) {
-        case "l":
-          edge.x -= edge.width / 2 + edge.labeloffset;
-          break;
-        case "r":
-          edge.x += edge.width / 2 + edge.labeloffset;
-          break;
-      }
-    }
-  });
-}
-function reversePointsForReversedEdges(g) {
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (edge.reversed) {
-      edge.points.reverse();
-    }
-  });
-}
-function removeBorderNodes(g) {
-  _.forEach(g.nodes(), function(v) {
-    if (g.children(v).length) {
-      var node = g.node(v);
-      var t = g.node(node.borderTop);
-      var b = g.node(node.borderBottom);
-      var l = g.node(_.last(node.borderLeft));
-      var r = g.node(_.last(node.borderRight));
-      node.width = Math.abs(r.x - l.x);
-      node.height = Math.abs(b.y - t.y);
-      node.x = l.x + node.width / 2;
-      node.y = t.y + node.height / 2;
-    }
-  });
-  _.forEach(g.nodes(), function(v) {
-    if (g.node(v).dummy === "border") {
-      g.removeNode(v);
-    }
-  });
-}
-function removeSelfEdges(g) {
-  _.forEach(g.edges(), function(e) {
-    if (e.v === e.w) {
-      var node = g.node(e.v);
-      if (!node.selfEdges) {
-        node.selfEdges = [];
-      }
-      node.selfEdges.push({ e, label: g.edge(e) });
-      g.removeEdge(e);
-    }
-  });
-}
-function insertSelfEdges(g) {
-  var layers = buildLayerMatrix(g);
-  _.forEach(layers, function(layer) {
-    var orderShift = 0;
-    _.forEach(layer, function(v, i) {
-      var node = g.node(v);
-      node.order = i + orderShift;
-      _.forEach(node.selfEdges, function(selfEdge) {
-        addDummyNode(
-          g,
-          "selfedge",
-          {
-            width: selfEdge.label.width,
-            height: selfEdge.label.height,
-            rank: node.rank,
-            order: i + ++orderShift,
-            e: selfEdge.e,
-            label: selfEdge.label
-          },
-          "_se"
-        );
-      });
-      delete node.selfEdges;
-    });
-  });
-}
-function positionSelfEdges(g) {
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v);
-    if (node.dummy === "selfedge") {
-      var selfNode = g.node(node.e.v);
-      var x = selfNode.x + selfNode.width / 2;
-      var y = selfNode.y;
-      var dx = node.x - x;
-      var dy = selfNode.height / 2;
-      g.setEdge(node.e, node.label);
-      g.removeNode(v);
-      node.label.points = [
-        { x: x + 2 * dx / 3, y: y - dy },
-        { x: x + 5 * dx / 6, y: y - dy },
-        { x: x + dx, y },
-        { x: x + 5 * dx / 6, y: y + dy },
-        { x: x + 2 * dx / 3, y: y + dy }
-      ];
-      node.label.x = node.x;
-      node.label.y = node.y;
-    }
-  });
-}
-function selectNumberAttrs(obj, attrs) {
-  return _.mapValues(_.pick(obj, attrs), Number);
-}
-function canonicalize(attrs) {
-  var newAttrs = {};
-  _.forEach(attrs, function(v, k) {
-    newAttrs[k.toLowerCase()] = v;
-  });
-  return newAttrs;
-}
-export {
-  layout
-};

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

@@ -1,94 +0,0 @@
-import * as _ from "lodash-es";
-import { addDummyNode, addBorderNode } from "./util.mjs";
-function run(g) {
-  var root = addDummyNode(g, "root", {}, "_root");
-  var depths = treeDepths(g);
-  var height = _.max(_.values(depths)) - 1;
-  var nodeSep = 2 * height + 1;
-  g.graph().nestingRoot = root;
-  _.forEach(g.edges(), function(e) {
-    g.edge(e).minlen *= nodeSep;
-  });
-  var weight = sumWeights(g) + 1;
-  _.forEach(g.children(), function(child) {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-  });
-  g.graph().nodeRankFactor = nodeSep;
-}
-function dfs(g, root, nodeSep, weight, height, depths, v) {
-  var children = g.children(v);
-  if (!children.length) {
-    if (v !== root) {
-      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
-    }
-    return;
-  }
-  var top = addBorderNode(g, "_bt");
-  var bottom = addBorderNode(g, "_bb");
-  var label = g.node(v);
-  g.setParent(top, v);
-  label.borderTop = top;
-  g.setParent(bottom, v);
-  label.borderBottom = bottom;
-  _.forEach(children, function(child) {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-    var childNode = g.node(child);
-    var childTop = childNode.borderTop ? childNode.borderTop : child;
-    var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
-    var thisWeight = childNode.borderTop ? weight : 2 * weight;
-    var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
-    g.setEdge(top, childTop, {
-      weight: thisWeight,
-      minlen,
-      nestingEdge: true
-    });
-    g.setEdge(childBottom, bottom, {
-      weight: thisWeight,
-      minlen,
-      nestingEdge: true
-    });
-  });
-  if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
-  }
-}
-function treeDepths(g) {
-  var depths = {};
-  function dfs2(v, depth) {
-    var children = g.children(v);
-    if (children && children.length) {
-      _.forEach(children, function(child) {
-        dfs2(child, depth + 1);
-      });
-    }
-    depths[v] = depth;
-  }
-  _.forEach(g.children(), function(v) {
-    dfs2(v, 1);
-  });
-  return depths;
-}
-function sumWeights(g) {
-  return _.reduce(
-    g.edges(),
-    function(acc, e) {
-      return acc + g.edge(e).weight;
-    },
-    0
-  );
-}
-function cleanup(g) {
-  var graphLabel = g.graph();
-  g.removeNode(graphLabel.nestingRoot);
-  delete graphLabel.nestingRoot;
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (edge.nestingEdge) {
-      g.removeEdge(e);
-    }
-  });
-}
-export {
-  cleanup,
-  run
-};