feature: vor und nachteile

praesentation/node_modules/dagre-d3-es/src/dagre-js/arrows.d.ts

@@ -0,0 +1,10 @@
+export namespace arrows {
+    export { normal };
+    export { vee };
+    export { undirected };
+}
+export function setArrows(value: any): void;
+declare function normal(parent: any, id: any, edge: any, type: any): void;
+declare function vee(parent: any, id: any, edge: any, type: any): void;
+declare function undirected(parent: any, id: any, edge: any, type: any): void;
+export {};

praesentation/node_modules/dagre-d3-es/src/dagre-js/arrows.js

@@ -0,0 +1,82 @@
+import * as util from './util.js';
+
+export { arrows, setArrows };
+
+var arrows = {
+  normal,
+  vee,
+  undirected,
+};
+
+function setArrows(value) {
+  arrows = value;
+}
+
+function normal(parent, id, edge, type) {
+  var marker = parent
+    .append('marker')
+    .attr('id', id)
+    .attr('viewBox', '0 0 10 10')
+    .attr('refX', 9)
+    .attr('refY', 5)
+    .attr('markerUnits', 'strokeWidth')
+    .attr('markerWidth', 8)
+    .attr('markerHeight', 6)
+    .attr('orient', 'auto');
+
+  var path = marker
+    .append('path')
+    .attr('d', 'M 0 0 L 10 5 L 0 10 z')
+    .style('stroke-width', 1)
+    .style('stroke-dasharray', '1,0');
+  util.applyStyle(path, edge[type + 'Style']);
+  if (edge[type + 'Class']) {
+    path.attr('class', edge[type + 'Class']);
+  }
+}
+
+function vee(parent, id, edge, type) {
+  var marker = parent
+    .append('marker')
+    .attr('id', id)
+    .attr('viewBox', '0 0 10 10')
+    .attr('refX', 9)
+    .attr('refY', 5)
+    .attr('markerUnits', 'strokeWidth')
+    .attr('markerWidth', 8)
+    .attr('markerHeight', 6)
+    .attr('orient', 'auto');
+
+  var path = marker
+    .append('path')
+    .attr('d', 'M 0 0 L 10 5 L 0 10 L 4 5 z')
+    .style('stroke-width', 1)
+    .style('stroke-dasharray', '1,0');
+  util.applyStyle(path, edge[type + 'Style']);
+  if (edge[type + 'Class']) {
+    path.attr('class', edge[type + 'Class']);
+  }
+}
+
+function undirected(parent, id, edge, type) {
+  var marker = parent
+    .append('marker')
+    .attr('id', id)
+    .attr('viewBox', '0 0 10 10')
+    .attr('refX', 9)
+    .attr('refY', 5)
+    .attr('markerUnits', 'strokeWidth')
+    .attr('markerWidth', 8)
+    .attr('markerHeight', 6)
+    .attr('orient', 'auto');
+
+  var path = marker
+    .append('path')
+    .attr('d', 'M 0 5 L 10 5')
+    .style('stroke-width', 1)
+    .style('stroke-dasharray', '1,0');
+  util.applyStyle(path, edge[type + 'Style']);
+  if (edge[type + 'Class']) {
+    path.attr('class', edge[type + 'Class']);
+  }
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-clusters.d.ts

@@ -0,0 +1,2 @@
+export function createClusters(selection: any, g: any): any;
+export function setCreateClusters(value: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-clusters.js

@@ -0,0 +1,49 @@
+import * as d3 from 'd3';
+import { addLabel } from './label/add-label.js';
+import * as util from './util.js';
+
+export { createClusters, setCreateClusters };
+
+var createClusters = function (selection, g) {
+  var clusters = g.nodes().filter(function (v) {
+    return util.isSubgraph(g, v);
+  });
+  var svgClusters = selection.selectAll('g.cluster').data(clusters, function (v) {
+    return v;
+  });
+
+  util.applyTransition(svgClusters.exit(), g).style('opacity', 0).remove();
+
+  var enterSelection = svgClusters
+    .enter()
+    .append('g')
+    .attr('class', 'cluster')
+    .attr('id', function (v) {
+      var node = g.node(v);
+      return node.id;
+    })
+    .style('opacity', 0)
+    .each(function (v) {
+      var node = g.node(v);
+      var thisGroup = d3.select(this);
+      d3.select(this).append('rect');
+      var labelGroup = thisGroup.append('g').attr('class', 'label');
+      addLabel(labelGroup, node, node.clusterLabelPos);
+    });
+
+  svgClusters = svgClusters.merge(enterSelection);
+
+  svgClusters = util.applyTransition(svgClusters, g).style('opacity', 1);
+
+  svgClusters.selectAll('rect').each(function (c) {
+    var node = g.node(c);
+    var domCluster = d3.select(this);
+    util.applyStyle(domCluster, node.style);
+  });
+
+  return svgClusters;
+};
+
+function setCreateClusters(value) {
+  createClusters = value;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-edge-labels.d.ts

@@ -0,0 +1,2 @@
+export function createEdgeLabels(selection: any, g: any): any;
+export function setCreateEdgeLabels(value: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-edge-labels.js

@@ -0,0 +1,53 @@
+import * as d3 from 'd3';
+import { addLabel } from './label/add-label.js';
+import * as util from './util.js';
+
+export { createEdgeLabels, setCreateEdgeLabels };
+
+let createEdgeLabels = function (selection, g) {
+  var svgEdgeLabels = selection
+    .selectAll('g.edgeLabel')
+    .data(g.edges(), function (e) {
+      return util.edgeToId(e);
+    })
+    .classed('update', true);
+
+  svgEdgeLabels.exit().remove();
+  svgEdgeLabels.enter().append('g').classed('edgeLabel', true).style('opacity', 0);
+
+  svgEdgeLabels = selection.selectAll('g.edgeLabel');
+
+  svgEdgeLabels.each(function (e) {
+    var root = d3.select(this);
+    root.select('.label').remove();
+    var edge = g.edge(e);
+    var label = addLabel(root, g.edge(e), 0).classed('label', true);
+    var bbox = label.node().getBBox();
+
+    if (edge.labelId) {
+      label.attr('id', edge.labelId);
+    }
+    if (!Object.prototype.hasOwnProperty.call(edge, 'width')) {
+      edge.width = bbox.width;
+    }
+    if (!Object.prototype.hasOwnProperty.call(edge, 'height')) {
+      edge.height = bbox.height;
+    }
+  });
+
+  var exitSelection;
+
+  if (svgEdgeLabels.exit) {
+    exitSelection = svgEdgeLabels.exit();
+  } else {
+    exitSelection = svgEdgeLabels.selectAll(null); // empty selection
+  }
+
+  util.applyTransition(exitSelection, g).style('opacity', 0).remove();
+
+  return svgEdgeLabels;
+};
+
+function setCreateEdgeLabels(value) {
+  createEdgeLabels = value;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-edge-paths.d.ts

@@ -0,0 +1,2 @@
+export function createEdgePaths(selection: any, g: any, arrows: any): any;
+export function setCreateEdgePaths(value: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-edge-paths.js

@@ -0,0 +1,132 @@
+import * as d3 from 'd3';
+import * as _ from 'lodash-es';
+import { intersectNode } from './intersect/intersect-node.js';
+import * as util from './util.js';
+
+export { createEdgePaths, setCreateEdgePaths };
+
+var createEdgePaths = function (selection, g, arrows) {
+  var previousPaths = selection
+    .selectAll('g.edgePath')
+    .data(g.edges(), function (e) {
+      return util.edgeToId(e);
+    })
+    .classed('update', true);
+
+  var newPaths = enter(previousPaths, g);
+  exit(previousPaths, g);
+
+  var svgPaths = previousPaths.merge !== undefined ? previousPaths.merge(newPaths) : previousPaths;
+  util.applyTransition(svgPaths, g).style('opacity', 1);
+
+  // Save DOM element in the path group, and set ID and class
+  svgPaths.each(function (e) {
+    var domEdge = d3.select(this);
+    var edge = g.edge(e);
+    edge.elem = this;
+
+    if (edge.id) {
+      domEdge.attr('id', edge.id);
+    }
+
+    util.applyClass(
+      domEdge,
+      edge['class'],
+      (domEdge.classed('update') ? 'update ' : '') + 'edgePath',
+    );
+  });
+
+  svgPaths.selectAll('path.path').each(function (e) {
+    var edge = g.edge(e);
+    edge.arrowheadId = _.uniqueId('arrowhead');
+
+    var domEdge = d3
+      .select(this)
+      .attr('marker-end', function () {
+        return 'url(' + makeFragmentRef(location.href, edge.arrowheadId) + ')';
+      })
+      .style('fill', 'none');
+
+    util.applyTransition(domEdge, g).attr('d', function (e) {
+      return calcPoints(g, e);
+    });
+
+    util.applyStyle(domEdge, edge.style);
+  });
+
+  svgPaths.selectAll('defs *').remove();
+  svgPaths.selectAll('defs').each(function (e) {
+    var edge = g.edge(e);
+    var arrowhead = arrows[edge.arrowhead];
+    arrowhead(d3.select(this), edge.arrowheadId, edge, 'arrowhead');
+  });
+
+  return svgPaths;
+};
+
+function setCreateEdgePaths(value) {
+  createEdgePaths = value;
+}
+
+function makeFragmentRef(url, fragmentId) {
+  var baseUrl = url.split('#')[0];
+  return baseUrl + '#' + fragmentId;
+}
+
+function calcPoints(g, e) {
+  var edge = g.edge(e);
+  var tail = g.node(e.v);
+  var head = g.node(e.w);
+  var points = edge.points.slice(1, edge.points.length - 1);
+  points.unshift(intersectNode(tail, points[0]));
+  points.push(intersectNode(head, points[points.length - 1]));
+
+  return createLine(edge, points);
+}
+
+function createLine(edge, points) {
+  // @ts-expect-error
+  var line = (d3.line || d3.svg.line)()
+    .x(function (d) {
+      return d.x;
+    })
+    .y(function (d) {
+      return d.y;
+    });
+
+  (line.curve || line.interpolate)(edge.curve);
+
+  return line(points);
+}
+
+function getCoords(elem) {
+  var bbox = elem.getBBox();
+  var matrix = elem.ownerSVGElement
+    .getScreenCTM()
+    .inverse()
+    .multiply(elem.getScreenCTM())
+    .translate(bbox.width / 2, bbox.height / 2);
+  return { x: matrix.e, y: matrix.f };
+}
+
+function enter(svgPaths, g) {
+  var svgPathsEnter = svgPaths.enter().append('g').attr('class', 'edgePath').style('opacity', 0);
+  svgPathsEnter
+    .append('path')
+    .attr('class', 'path')
+    .attr('d', function (e) {
+      var edge = g.edge(e);
+      var sourceElem = g.node(e.v).elem;
+      var points = _.range(edge.points.length).map(function () {
+        return getCoords(sourceElem);
+      });
+      return createLine(edge, points);
+    });
+  svgPathsEnter.append('defs');
+  return svgPathsEnter;
+}
+
+function exit(svgPaths, g) {
+  var svgPathExit = svgPaths.exit();
+  util.applyTransition(svgPathExit, g).style('opacity', 0).remove();
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-nodes.d.ts

@@ -0,0 +1,2 @@
+export function createNodes(selection: any, g: any, shapes: any): any;
+export function setCreateNodes(value: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/create-nodes.js

@@ -0,0 +1,92 @@
+import * as d3 from 'd3';
+import { pick } from 'lodash-es';
+import { addLabel } from './label/add-label.js';
+import * as util from './util.js';
+
+export { createNodes, setCreateNodes };
+
+var createNodes = function (selection, g, shapes) {
+  var simpleNodes = g.nodes().filter(function (v) {
+    return !util.isSubgraph(g, v);
+  });
+  var svgNodes = selection
+    .selectAll('g.node')
+    .data(simpleNodes, function (v) {
+      return v;
+    })
+    .classed('update', true);
+
+  svgNodes.exit().remove();
+
+  svgNodes.enter().append('g').attr('class', 'node').style('opacity', 0);
+
+  svgNodes = selection.selectAll('g.node');
+
+  svgNodes.each(function (v) {
+    var node = g.node(v);
+    var thisGroup = d3.select(this);
+    util.applyClass(
+      thisGroup,
+      node['class'],
+      (thisGroup.classed('update') ? 'update ' : '') + 'node',
+    );
+
+    thisGroup.select('g.label').remove();
+    var labelGroup = thisGroup.append('g').attr('class', 'label');
+    var labelDom = addLabel(labelGroup, node);
+    var shape = shapes[node.shape];
+    var bbox = pick(labelDom.node().getBBox(), 'width', 'height');
+
+    node.elem = this;
+
+    if (node.id) {
+      thisGroup.attr('id', node.id);
+    }
+    if (node.labelId) {
+      labelGroup.attr('id', node.labelId);
+    }
+
+    if (Object.prototype.hasOwnProperty.call(node, 'width')) {
+      bbox.width = node.width;
+    }
+    if (Object.prototype.hasOwnProperty.call(node, 'height')) {
+      bbox.height = node.height;
+    }
+
+    bbox.width += node.paddingLeft + node.paddingRight;
+    bbox.height += node.paddingTop + node.paddingBottom;
+    labelGroup.attr(
+      'transform',
+      'translate(' +
+        (node.paddingLeft - node.paddingRight) / 2 +
+        ',' +
+        (node.paddingTop - node.paddingBottom) / 2 +
+        ')',
+    );
+
+    var root = d3.select(this);
+    root.select('.label-container').remove();
+    var shapeSvg = shape(root, bbox, node).classed('label-container', true);
+    util.applyStyle(shapeSvg, node.style);
+
+    var shapeBBox = shapeSvg.node().getBBox();
+    node.width = shapeBBox.width;
+    node.height = shapeBBox.height;
+  });
+
+  var exitSelection;
+
+  if (svgNodes.exit) {
+    exitSelection = svgNodes.exit();
+  } else {
+    exitSelection = svgNodes.selectAll(null); // empty selection
+  }
+
+  util.applyTransition(exitSelection, g).style('opacity', 0).remove();
+
+  return svgNodes;
+};
+
+function setCreateNodes(value) {
+  createNodes = value;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/index.d.ts

@@ -0,0 +1,6 @@
+import * as node from './intersect-node.js';
+import * as circle from './intersect-circle.js';
+import * as ellipse from './intersect-ellipse.js';
+import * as polygon from './intersect-polygon.js';
+import * as rect from './intersect-rect.js';
+export { node, circle, ellipse, polygon, rect };

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/index.js

@@ -0,0 +1,7 @@
+import * as node from './intersect-node.js';
+import * as circle from './intersect-circle.js';
+import * as ellipse from './intersect-ellipse.js';
+import * as polygon from './intersect-polygon.js';
+import * as rect from './intersect-rect.js';
+
+export { node, circle, ellipse, polygon, rect };

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-circle.d.ts

@@ -0,0 +1,4 @@
+export function intersectCircle(node: any, rx: any, point: any): {
+    x: any;
+    y: any;
+};

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-circle.js

@@ -0,0 +1,7 @@
+import { intersectEllipse } from './intersect-ellipse.js';
+
+export { intersectCircle };
+
+function intersectCircle(node, rx, point) {
+  return intersectEllipse(node, rx, rx, point);
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-ellipse.d.ts

@@ -0,0 +1,4 @@
+export function intersectEllipse(node: any, rx: any, ry: any, point: any): {
+    x: any;
+    y: any;
+};

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-ellipse.js

@@ -0,0 +1,24 @@
+export { intersectEllipse };
+
+function intersectEllipse(node, rx, ry, point) {
+  // Formulae from: http://mathworld.wolfram.com/Ellipse-LineIntersection.html
+
+  var cx = node.x;
+  var cy = node.y;
+
+  var px = cx - point.x;
+  var py = cy - point.y;
+
+  var det = Math.sqrt(rx * rx * py * py + ry * ry * px * px);
+
+  var dx = Math.abs((rx * ry * px) / det);
+  if (point.x < cx) {
+    dx = -dx;
+  }
+  var dy = Math.abs((rx * ry * py) / det);
+  if (point.y < cy) {
+    dy = -dy;
+  }
+
+  return { x: cx + dx, y: cy + dy };
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-line.d.ts

@@ -0,0 +1,4 @@
+export function intersectLine(p1: any, p2: any, q1: any, q2: any): {
+    x: number;
+    y: number;
+};

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-line.js

@@ -0,0 +1,70 @@
+export { intersectLine };
+
+/*
+ * Returns the point at which two lines, p and q, intersect or returns
+ * undefined if they do not intersect.
+ */
+function intersectLine(p1, p2, q1, q2) {
+  // Algorithm from J. Avro, (ed.) Graphics Gems, No 2, Morgan Kaufmann, 1994,
+  // p7 and p473.
+
+  var a1, a2, b1, b2, c1, c2;
+  var r1, r2, r3, r4;
+  var denom, offset, num;
+  var x, y;
+
+  // Compute a1, b1, c1, where line joining points 1 and 2 is F(x,y) = a1 x +
+  // b1 y + c1 = 0.
+  a1 = p2.y - p1.y;
+  b1 = p1.x - p2.x;
+  c1 = p2.x * p1.y - p1.x * p2.y;
+
+  // Compute r3 and r4.
+  r3 = a1 * q1.x + b1 * q1.y + c1;
+  r4 = a1 * q2.x + b1 * q2.y + c1;
+
+  // Check signs of r3 and r4. If both point 3 and point 4 lie on
+  // same side of line 1, the line segments do not intersect.
+  if (r3 !== 0 && r4 !== 0 && sameSign(r3, r4)) {
+    return /*DONT_INTERSECT*/;
+  }
+
+  // Compute a2, b2, c2 where line joining points 3 and 4 is G(x,y) = a2 x + b2 y + c2 = 0
+  a2 = q2.y - q1.y;
+  b2 = q1.x - q2.x;
+  c2 = q2.x * q1.y - q1.x * q2.y;
+
+  // Compute r1 and r2
+  r1 = a2 * p1.x + b2 * p1.y + c2;
+  r2 = a2 * p2.x + b2 * p2.y + c2;
+
+  // Check signs of r1 and r2. If both point 1 and point 2 lie
+  // on same side of second line segment, the line segments do
+  // not intersect.
+  if (r1 !== 0 && r2 !== 0 && sameSign(r1, r2)) {
+    return /*DONT_INTERSECT*/;
+  }
+
+  // Line segments intersect: compute intersection point.
+  denom = a1 * b2 - a2 * b1;
+  if (denom === 0) {
+    return /*COLLINEAR*/;
+  }
+
+  offset = Math.abs(denom / 2);
+
+  // The denom/2 is to get rounding instead of truncating. It
+  // is added or subtracted to the numerator, depending upon the
+  // sign of the numerator.
+  num = b1 * c2 - b2 * c1;
+  x = num < 0 ? (num - offset) / denom : (num + offset) / denom;
+
+  num = a2 * c1 - a1 * c2;
+  y = num < 0 ? (num - offset) / denom : (num + offset) / denom;
+
+  return { x: x, y: y };
+}
+
+function sameSign(r1, r2) {
+  return r1 * r2 > 0;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-node.d.ts

@@ -0,0 +1 @@
+export function intersectNode(node: any, point: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-node.js

@@ -0,0 +1,5 @@
+export { intersectNode };
+
+function intersectNode(node, point) {
+  return node.intersect(point);
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-polygon.d.ts

@@ -0,0 +1 @@
+export function intersectPolygon(node: any, polyPoints: any, point: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-polygon.js

@@ -0,0 +1,59 @@
+import { intersectLine } from './intersect-line.js';
+
+export { intersectPolygon };
+
+/*
+ * Returns the point ({x, y}) at which the point argument intersects with the
+ * node argument assuming that it has the shape specified by polygon.
+ */
+function intersectPolygon(node, polyPoints, point) {
+  var x1 = node.x;
+  var y1 = node.y;
+
+  var intersections = [];
+
+  var minX = Number.POSITIVE_INFINITY;
+  var minY = Number.POSITIVE_INFINITY;
+  polyPoints.forEach(function (entry) {
+    minX = Math.min(minX, entry.x);
+    minY = Math.min(minY, entry.y);
+  });
+
+  var left = x1 - node.width / 2 - minX;
+  var top = y1 - node.height / 2 - minY;
+
+  for (var i = 0; i < polyPoints.length; i++) {
+    var p1 = polyPoints[i];
+    var p2 = polyPoints[i < polyPoints.length - 1 ? i + 1 : 0];
+    var intersect = intersectLine(
+      node,
+      point,
+      { x: left + p1.x, y: top + p1.y },
+      { x: left + p2.x, y: top + p2.y },
+    );
+    if (intersect) {
+      intersections.push(intersect);
+    }
+  }
+
+  if (!intersections.length) {
+    console.log('NO INTERSECTION FOUND, RETURN NODE CENTER', node);
+    return node;
+  }
+
+  if (intersections.length > 1) {
+    // More intersections, find the one nearest to edge end point
+    intersections.sort(function (p, q) {
+      var pdx = p.x - point.x;
+      var pdy = p.y - point.y;
+      var distp = Math.sqrt(pdx * pdx + pdy * pdy);
+
+      var qdx = q.x - point.x;
+      var qdy = q.y - point.y;
+      var distq = Math.sqrt(qdx * qdx + qdy * qdy);
+
+      return distp < distq ? -1 : distp === distq ? 0 : 1;
+    });
+  }
+  return intersections[0];
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-rect.d.ts

@@ -0,0 +1,4 @@
+export function intersectRect(node: any, point: any): {
+    x: any;
+    y: any;
+};

praesentation/node_modules/dagre-d3-es/src/dagre-js/intersect/intersect-rect.js

@@ -0,0 +1,32 @@
+export { intersectRect };
+
+function intersectRect(node, point) {
+  var x = node.x;
+  var y = node.y;
+
+  // Rectangle intersection algorithm from:
+  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+  var dx = point.x - x;
+  var dy = point.y - y;
+  var w = node.width / 2;
+  var h = node.height / 2;
+
+  var sx, sy;
+  if (Math.abs(dy) * w > Math.abs(dx) * h) {
+    // Intersection is top or bottom of rect.
+    if (dy < 0) {
+      h = -h;
+    }
+    sx = dy === 0 ? 0 : (h * dx) / dy;
+    sy = h;
+  } else {
+    // Intersection is left or right of rect.
+    if (dx < 0) {
+      w = -w;
+    }
+    sx = w;
+    sy = dx === 0 ? 0 : (w * dy) / dx;
+  }
+
+  return { x: x + sx, y: y + sy };
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-html-label.d.ts

@@ -0,0 +1 @@
+export function addHtmlLabel(root: any, node: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-html-label.js

@@ -0,0 +1,35 @@
+import * as util from '../util.js';
+
+export { addHtmlLabel };
+
+function addHtmlLabel(root, node) {
+  var fo = root.append('foreignObject').attr('width', '100000');
+
+  var div = fo.append('xhtml:div');
+  div.attr('xmlns', 'http://www.w3.org/1999/xhtml');
+
+  var label = node.label;
+  switch (typeof label) {
+    case 'function':
+      div.insert(label);
+      break;
+    case 'object':
+      // Currently we assume this is a DOM object.
+      div.insert(function () {
+        return label;
+      });
+      break;
+    default:
+      div.html(label);
+  }
+
+  util.applyStyle(div, node.labelStyle);
+  div.style('display', 'inline-block');
+  // Fix for firefox
+  div.style('white-space', 'nowrap');
+
+  var client = div.node();
+  fo.attr('width', client.offsetWidth).attr('height', client.offsetHeight);
+
+  return fo;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-label.d.ts

@@ -0,0 +1 @@
+export function addLabel(root: any, node: any, location: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-label.js

@@ -0,0 +1,36 @@
+import { addHtmlLabel } from './add-html-label.js';
+import { addSVGLabel } from './add-svg-label.js';
+import { addTextLabel } from './add-text-label.js';
+
+export { addLabel };
+
+function addLabel(root, node, location) {
+  var label = node.label;
+  var labelSvg = root.append('g');
+
+  // Allow the label to be a string, a function that returns a DOM element, or
+  // a DOM element itself.
+  if (node.labelType === 'svg') {
+    addSVGLabel(labelSvg, node);
+  } else if (typeof label !== 'string' || node.labelType === 'html') {
+    addHtmlLabel(labelSvg, node);
+  } else {
+    addTextLabel(labelSvg, node);
+  }
+
+  var labelBBox = labelSvg.node().getBBox();
+  var y;
+  switch (location) {
+    case 'top':
+      y = -node.height / 2;
+      break;
+    case 'bottom':
+      y = node.height / 2 - labelBBox.height;
+      break;
+    default:
+      y = -labelBBox.height / 2;
+  }
+  labelSvg.attr('transform', 'translate(' + -labelBBox.width / 2 + ',' + y + ')');
+
+  return labelSvg;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-svg-label.d.ts

@@ -0,0 +1 @@
+export function addSVGLabel(root: any, node: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-svg-label.js

@@ -0,0 +1,13 @@
+import * as util from '../util.js';
+
+export { addSVGLabel };
+
+function addSVGLabel(root, node) {
+  var domNode = root;
+
+  domNode.node().appendChild(node.label);
+
+  util.applyStyle(domNode, node.labelStyle);
+
+  return domNode;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-text-label.d.ts

@@ -0,0 +1 @@
+export function addTextLabel(root: any, node: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/label/add-text-label.js

@@ -0,0 +1,48 @@
+import * as util from '../util.js';
+
+export { addTextLabel };
+
+/*
+ * Attaches a text label to the specified root. Handles escape sequences.
+ */
+function addTextLabel(root, node) {
+  var domNode = root.append('text');
+
+  var lines = processEscapeSequences(node.label).split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    domNode
+      .append('tspan')
+      .attr('xml:space', 'preserve')
+      .attr('dy', '1em')
+      .attr('x', '1')
+      .text(lines[i]);
+  }
+
+  util.applyStyle(domNode, node.labelStyle);
+
+  return domNode;
+}
+
+function processEscapeSequences(text) {
+  var newText = '';
+  var escaped = false;
+  var ch;
+  for (var i = 0; i < text.length; ++i) {
+    ch = text[i];
+    if (escaped) {
+      switch (ch) {
+        case 'n':
+          newText += '\n';
+          break;
+        default:
+          newText += ch;
+      }
+      escaped = false;
+    } else if (ch === '\\') {
+      escaped = true;
+    } else {
+      newText += ch;
+    }
+  }
+  return newText;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-clusters.d.ts

@@ -0,0 +1 @@
+export function positionClusters(selection: any, g: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-clusters.js

@@ -0,0 +1,36 @@
+import * as d3 from 'd3';
+import * as util from './util.js';
+
+export { positionClusters };
+
+function positionClusters(selection, g) {
+  var created = selection.filter(function () {
+    return !d3.select(this).classed('update');
+  });
+
+  function translate(v) {
+    var node = g.node(v);
+    return 'translate(' + node.x + ',' + node.y + ')';
+  }
+
+  created.attr('transform', translate);
+
+  util.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);
+
+  util
+    .applyTransition(created.selectAll('rect'), g)
+    .attr('width', function (v) {
+      return g.node(v).width;
+    })
+    .attr('height', function (v) {
+      return g.node(v).height;
+    })
+    .attr('x', function (v) {
+      var node = g.node(v);
+      return -node.width / 2;
+    })
+    .attr('y', function (v) {
+      var node = g.node(v);
+      return -node.height / 2;
+    });
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-edge-labels.d.ts

@@ -0,0 +1 @@
+export function positionEdgeLabels(selection: any, g: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-edge-labels.js

@@ -0,0 +1,21 @@
+import * as d3 from 'd3';
+import * as util from './util.js';
+
+export { positionEdgeLabels };
+
+function positionEdgeLabels(selection, g) {
+  var created = selection.filter(function () {
+    return !d3.select(this).classed('update');
+  });
+
+  function translate(e) {
+    var edge = g.edge(e);
+    return Object.prototype.hasOwnProperty.call(edge, 'x')
+      ? 'translate(' + edge.x + ',' + edge.y + ')'
+      : '';
+  }
+
+  created.attr('transform', translate);
+
+  util.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-nodes.d.ts

@@ -0,0 +1 @@
+export function positionNodes(selection: any, g: any): void;

praesentation/node_modules/dagre-d3-es/src/dagre-js/position-nodes.js

@@ -0,0 +1,19 @@
+import * as d3 from 'd3';
+import * as util from './util.js';
+
+export { positionNodes };
+
+function positionNodes(selection, g) {
+  var created = selection.filter(function () {
+    return !d3.select(this).classed('update');
+  });
+
+  function translate(v) {
+    var node = g.node(v);
+    return 'translate(' + node.x + ',' + node.y + ')';
+  }
+
+  created.attr('transform', translate);
+
+  util.applyTransition(selection, g).style('opacity', 1).attr('transform', translate);
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/render.d.ts

@@ -0,0 +1,48 @@
+export type Node = {
+    /**
+     * - The label of the node.
+     */
+    label: string;
+    /**
+     * - The horizontal padding of the node.
+     */
+    paddingX?: number;
+    /**
+     * - The vertical padding of the node.
+     */
+    paddingY?: number;
+    /**
+     * - The padding of the node for all directions. Overrides `paddingX` and `paddingY`.
+     */
+    padding?: number;
+    /**
+     * - The left padding of the node.
+     */
+    paddingLeft?: number;
+    /**
+     * - The right padding of the node.
+     */
+    paddingRight?: number;
+    _prevWidth?: number;
+    width?: number;
+    _prevHeight?: number;
+    height?: number;
+};
+export function render(): {
+    (svg: any, g: any): void;
+    createNodes(value: any, ...args: any[]): (selection: any, g: any, shapes: any) => any;
+    createClusters(value: any, ...args: any[]): (selection: any, g: any) => any;
+    createEdgeLabels(value: any, ...args: any[]): (selection: any, g: any) => any;
+    createEdgePaths(value: any, ...args: any[]): (selection: any, g: any, arrows: any) => any;
+    shapes(value: any, ...args: any[]): {
+        rect: (parent: any, bbox: any, node: any) => any;
+        ellipse: (parent: any, bbox: any, node: any) => any;
+        circle: (parent: any, bbox: any, node: any) => any;
+        diamond: (parent: any, bbox: any, node: any) => any;
+    } | /*elided*/ any;
+    arrows(value: any, ...args: any[]): {
+        normal: (parent: any, id: any, edge: any, type: any) => void;
+        vee: (parent: any, id: any, edge: any, type: any) => void;
+        undirected: (parent: any, id: any, edge: any, type: any) => void;
+    } | /*elided*/ any;
+};

praesentation/node_modules/dagre-d3-es/src/dagre-js/render.js

@@ -0,0 +1,195 @@
+import * as d3 from 'd3';
+import { defaults } from 'lodash-es';
+import { layout } from '../dagre/index.js';
+import { arrows, setArrows } from './arrows.js';
+import { createClusters, setCreateClusters } from './create-clusters.js';
+import { createEdgeLabels, setCreateEdgeLabels } from './create-edge-labels.js';
+import { createEdgePaths, setCreateEdgePaths } from './create-edge-paths.js';
+import { createNodes, setCreateNodes } from './create-nodes.js';
+import { positionClusters } from './position-clusters.js';
+import { positionEdgeLabels } from './position-edge-labels.js';
+import { positionNodes } from './position-nodes.js';
+import { shapes, setShapes } from './shapes.js';
+
+export { render };
+
+// This design is based on http://bost.ocks.org/mike/chart/.
+function render() {
+  var fn = function (svg, g) {
+    preProcessGraph(g);
+
+    var outputGroup = createOrSelectGroup(svg, 'output');
+    var clustersGroup = createOrSelectGroup(outputGroup, 'clusters');
+    var edgePathsGroup = createOrSelectGroup(outputGroup, 'edgePaths');
+    var edgeLabels = createEdgeLabels(createOrSelectGroup(outputGroup, 'edgeLabels'), g);
+    var nodes = createNodes(createOrSelectGroup(outputGroup, 'nodes'), g, shapes);
+
+    layout(g);
+
+    positionNodes(nodes, g);
+    positionEdgeLabels(edgeLabels, g);
+    createEdgePaths(edgePathsGroup, g, arrows);
+
+    var clusters = createClusters(clustersGroup, g);
+    positionClusters(clusters, g);
+
+    postProcessGraph(g);
+  };
+
+  fn.createNodes = function (value) {
+    if (!arguments.length) return createNodes;
+    setCreateNodes(value);
+    return fn;
+  };
+
+  fn.createClusters = function (value) {
+    if (!arguments.length) return createClusters;
+    setCreateClusters(value);
+    return fn;
+  };
+
+  fn.createEdgeLabels = function (value) {
+    if (!arguments.length) return createEdgeLabels;
+    setCreateEdgeLabels(value);
+    return fn;
+  };
+
+  fn.createEdgePaths = function (value) {
+    if (!arguments.length) return createEdgePaths;
+    setCreateEdgePaths(value);
+    return fn;
+  };
+
+  fn.shapes = function (value) {
+    if (!arguments.length) return shapes;
+    setShapes(value);
+    return fn;
+  };
+
+  fn.arrows = function (value) {
+    if (!arguments.length) return arrows;
+    setArrows(value);
+    return fn;
+  };
+
+  return fn;
+}
+
+var NODE_DEFAULT_ATTRS = {
+  paddingLeft: 10,
+  paddingRight: 10,
+  paddingTop: 10,
+  paddingBottom: 10,
+  rx: 0,
+  ry: 0,
+  shape: 'rect',
+};
+
+var EDGE_DEFAULT_ATTRS = {
+  arrowhead: 'normal',
+  curve: d3.curveLinear,
+};
+
+/**
+ * @typedef {Object} Node
+ * @property {string} label - The label of the node.
+ * @property {number} [paddingX] - The horizontal padding of the node.
+ * @property {number} [paddingY] - The vertical padding of the node.
+ * @property {number} [padding] - The padding of the node for all directions. Overrides `paddingX` and `paddingY`.
+ * @property {number} [paddingLeft] - The left padding of the node.
+ * @property {number} [paddingRight] - The right padding of the node.
+ * @property {number} [_prevWidth]
+ * @property {number} [width]
+ * @property {number} [_prevHeight]
+ * @property {number} [height]
+ */
+
+/**
+ * Pre-processes the graph by setting default labels and padding for nodes.
+ * @param {Object} g - The graph object.
+ */
+function preProcessGraph(g) {
+  g.nodes().forEach((v) => {
+    /** @type {Node} */
+    const node = g.node(v);
+    if (!Object.prototype.hasOwnProperty.call(node, 'label') && !g.children(v).length) {
+      node.label = v;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(node, 'paddingX')) {
+      defaults(node, {
+        paddingLeft: node.paddingX,
+        paddingRight: node.paddingX,
+      });
+    }
+
+    if (Object.prototype.hasOwnProperty.call(node, 'paddingY')) {
+      defaults(node, {
+        paddingTop: node.paddingY,
+        paddingBottom: node.paddingY,
+      });
+    }
+
+    if (Object.prototype.hasOwnProperty.call(node, 'padding')) {
+      defaults(node, {
+        paddingLeft: node.padding,
+        paddingRight: node.padding,
+        paddingTop: node.padding,
+        paddingBottom: node.padding,
+      });
+    }
+
+    defaults(node, NODE_DEFAULT_ATTRS);
+
+    ['paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom'].forEach((k) => {
+      node[k] = Number(node[k]);
+    });
+
+    // Save dimensions for restore during post-processing
+    if (Object.prototype.hasOwnProperty.call(node, 'width')) {
+      node._prevWidth = node.width;
+    }
+    if (Object.prototype.hasOwnProperty.call(node, 'height')) {
+      node._prevHeight = node.height;
+    }
+  });
+
+  g.edges().forEach(function (e) {
+    var edge = g.edge(e);
+    if (!Object.prototype.hasOwnProperty.call(edge, 'label')) {
+      edge.label = '';
+    }
+    defaults(edge, EDGE_DEFAULT_ATTRS);
+  });
+}
+
+function postProcessGraph(g) {
+  g.nodes().forEach((v) => {
+    /** @type {Node} */
+    var node = g.node(v);
+
+    // Restore original dimensions
+    if (Object.prototype.hasOwnProperty.call(node, '_prevWidth')) {
+      node.width = node._prevWidth;
+    } else {
+      delete node.width;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(node, '_prevHeight')) {
+      node.height = node._prevHeight;
+    } else {
+      delete node.height;
+    }
+
+    delete node._prevWidth;
+    delete node._prevHeight;
+  });
+}
+
+function createOrSelectGroup(root, name) {
+  var selection = root.select('g.' + name);
+  if (selection.empty()) {
+    selection = root.append('g').attr('class', name);
+  }
+  return selection;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/shapes.d.ts

@@ -0,0 +1,12 @@
+export namespace shapes {
+    export { rect };
+    export { ellipse };
+    export { circle };
+    export { diamond };
+}
+export function setShapes(value: any): void;
+declare function rect(parent: any, bbox: any, node: any): any;
+declare function ellipse(parent: any, bbox: any, node: any): any;
+declare function circle(parent: any, bbox: any, node: any): any;
+declare function diamond(parent: any, bbox: any, node: any): any;
+export {};

praesentation/node_modules/dagre-d3-es/src/dagre-js/shapes.js

@@ -0,0 +1,94 @@
+import { intersectCircle } from './intersect/intersect-circle.js';
+import { intersectEllipse } from './intersect/intersect-ellipse.js';
+import { intersectPolygon } from './intersect/intersect-polygon.js';
+import { intersectRect } from './intersect/intersect-rect.js';
+
+export { shapes, setShapes };
+
+var shapes = {
+  rect,
+  ellipse,
+  circle,
+  diamond,
+};
+
+function setShapes(value) {
+  shapes = value;
+}
+
+function rect(parent, bbox, node) {
+  var shapeSvg = parent
+    .insert('rect', ':first-child')
+    .attr('rx', node.rx)
+    .attr('ry', node.ry)
+    .attr('x', -bbox.width / 2)
+    .attr('y', -bbox.height / 2)
+    .attr('width', bbox.width)
+    .attr('height', bbox.height);
+
+  node.intersect = function (point) {
+    return intersectRect(node, point);
+  };
+
+  return shapeSvg;
+}
+
+function ellipse(parent, bbox, node) {
+  var rx = bbox.width / 2;
+  var ry = bbox.height / 2;
+  var shapeSvg = parent
+    .insert('ellipse', ':first-child')
+    .attr('x', -bbox.width / 2)
+    .attr('y', -bbox.height / 2)
+    .attr('rx', rx)
+    .attr('ry', ry);
+
+  node.intersect = function (point) {
+    return intersectEllipse(node, rx, ry, point);
+  };
+
+  return shapeSvg;
+}
+
+function circle(parent, bbox, node) {
+  var r = Math.max(bbox.width, bbox.height) / 2;
+  var shapeSvg = parent
+    .insert('circle', ':first-child')
+    .attr('x', -bbox.width / 2)
+    .attr('y', -bbox.height / 2)
+    .attr('r', r);
+
+  node.intersect = function (point) {
+    return intersectCircle(node, r, point);
+  };
+
+  return shapeSvg;
+}
+
+// Circumscribe an ellipse for the bounding box with a diamond shape. I derived
+// the function to calculate the diamond shape from:
+// http://mathforum.org/kb/message.jspa?messageID=3750236
+function diamond(parent, bbox, node) {
+  var w = (bbox.width * Math.SQRT2) / 2;
+  var h = (bbox.height * Math.SQRT2) / 2;
+  var points = [
+    { x: 0, y: -h },
+    { x: -w, y: 0 },
+    { x: 0, y: h },
+    { x: w, y: 0 },
+  ];
+  var shapeSvg = parent.insert('polygon', ':first-child').attr(
+    'points',
+    points
+      .map(function (p) {
+        return p.x + ',' + p.y;
+      })
+      .join(' '),
+  );
+
+  node.intersect = function (p) {
+    return intersectPolygon(node, points, p);
+  };
+
+  return shapeSvg;
+}

praesentation/node_modules/dagre-d3-es/src/dagre-js/util.d.ts

@@ -0,0 +1,5 @@
+export function isSubgraph(g: any, v: any): boolean;
+export function edgeToId(e: any): string;
+export function applyStyle(dom: any, styleFn: any): void;
+export function applyClass(dom: any, classFn: any, otherClasses: any): void;
+export function applyTransition(selection: any, g: any): any;

praesentation/node_modules/dagre-d3-es/src/dagre-js/util.js

@@ -0,0 +1,46 @@
+import * as _ from 'lodash-es';
+
+// Public utility functions
+export { isSubgraph, edgeToId, applyStyle, applyClass, applyTransition };
+
+/*
+ * Returns true if the specified node in the graph is a subgraph node. A
+ * subgraph node is one that contains other nodes.
+ */
+function isSubgraph(g, v) {
+  return !!g.children(v).length;
+}
+
+function edgeToId(e) {
+  return escapeId(e.v) + ':' + escapeId(e.w) + ':' + escapeId(e.name);
+}
+
+var ID_DELIM = /:/g;
+function escapeId(str) {
+  return str ? String(str).replace(ID_DELIM, '\\:') : '';
+}
+
+function applyStyle(dom, styleFn) {
+  if (styleFn) {
+    dom.attr('style', styleFn);
+  }
+}
+
+function applyClass(dom, classFn, otherClasses) {
+  if (classFn) {
+    dom.attr('class', classFn).attr('class', otherClasses + ' ' + dom.attr('class'));
+  }
+}
+
+function applyTransition(selection, g) {
+  var graph = g.graph();
+
+  if (_.isPlainObject(graph)) {
+    var transition = graph.transition;
+    if (_.isFunction(transition)) {
+      return transition(selection);
+    }
+  }
+
+  return selection;
+}