@html-graph/html-graph 8.5.0 → 8.6.1

package/dist/html-graph.js

@@ -1,20 +1,22 @@
-var Ye = Object.defineProperty;
-var Xe = (r, e, t) => e in r ? Ye(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var i = (r, e, t) => Xe(r, typeof e != "symbol" ? e + "" : e, t);
-var D = /* @__PURE__ */ ((r) => (r.Line = "line", r.NodeCycle = "node-cycle", r.PortCycle = "port-cycle", r))(D || {});
-const Ge = () => {
+var Ke = Object.defineProperty;
+var Qe = (r, e, t) => e in r ? Ke(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var i = (r, e, t) => Qe(r, typeof e != "symbol" ? e + "" : e, t);
+var R = /* @__PURE__ */ ((r) => (r.Line = "line", r.NodeCycle = "node-cycle", r.PortCycle = "port-cycle", r))(R || {});
+const Ze = () => {
   const r = document.createElement("div");
   return r.style.width = "100%", r.style.height = "100%", r.style.position = "relative", r.style.overflow = "hidden", r;
-}, je = () => {
+}, Je = () => {
   const r = document.createElement("div");
   return r.style.position = "absolute", r.style.top = "0", r.style.left = "0", r.style.width = "0", r.style.height = "0", r;
-}, qe = (r) => {
+}, _e = (r) => {
   r.style.position = "absolute", r.style.top = "0", r.style.left = "0", r.style.visibility = "hidden";
+}, et = (r) => {
+  r.style.removeProperty("position"), r.style.removeProperty("top"), r.style.removeProperty("left"), r.style.removeProperty("visibility"), r.style.removeProperty("transform");
 };
-class xe {
+class Ee {
   constructor(e, t, s) {
-    i(this, "host", Ge());
-    i(this, "container", je());
+    i(this, "host", Ze());
+    i(this, "container", Je());
     i(this, "edgeIdToElementMap", /* @__PURE__ */ new Map());
     i(this, "attachedNodeIds", /* @__PURE__ */ new Set());
     i(this, "applyTransform", () => {
@@ -25,11 +27,11 @@ class xe {
   }
   attachNode(e) {
     const t = this.graphStore.getNode(e);
-    qe(t.element), this.attachedNodeIds.add(e), this.container.appendChild(t.element), this.updateNodePosition(e), this.updateNodePriority(e), t.element.style.visibility = "visible";
+    _e(t.element), this.attachedNodeIds.add(e), this.container.appendChild(t.element), this.updateNodePosition(e), this.updateNodePriority(e), t.element.style.visibility = "visible";
   }
   detachNode(e) {
     const t = this.graphStore.getNode(e);
-    this.container.removeChild(t.element), this.attachedNodeIds.delete(e);
+    et(t.element), this.container.removeChild(t.element), this.attachedNodeIds.delete(e);
   }
   attachEdge(e) {
     const t = this.graphStore.getEdge(e).payload.shape.svg;
@@ -47,7 +49,7 @@ class xe {
     });
   }
   destroy() {
-    this.viewportStore.onAfterUpdated.unsubscribe(this.applyTransform), this.element.removeChild(this.host), this.host.removeChild(this.container);
+    this.clear(), this.viewportStore.onAfterUpdated.unsubscribe(this.applyTransform), this.element.removeChild(this.host), this.host.removeChild(this.container);
   }
   updateNodePosition(e) {
     const t = this.graphStore.getNode(e), { width: s, height: o } = t.element.getBoundingClientRect(), n = this.viewportStore.getViewportMatrix().scale, { payload: a } = t, h = a.centerFn(s, o), d = a.x - n * h.x, c = a.y - n * h.y;
@@ -70,8 +72,8 @@ class xe {
       h,
       d
     ), g = this.createEdgeRenderPort(o, a, h, d);
-    let l = D.Line;
-    s.element === o.element ? l = D.PortCycle : s.nodeId === o.nodeId && (l = D.NodeCycle), t.payload.shape.render({ from: c, to: g, category: l });
+    let l = R.Line;
+    s.element === o.element ? l = R.PortCycle : s.nodeId === o.nodeId && (l = R.NodeCycle), t.payload.shape.render({ from: c, to: g, category: l });
   }
   updateEdgePriority(e) {
     const t = this.graphStore.getEdge(e);
@@ -91,7 +93,7 @@ class xe {
     };
   }
 }
-class Ke {
+class tt {
   constructor(e) {
     i(this, "xFrom", 1 / 0);
     i(this, "yFrom", 1 / 0);
@@ -111,7 +113,7 @@ class Ke {
     return h <= this.xTo && d >= this.xFrom && c <= this.yTo && g >= this.yFrom;
   }
 }
-class Qe {
+class rt {
   constructor(e, t, s, o) {
     i(this, "attachedNodes", /* @__PURE__ */ new Set());
     i(this, "attachedEdges", /* @__PURE__ */ new Set());
@@ -135,7 +137,7 @@ class Qe {
         this.handleAttachEdge(a);
       });
     });
-    this.htmlView = e, this.graphStore = t, this.trigger = s, this.params = o, this.renderingBox = new Ke(this.graphStore), this.trigger.subscribe(this.updateViewport);
+    this.htmlView = e, this.graphStore = t, this.trigger = s, this.params = o, this.renderingBox = new tt(this.graphStore), this.trigger.subscribe(this.updateViewport);
   }
   attachNode(e) {
     this.renderingBox.hasNode(e) && this.handleAttachNode(e);
@@ -189,7 +191,7 @@ class Qe {
     this.htmlView.detachEdge(e), this.attachedEdges.delete(e);
   }
 }
-class Ze {
+class st {
   constructor(e, t) {
     i(this, "deferredNodes", /* @__PURE__ */ new Set());
     i(this, "deferredEdges", /* @__PURE__ */ new Set());
@@ -243,7 +245,7 @@ class Ze {
     this.isEdgeValid(e) && (this.deferredEdges.delete(e), this.htmlView.attachEdge(e));
   }
 }
-class Q {
+class K {
   constructor() {
     i(this, "callbacks", /* @__PURE__ */ new Set());
   }
@@ -259,215 +261,64 @@ class Q {
     });
   }
 }
-const E = () => {
-  const r = new Q();
+const S = () => {
+  const r = new K();
   return [r, r];
 };
-class G {
-  constructor(e) {
-    i(this, "counter", 0);
-    this.checkExists = e;
-  }
-  create(e) {
-    if (e !== void 0)
-      return e;
-    for (; this.checkExists(this.counter); )
-      this.counter++;
-    return this.counter;
-  }
-  reset() {
-    this.counter = 0;
-  }
-}
-class Ee {
-  constructor(e, t, s, o, n, a) {
-    i(this, "nodeIdGenerator", new G(
-      (e) => this.graphStore.hasNode(e)
-    ));
-    i(this, "portIdGenerator", new G(
-      (e) => this.graphStore.hasPort(e)
-    ));
-    i(this, "edgeIdGenerator", new G(
-      (e) => this.graphStore.hasEdge(e)
-    ));
-    i(this, "onAfterNodeAdded", (e) => {
-      this.htmlView.attachNode(e);
-    });
-    i(this, "onAfterNodeUpdated", (e) => {
-      this.htmlView.updateNodePosition(e), this.graphStore.getNodeAdjacentEdgeIds(e).forEach((t) => {
-        this.htmlView.renderEdge(t);
-      });
-    });
-    i(this, "onAfterNodePriorityUpdated", (e) => {
-      this.htmlView.updateNodePriority(e);
-    });
-    i(this, "onBeforeNodeRemoved", (e) => {
-      this.graphStore.getNodePortIds(e).forEach((t) => {
-        this.unmarkPort(t);
-      }), this.htmlView.detachNode(e);
-    });
-    i(this, "onAfterPortUpdated", (e) => {
-      this.graphStore.getPortAdjacentEdgeIds(e).forEach((t) => {
-        this.htmlView.renderEdge(t);
-      });
-    });
-    i(this, "onBeforePortUnmarked", (e) => {
-      this.graphStore.getPortAdjacentEdgeIds(e).forEach((t) => {
-        this.removeEdge(t);
-      });
-    });
-    i(this, "onAfterEdgeAdded", (e) => {
-      this.htmlView.attachEdge(e);
-    });
-    i(this, "onAfterEdgeShapeUpdated", (e) => {
-      this.htmlView.updateEdgeShape(e);
-    });
-    i(this, "onAfterEdgeUpdated", (e) => {
-      this.htmlView.renderEdge(e);
-    });
-    i(this, "onAfterEdgePriorityUpdated", (e) => {
-      this.htmlView.updateEdgePriority(e);
-    });
-    i(this, "onBeforeEdgeRemoved", (e) => {
-      this.htmlView.detachEdge(e);
-    });
-    i(this, "onBeforeClear", () => {
-      this.nodeIdGenerator.reset(), this.portIdGenerator.reset(), this.edgeIdGenerator.reset(), this.htmlView.clear();
-    });
-    i(this, "onBeforeDestroyEmitter");
+class Se {
+  constructor(e, t, s, o) {
+    i(this, "beforeDestroyEmitter");
     i(this, "destroyed", !1);
-    /**
-     * emits event just before destruction of canvas
-     */
     i(this, "onBeforeDestroy");
-    this.graph = e, this.viewport = t, this.graphStore = s, this.viewportStore = o, this.htmlView = n, this.params = a, this.graphStore.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.graphStore.onAfterNodeUpdated.subscribe(this.onAfterNodeUpdated), this.graphStore.onAfterNodePriorityUpdated.subscribe(
-      this.onAfterNodePriorityUpdated
-    ), this.graphStore.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.graphStore.onAfterPortUpdated.subscribe(this.onAfterPortUpdated), this.graphStore.onBeforePortRemoved.subscribe(this.onBeforePortUnmarked), this.graphStore.onAfterEdgeAdded.subscribe(this.onAfterEdgeAdded), this.graphStore.onAfterEdgeShapeUpdated.subscribe(
-      this.onAfterEdgeShapeUpdated
-    ), this.graphStore.onAfterEdgeUpdated.subscribe(this.onAfterEdgeUpdated), this.graphStore.onAfterEdgePriorityUpdated.subscribe(
-      this.onAfterEdgePriorityUpdated
-    ), this.graphStore.onBeforeEdgeRemoved.subscribe(this.onBeforeEdgeRemoved), this.graphStore.onBeforeClear.subscribe(this.onBeforeClear), [this.onBeforeDestroyEmitter, this.onBeforeDestroy] = E();
+    this.graph = e, this.viewport = t, this.graphController = s, this.viewportController = o, [this.beforeDestroyEmitter, this.onBeforeDestroy] = S();
   }
-  /**
-   * adds new node
-   */
   addNode(e) {
-    const t = this.nodeIdGenerator.create(e.id);
-    if (this.graphStore.addNode({
-      id: t,
-      element: e.element,
-      x: e.x ?? null,
-      y: e.y ?? null,
-      centerFn: e.centerFn ?? this.params.nodes.centerFn,
-      priority: e.priority ?? this.params.nodes.priorityFn()
-    }), e.ports !== void 0)
-      for (const s of e.ports)
-        this.markPort({
-          id: s.id,
-          element: s.element,
-          nodeId: t,
-          direction: s.direction
-        });
-    return this;
+    return this.graphController.addNode(e), this;
   }
-  /**
-   * updates node parameters
-   */
   updateNode(e, t) {
-    return this.graphStore.updateNode(e, t ?? {}), this;
+    return this.graphController.updateNode(e, t), this;
   }
-  /**
-   * removes specified node
-   * all the ports of node get unmarked
-   * all the edges adjacent to node get removed
-   */
   removeNode(e) {
-    return this.graphStore.removeNode(e), this;
+    return this.graphController.removeNode(e), this;
   }
-  /**
-   * marks specified element as a port for specified node
-   */
   markPort(e) {
-    const t = this.portIdGenerator.create(e.id);
-    return this.graphStore.addPort({
-      id: t,
-      element: e.element,
-      nodeId: e.nodeId,
-      direction: e.direction ?? this.params.ports.direction
-    }), this;
+    return this.graphController.markPort(e), this;
   }
-  /**
-   * updates port and edges attached to it
-   */
   updatePort(e, t) {
-    return this.graphStore.updatePort(e, t ?? {}), this;
+    return this.graphController.updatePort(e, t), this;
   }
-  /**
-   * unmarks specified port
-   * all the edges adjacent to the port get removed
-   */
   unmarkPort(e) {
-    return this.graphStore.removePort(e), this;
+    return this.graphController.unmarkPort(e), this;
   }
-  /**
-   * adds new edge
-   */
   addEdge(e) {
-    const t = this.edgeIdGenerator.create(e.id);
-    return this.graphStore.addEdge({
-      id: t,
-      from: e.from,
-      to: e.to,
-      shape: e.shape ?? this.params.edges.shapeFactory(t),
-      priority: e.priority ?? this.params.edges.priorityFn()
-    }), this;
+    return this.graphController.addEdge(e), this;
   }
-  /**
-   * updates specified edge
-   */
   updateEdge(e, t) {
-    return this.graphStore.updateEdge(e, t ?? {}), this;
+    return this.graphController.updateEdge(e, t), this;
   }
-  /**
-   * removes specified edge
-   */
   removeEdge(e) {
-    return this.graphStore.removeEdge(e), this;
+    return this.graphController.removeEdge(e), this;
   }
-  /**
-   * clears canvas from nodes and edges
-   * canvas gets rolled back to initial state and can be reused
-   */
   clear() {
-    return this.graphStore.clear(), this;
+    return this.graphController.clear(), this;
+  }
+  focus(e) {
+    return this.viewportController.focus(e), this;
+  }
+  center(e, t) {
+    return this.viewportController.center(e, t), this;
   }
-  /**
-   * applies transformation for viewport matrix
-   */
   patchViewportMatrix(e) {
-    return this.viewportStore.patchViewportMatrix(e), this;
+    return this.viewportController.patchViewportMatrix(e), this;
   }
-  /**
-   * applies transformation for content matrix
-   */
   patchContentMatrix(e) {
-    return this.viewportStore.patchContentMatrix(e), this;
+    return this.viewportController.patchContentMatrix(e), this;
   }
-  /**
-   * destroys canvas
-   * canvas element gets rolled back to initial state, and can not be reused
-   */
   destroy() {
-    this.destroyed || (this.clear(), this.onBeforeDestroyEmitter.emit(), this.graphStore.onAfterNodeAdded.unsubscribe(this.onAfterNodeAdded), this.graphStore.onAfterNodeUpdated.unsubscribe(this.onAfterNodeUpdated), this.graphStore.onAfterNodePriorityUpdated.unsubscribe(
-      this.onAfterNodePriorityUpdated
-    ), this.graphStore.onBeforeNodeRemoved.unsubscribe(this.onBeforeNodeRemoved), this.graphStore.onAfterPortUpdated.unsubscribe(this.onAfterPortUpdated), this.graphStore.onBeforePortRemoved.unsubscribe(this.onBeforePortUnmarked), this.graphStore.onAfterEdgeAdded.unsubscribe(this.onAfterEdgeAdded), this.graphStore.onAfterEdgeShapeUpdated.unsubscribe(
-      this.onAfterEdgeShapeUpdated
-    ), this.graphStore.onAfterEdgeUpdated.unsubscribe(this.onAfterEdgeUpdated), this.graphStore.onAfterEdgePriorityUpdated.unsubscribe(
-      this.onAfterEdgePriorityUpdated
-    ), this.graphStore.onBeforeEdgeRemoved.unsubscribe(this.onBeforeEdgeRemoved), this.graphStore.onBeforeClear.unsubscribe(this.onBeforeClear), this.htmlView.destroy(), this.viewportStore.destroy(), this.destroyed = !0);
+    this.destroyed || (this.destroyed = !0, this.beforeDestroyEmitter.emit(), this.graphController.destroy(), this.viewportController.destroy());
   }
 }
-class Je {
+class ot {
   constructor() {
     i(this, "singleToMultiMap", /* @__PURE__ */ new Map());
     i(this, "multiToSingleMap", /* @__PURE__ */ new Map());
@@ -507,22 +358,22 @@ class Je {
     return this.multiToSingleMap.get(e) !== void 0;
   }
 }
-class x extends Error {
+class E extends Error {
   constructor() {
     super(...arguments);
     i(this, "name", "CanvasError");
   }
 }
-class Se {
+class be {
   constructor() {
     i(this, "nodes", /* @__PURE__ */ new Map());
     i(this, "ports", /* @__PURE__ */ new Map());
     i(this, "edges", /* @__PURE__ */ new Map());
     i(this, "nodesElementsMap", /* @__PURE__ */ new Map());
     i(this, "portIncomingEdges", /* @__PURE__ */ new Map());
-    i(this, "portOutcomingEdges", /* @__PURE__ */ new Map());
+    i(this, "portOutgoingEdges", /* @__PURE__ */ new Map());
     i(this, "portCycleEdges", /* @__PURE__ */ new Map());
-    i(this, "elementPorts", new Je());
+    i(this, "elementPorts", new ot());
     i(this, "afterNodeAddedEmitter");
     i(this, "onAfterNodeAdded");
     i(this, "afterNodeUpdatedEmitter");
@@ -549,7 +400,7 @@ class Se {
     i(this, "onBeforeEdgeRemoved");
     i(this, "beforeClearEmitter");
     i(this, "onBeforeClear");
-    [this.afterNodeAddedEmitter, this.onAfterNodeAdded] = E(), [this.afterNodeUpdatedEmitter, this.onAfterNodeUpdated] = E(), [this.afterNodePriorityUpdatedEmitter, this.onAfterNodePriorityUpdated] = E(), [this.beforeNodeRemovedEmitter, this.onBeforeNodeRemoved] = E(), [this.afterPortAddedEmitter, this.onAfterPortAdded] = E(), [this.afterPortUpdatedEmitter, this.onAfterPortUpdated] = E(), [this.beforePortRemovedEmitter, this.onBeforePortRemoved] = E(), [this.afterEdgeAddedEmitter, this.onAfterEdgeAdded] = E(), [this.afterEdgeShapeUpdatedEmitter, this.onAfterEdgeShapeUpdated] = E(), [this.afterEdgeUpdatedEmitter, this.onAfterEdgeUpdated] = E(), [this.afterEdgePriorityUpdatedEmitter, this.onAfterEdgePriorityUpdated] = E(), [this.beforeEdgeRemovedEmitter, this.onBeforeEdgeRemoved] = E(), [this.beforeClearEmitter, this.onBeforeClear] = E();
+    [this.afterNodeAddedEmitter, this.onAfterNodeAdded] = S(), [this.afterNodeUpdatedEmitter, this.onAfterNodeUpdated] = S(), [this.afterNodePriorityUpdatedEmitter, this.onAfterNodePriorityUpdated] = S(), [this.beforeNodeRemovedEmitter, this.onBeforeNodeRemoved] = S(), [this.afterPortAddedEmitter, this.onAfterPortAdded] = S(), [this.afterPortUpdatedEmitter, this.onAfterPortUpdated] = S(), [this.beforePortRemovedEmitter, this.onBeforePortRemoved] = S(), [this.afterEdgeAddedEmitter, this.onAfterEdgeAdded] = S(), [this.afterEdgeShapeUpdatedEmitter, this.onAfterEdgeShapeUpdated] = S(), [this.afterEdgeUpdatedEmitter, this.onAfterEdgeUpdated] = S(), [this.afterEdgePriorityUpdatedEmitter, this.onAfterEdgePriorityUpdated] = S(), [this.beforeEdgeRemovedEmitter, this.onBeforeEdgeRemoved] = S(), [this.beforeClearEmitter, this.onBeforeClear] = S();
   }
   hasNode(e) {
     return this.nodes.has(e);
@@ -557,14 +408,14 @@ class Se {
   getNode(e) {
     const t = this.nodes.get(e);
     if (t === void 0)
-      throw new x("failed to access nonexistent node");
+      throw new E("failed to access nonexistent node");
     return t;
   }
   addNode(e) {
     if (this.hasNode(e.id))
-      throw new x("failed to add node with existing id");
+      throw new E("failed to add node with existing id");
     if (this.findNodeIdByElement(e.element) !== void 0)
-      throw new x(
+      throw new E(
         "failed to add node with html element already in use by another node"
       );
     const t = /* @__PURE__ */ new Map(), s = {
@@ -587,13 +438,13 @@ class Se {
   }
   updateNode(e, t) {
     if (!this.hasNode(e))
-      throw new x("failed to update nonexistent node");
+      throw new E("failed to update nonexistent node");
     const { payload: s } = this.nodes.get(e);
     s.x = t.x ?? s.x, s.y = t.y ?? s.y, s.centerFn = t.centerFn ?? s.centerFn, t.priority !== void 0 && (s.priority = t.priority, this.afterNodePriorityUpdatedEmitter.emit(e)), this.afterNodeUpdatedEmitter.emit(e);
   }
   removeNode(e) {
     if (!this.hasNode(e))
-      throw new x("failed to remove nonexistent node");
+      throw new E("failed to remove nonexistent node");
     this.beforeNodeRemovedEmitter.emit(e);
     const t = this.nodes.get(e);
     this.nodesElementsMap.delete(t.element), this.nodes.delete(e);
@@ -604,25 +455,25 @@ class Se {
   getPort(e) {
     const t = this.ports.get(e);
     if (t === void 0)
-      throw new x("failed to access nonexistent port");
+      throw new E("failed to access nonexistent port");
     return t;
   }
   addPort(e) {
     if (this.hasPort(e.id))
-      throw new x("failed to add port with existing id");
+      throw new E("failed to add port with existing id");
     if (!this.hasNode(e.nodeId))
-      throw new x("failed to add port to nonexistent node");
+      throw new E("failed to add port to nonexistent node");
     this.ports.set(e.id, {
       element: e.element,
       payload: {
         direction: e.direction
       },
       nodeId: e.nodeId
-    }), this.elementPorts.addRecord(e.element, e.id), this.portCycleEdges.set(e.id, /* @__PURE__ */ new Set()), this.portIncomingEdges.set(e.id, /* @__PURE__ */ new Set()), this.portOutcomingEdges.set(e.id, /* @__PURE__ */ new Set()), this.nodes.get(e.nodeId).ports.set(e.id, e.element), this.afterPortAddedEmitter.emit(e.id);
+    }), this.elementPorts.addRecord(e.element, e.id), this.portCycleEdges.set(e.id, /* @__PURE__ */ new Set()), this.portIncomingEdges.set(e.id, /* @__PURE__ */ new Set()), this.portOutgoingEdges.set(e.id, /* @__PURE__ */ new Set()), this.nodes.get(e.nodeId).ports.set(e.id, e.element), this.afterPortAddedEmitter.emit(e.id);
   }
   updatePort(e, t) {
     if (!this.hasPort(e))
-      throw new x("failed to update nonexistent port");
+      throw new E("failed to update nonexistent port");
     const s = this.ports.get(e).payload;
     s.direction = t.direction ?? s.direction, this.afterPortUpdatedEmitter.emit(e);
   }
@@ -635,12 +486,12 @@ class Se {
   getNodePortIds(e) {
     const t = this.nodes.get(e);
     if (t === void 0)
-      throw new x("failed to access port ids of nonexistent node");
+      throw new E("failed to access port ids of nonexistent node");
     return Array.from(t.ports.keys());
   }
   removePort(e) {
     if (!this.hasPort(e))
-      throw new x("failed to remove nonexistent port");
+      throw new E("failed to remove nonexistent port");
     const t = this.ports.get(e).nodeId;
     this.beforePortRemovedEmitter.emit(e), this.nodes.get(t).ports.delete(e), this.ports.delete(e), this.elementPorts.removeByMulti(e);
   }
@@ -650,21 +501,21 @@ class Se {
   getEdge(e) {
     const t = this.edges.get(e);
     if (t === void 0)
-      throw new x("failed to access nonexistent edge");
+      throw new E("failed to access nonexistent edge");
     return t;
   }
   addEdge(e) {
     if (this.hasEdge(e.id))
-      throw new x("failed to add edge with existing id");
+      throw new E("failed to add edge with existing id");
     if (!this.hasPort(e.from))
-      throw new x("failed to add edge from nonexistent port");
+      throw new E("failed to add edge from nonexistent port");
     if (!this.hasPort(e.to))
-      throw new x("failed to add edge to nonexistent port");
+      throw new E("failed to add edge to nonexistent port");
     this.addEdgeInternal(e), this.afterEdgeAddedEmitter.emit(e.id);
   }
   updateEdge(e, t) {
     if (!this.hasEdge(e))
-      throw new x("failed to update nonexistent edge");
+      throw new E("failed to update nonexistent edge");
     if (t.from !== void 0 || t.to !== void 0) {
       const o = this.edges.get(e), n = o.payload;
       this.removeEdgeInternal(e), this.addEdgeInternal({
@@ -683,28 +534,28 @@ class Se {
   }
   removeEdge(e) {
     if (!this.hasEdge(e))
-      throw new x("failed to remove nonexistent edge");
+      throw new E("failed to remove nonexistent edge");
     this.beforeEdgeRemovedEmitter.emit(e), this.removeEdgeInternal(e);
   }
   clear() {
-    this.beforeClearEmitter.emit(), this.portIncomingEdges.clear(), this.portOutcomingEdges.clear(), this.portCycleEdges.clear(), this.elementPorts.clear(), this.nodesElementsMap.clear(), this.edges.clear(), this.ports.clear(), this.nodes.clear();
+    this.beforeClearEmitter.emit(), this.portIncomingEdges.clear(), this.portOutgoingEdges.clear(), this.portCycleEdges.clear(), this.elementPorts.clear(), this.nodesElementsMap.clear(), this.edges.clear(), this.ports.clear(), this.nodes.clear();
   }
   getPortIncomingEdgeIds(e) {
     const t = this.portIncomingEdges.get(e);
     if (t === void 0)
-      throw new x("failed to access edges for nonexistent port");
+      throw new E("failed to access edges for nonexistent port");
     return Array.from(t);
   }
   getPortOutgoingEdgeIds(e) {
-    const t = this.portOutcomingEdges.get(e);
+    const t = this.portOutgoingEdges.get(e);
     if (t === void 0)
-      throw new x("failed to access edges for nonexistent port");
+      throw new E("failed to access edges for nonexistent port");
     return Array.from(t);
   }
   getPortCycleEdgeIds(e) {
     const t = this.portCycleEdges.get(e);
     if (t === void 0)
-      throw new x("failed to access edges for nonexistent port");
+      throw new E("failed to access edges for nonexistent port");
     return Array.from(t);
   }
   getPortAdjacentEdgeIds(e) {
@@ -769,29 +620,29 @@ class Se {
         shape: e.shape,
         priority: e.priority
       }
-    }), e.from !== e.to ? (this.portOutcomingEdges.get(e.from).add(e.id), this.portIncomingEdges.get(e.to).add(e.id)) : this.portCycleEdges.get(e.from).add(e.id);
+    }), e.from !== e.to ? (this.portOutgoingEdges.get(e.from).add(e.id), this.portIncomingEdges.get(e.to).add(e.id)) : this.portCycleEdges.get(e.from).add(e.id);
   }
   removeEdgeInternal(e) {
     const t = this.edges.get(e), s = t.from, o = t.to;
-    this.portCycleEdges.get(s).delete(e), this.portCycleEdges.get(o).delete(e), this.portIncomingEdges.get(s).delete(e), this.portIncomingEdges.get(o).delete(e), this.portOutcomingEdges.get(s).delete(e), this.portOutcomingEdges.get(o).delete(e), this.edges.delete(e);
+    this.portCycleEdges.get(s).delete(e), this.portCycleEdges.get(o).delete(e), this.portIncomingEdges.get(s).delete(e), this.portIncomingEdges.get(o).delete(e), this.portOutgoingEdges.get(s).delete(e), this.portOutgoingEdges.get(o).delete(e), this.edges.delete(e);
   }
 }
-const ge = (r) => ({
+const ue = (r) => ({
   scale: 1 / r.scale,
   x: -r.x / r.scale,
   y: -r.y / r.scale
-}), ue = {
+}), pe = {
   scale: 1,
   x: 0,
   y: 0
-}, pe = (r, e) => ({
+}, we = (r, e) => ({
   x: r.scale * e.x + r.x,
   y: r.scale * e.y + r.y
 });
-class _e {
+class it {
   constructor(e) {
-    i(this, "viewportMatrix", ue);
-    i(this, "contentMatrix", ue);
+    i(this, "viewportMatrix", pe);
+    i(this, "contentMatrix", pe);
     i(this, "beforeUpdateEmitter");
     i(this, "onBeforeUpdated");
     i(this, "afterUpdateEmitter");
@@ -801,7 +652,7 @@ class _e {
     i(this, "observer", new ResizeObserver(() => {
       this.afterResizeEmitter.emit();
     }));
-    this.host = e, [this.afterUpdateEmitter, this.onAfterUpdated] = E(), [this.beforeUpdateEmitter, this.onBeforeUpdated] = E(), [this.afterResizeEmitter, this.onAfterResize] = E(), this.observer.observe(this.host);
+    this.host = e, [this.afterUpdateEmitter, this.onAfterUpdated] = S(), [this.beforeUpdateEmitter, this.onBeforeUpdated] = S(), [this.afterResizeEmitter, this.onAfterResize] = S(), this.observer.observe(this.host);
   }
   getViewportMatrix() {
     return this.viewportMatrix;
@@ -814,30 +665,30 @@ class _e {
       scale: e.scale ?? this.viewportMatrix.scale,
       x: e.x ?? this.viewportMatrix.x,
       y: e.y ?? this.viewportMatrix.y
-    }, this.beforeUpdateEmitter.emit(), this.contentMatrix = ge(this.viewportMatrix), this.afterUpdateEmitter.emit();
+    }, this.beforeUpdateEmitter.emit(), this.contentMatrix = ue(this.viewportMatrix), this.afterUpdateEmitter.emit();
   }
   patchContentMatrix(e) {
     this.contentMatrix = {
       scale: e.scale ?? this.contentMatrix.scale,
       x: e.x ?? this.contentMatrix.x,
       y: e.y ?? this.contentMatrix.y
-    }, this.beforeUpdateEmitter.emit(), this.viewportMatrix = ge(this.contentMatrix), this.afterUpdateEmitter.emit();
+    }, this.beforeUpdateEmitter.emit(), this.viewportMatrix = ue(this.contentMatrix), this.afterUpdateEmitter.emit();
   }
   getDimensions() {
     const { width: e, height: t } = this.host.getBoundingClientRect();
     return { width: e, height: t };
   }
   createContentCoords(e) {
-    return pe(this.viewportMatrix, e);
+    return we(this.viewportMatrix, e);
   }
   createViewportCoords(e) {
-    return pe(this.contentMatrix, e);
+    return we(this.contentMatrix, e);
   }
   destroy() {
     this.observer.disconnect();
   }
 }
-class Z {
+class Q {
   constructor(e) {
     i(this, "elementToNodeId", /* @__PURE__ */ new Map());
     i(this, "nodesResizeObserver");
@@ -849,28 +700,31 @@ class Z {
       const t = this.canvas.graph.getNode(e);
       this.elementToNodeId.delete(t.element), this.nodesResizeObserver.unobserve(t.element);
     });
-    i(this, "onBeforeClear", () => {
+    i(this, "reset", () => {
       this.nodesResizeObserver.disconnect(), this.elementToNodeId.clear();
     });
+    i(this, "revert", () => {
+      this.reset();
+    });
     this.canvas = e, this.nodesResizeObserver = new ResizeObserver((t) => {
       t.forEach((s) => {
         const o = s.target;
         this.handleNodeResize(o);
       });
-    }), this.canvas.graph.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.canvas.graph.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.canvas.graph.onBeforeClear.subscribe(this.onBeforeClear);
+    }), this.canvas.graph.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.canvas.graph.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.canvas.graph.onBeforeClear.subscribe(this.reset), this.canvas.onBeforeDestroy.subscribe(this.revert);
   }
   static configure(e) {
-    new Z(e);
+    new Q(e);
   }
   handleNodeResize(e) {
     const t = this.elementToNodeId.get(e);
     this.canvas.updateNode(t);
   }
 }
-const et = (r, e, t) => {
+const nt = (r, e, t) => {
   const { x: s, y: o, width: n, height: a } = r.getBoundingClientRect();
   return e >= s && e <= s + n && t >= o && t <= o + a;
-}, tt = (r, e, t) => e >= 0 && e <= r.innerWidth && t >= 0 && t <= r.innerHeight, R = (r, e, t, s) => et(e, t, s) && tt(r, t, s), U = (r, e) => {
+}, at = (r, e, t) => e >= 0 && e <= r.innerWidth && t >= 0 && t <= r.innerHeight, D = (r, e, t, s) => nt(e, t, s) && at(r, t, s), U = (r, e) => {
   e !== null ? r.style.cursor = e : r.style.removeProperty("cursor");
 }, O = (r) => {
   const e = document.createElement("div");
@@ -887,7 +741,7 @@ const et = (r, e, t) => {
       }
     ]
   };
-}, rt = (r, e) => {
+}, ht = (r, e) => {
   let t = e;
   for (; t !== null; ) {
     const s = r.findPortIdsByElement(t)[0] ?? null;
@@ -906,21 +760,21 @@ const et = (r, e, t) => {
     status: "notFound"
   };
 };
-function* be(r, e) {
+function* Pe(r, e) {
   const t = r.elementsFromPoint(e.x, e.y);
   for (const s of t) {
     if (s.shadowRoot !== null) {
-      const o = be(s.shadowRoot, e);
+      const o = Pe(s.shadowRoot, e);
       for (const n of o)
         yield n;
     }
     yield s;
   }
 }
-const Pe = (r, e) => {
-  const t = be(document, e);
+const Ce = (r, e) => {
+  const t = Pe(document, e);
   for (const s of t) {
-    const o = rt(r, s);
+    const o = ht(r, s);
     if (o.status === "portFound")
       return o.portId;
     if (o.status === "nodeEncountered")
@@ -932,7 +786,7 @@ var N = /* @__PURE__ */ ((r) => (r.StaticNodeId = "static", r.DraggingNodeId = "
 const Ne = (r, e) => ({
   x: r / 2,
   y: e / 2
-}), p = {
+}), w = {
   x: 0,
   y: 0
 }, m = (r, e, t) => ({
@@ -954,11 +808,11 @@ const Ne = (r, e) => ({
     flipX: d,
     flipY: c
   };
-}, k = (r, e, t, s) => ({
+}, z = (r, e, t, s) => ({
   x: e * r.x + (1 - e) / 2 * s.x,
   y: t * r.y + (1 - t) / 2 * s.y
 });
-class st {
+class dt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
@@ -966,9 +820,9 @@ class st {
     const t = this.params.to;
     this.midpoint = { x: t.x / 2, y: t.y / 2 };
     const s = m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), o = m(
       { x: this.params.to.x - this.params.arrowLength, y: this.params.to.y },
       this.params.targetDirection,
@@ -979,20 +833,20 @@ class st {
     }, a = {
       x: o.x - this.params.targetDirection.x * this.params.curvature,
       y: o.y - this.params.targetDirection.y * this.params.curvature
-    }, h = `M ${s.x} ${s.y} C ${n.x} ${n.y}, ${a.x} ${a.y}, ${o.x} ${o.y}`, d = this.params.hasSourceArrow ? "" : `M ${p.x} ${p.y} L ${s.x} ${s.y} `, c = this.params.hasTargetArrow ? "" : ` M ${o.x} ${o.y} L ${this.params.to.x} ${this.params.to.y}`;
+    }, h = `M ${s.x} ${s.y} C ${n.x} ${n.y}, ${a.x} ${a.y}, ${o.x} ${o.y}`, d = this.params.hasSourceArrow ? "" : `M ${w.x} ${w.y} L ${s.x} ${s.y} `, c = this.params.hasTargetArrow ? "" : ` M ${o.x} ${o.y} L ${this.params.to.x} ${this.params.to.y}`;
     this.path = `${d}${h}${c}`;
   }
 }
-class ot {
+class ct {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, s = this.params.hasTargetArrow ? m(
+      w
+    ) : w, s = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1000,9 +854,9 @@ class ot {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, o = this.params.arrowLength, n = Math.cos(this.params.detourDirection) * this.params.detourDistance, a = Math.sin(this.params.detourDirection) * this.params.detourDistance, h = n * this.params.flipX, d = a * this.params.flipY, c = m(
-      { x: o, y: p.y },
+      { x: o, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), g = {
       x: c.x + h,
       y: c.y + d
@@ -1013,16 +867,16 @@ class ot {
     ), u = {
       x: l.x + h,
       y: l.y + d
-    }, w = {
+    }, p = {
       x: (g.x + u.x) / 2,
       y: (g.y + u.y) / 2
-    }, f = {
+    }, y = {
       x: c.x + this.params.curvature * this.params.sourceDirection.x,
       y: c.y + this.params.curvature * this.params.sourceDirection.y
     }, v = {
       x: l.x - this.params.curvature * this.params.targetDirection.x,
       y: l.y - this.params.curvature * this.params.targetDirection.y
-    }, S = {
+    }, x = {
       x: c.x + h,
       y: c.y + d
     }, b = {
@@ -1032,27 +886,27 @@ class ot {
     this.path = [
       `M ${t.x} ${t.y}`,
       `L ${c.x} ${c.y}`,
-      `C ${f.x} ${f.y} ${S.x} ${S.y} ${w.x} ${w.y}`,
+      `C ${y.x} ${y.y} ${x.x} ${x.y} ${p.x} ${p.y}`,
       `C ${b.x} ${b.y} ${v.x} ${v.y} ${l.x} ${l.y}`,
       `L ${s.x} ${s.y}`
-    ].join(" "), this.midpoint = k(w, e.flipX, e.flipY, e.to);
+    ].join(" "), this.midpoint = z(p, e.flipX, e.flipY, e.to);
   }
 }
-const J = Object.freeze({
+const Z = Object.freeze({
   edgeColor: "--edge-color"
-}), Ce = (r) => {
+}), Me = (r) => {
   const e = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-  return e.style.pointerEvents = "none", e.style.position = "absolute", e.style.top = "0", e.style.left = "0", e.style.overflow = "visible", e.style.setProperty(J.edgeColor, r), e;
-}, Me = (r) => {
+  return e.style.pointerEvents = "none", e.style.position = "absolute", e.style.top = "0", e.style.left = "0", e.style.overflow = "visible", e.style.setProperty(Z.edgeColor, r), e;
+}, Re = (r) => {
   const e = document.createElementNS("http://www.w3.org/2000/svg", "path");
-  return e.setAttribute("stroke", `var(${J.edgeColor})`), e.setAttribute("stroke-width", `${r}`), e.setAttribute("fill", "none"), e;
+  return e.setAttribute("stroke", `var(${Z.edgeColor})`), e.setAttribute("stroke-width", `${r}`), e.setAttribute("fill", "none"), e;
 }, W = () => {
   const r = document.createElementNS("http://www.w3.org/2000/svg", "path");
-  return r.setAttribute("fill", `var(${J.edgeColor})`), r;
+  return r.setAttribute("fill", `var(${Z.edgeColor})`), r;
 }, De = () => {
   const r = document.createElementNS("http://www.w3.org/2000/svg", "g");
   return r.style.transformOrigin = "50% 50%", r;
-}, Re = (r, e) => {
+}, Le = (r, e) => {
   r.style.transform = `translate(${e.x}px, ${e.y}px)`, r.style.width = `${Math.max(e.width, 1)}px`, r.style.height = `${Math.max(e.height, 1)}px`;
 }, M = (r, e) => {
   const t = [];
@@ -1061,20 +915,20 @@ const J = Object.freeze({
     let o = 0, n = 0, a = 0;
     r.forEach((h, d) => {
       let c = 0, g = 0, l = 0;
-      const u = d > 0, w = d < s, f = u && w;
-      if (u && (c = -o, g = -n, l = a), w) {
+      const u = d > 0, p = d < s, y = u && p;
+      if (u && (c = -o, g = -n, l = a), p) {
         const V = r[d + 1];
         o = V.x - h.x, n = V.y - h.y, a = Math.sqrt(o * o + n * n);
       }
-      const S = a !== 0 ? Math.min((f ? e : 0) / a, d < s - 1 ? 0.5 : 1) : 0, b = f ? { x: h.x + o * S, y: h.y + n * S } : h, P = l !== 0 ? Math.min((f ? e : 0) / l, d > 1 ? 0.5 : 1) : 0, L = f ? { x: h.x + c * P, y: h.y + g * P } : h;
-      d > 0 && t.push(`L ${L.x} ${L.y}`), f && t.push(
+      const x = a !== 0 ? Math.min((y ? e : 0) / a, d < s - 1 ? 0.5 : 1) : 0, b = y ? { x: h.x + o * x, y: h.y + n * x } : h, C = l !== 0 ? Math.min((y ? e : 0) / l, d > 1 ? 0.5 : 1) : 0, L = y ? { x: h.x + c * C, y: h.y + g * C } : h;
+      d > 0 && t.push(`L ${L.x} ${L.y}`), y && t.push(
         `C ${h.x} ${h.y} ${h.x} ${h.y} ${b.x} ${b.y}`
       );
     });
   }
   return t.join(" ");
 };
-class it {
+class lt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
@@ -1082,10 +936,10 @@ class it {
     const t = this.params.to;
     this.midpoint = { x: t.x / 2, y: t.y / 2 };
     const s = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, o = this.params.hasTargetArrow ? m(
+      w
+    ) : w, o = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1093,9 +947,9 @@ class it {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, n = this.params.arrowLength + this.params.arrowOffset, a = n - this.params.roundness, h = m(
-      { x: a, y: p.y },
+      { x: a, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), d = m(
       { x: this.params.to.x - a, y: this.params.to.y },
       this.params.targetDirection,
@@ -1103,26 +957,26 @@ class it {
     ), c = Math.max((h.x + d.x) / 2, n), g = this.params.to.y / 2, l = {
       x: this.params.flipX > 0 ? c : -n,
       y: h.y
-    }, u = { x: l.x, y: g }, w = {
+    }, u = { x: l.x, y: g }, p = {
       x: this.params.flipX > 0 ? this.params.to.x - c : this.params.to.x + n,
       y: d.y
-    }, f = { x: w.x, y: g };
+    }, y = { x: p.x, y: g };
     this.path = M(
-      [s, h, l, u, f, w, d, o],
+      [s, h, l, u, y, p, d, o],
       this.params.roundness
     );
   }
 }
-class nt {
+class gt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, s = this.params.hasTargetArrow ? m(
+      w
+    ) : w, s = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1130,21 +984,21 @@ class nt {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, o = this.params.arrowLength + this.params.arrowOffset, n = m(
-      { x: o, y: p.y },
+      { x: o, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), a = Math.cos(this.params.detourDirection) * this.params.detourDistance, h = Math.sin(this.params.detourDirection) * this.params.detourDistance, d = a * this.params.flipX, c = h * this.params.flipY, g = { x: n.x + d, y: n.y + c }, l = m(
       { x: this.params.to.x - o, y: this.params.to.y },
       this.params.targetDirection,
       this.params.to
-    ), u = { x: l.x + d, y: l.y + c }, w = { x: (g.x + u.x) / 2, y: (g.y + u.y) / 2 };
-    this.midpoint = k(w, e.flipX, e.flipY, e.to), this.path = M(
+    ), u = { x: l.x + d, y: l.y + c }, p = { x: (g.x + u.x) / 2, y: (g.y + u.y) / 2 };
+    this.midpoint = z(p, e.flipX, e.flipY, e.to), this.path = M(
       [t, n, g, u, l, s],
       this.params.roundness
     );
   }
 }
-class at {
+class ut {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
@@ -1152,10 +1006,10 @@ class at {
     const t = this.params.to;
     this.midpoint = { x: t.x / 2, y: t.y / 2 };
     const s = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, o = this.params.hasTargetArrow ? m(
+      w
+    ) : w, o = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1163,9 +1017,9 @@ class at {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, n = this.params.arrowLength + this.params.arrowOffset, a = m(
-      { x: n, y: p.y },
+      { x: n, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), h = m(
       { x: this.params.to.x - n, y: this.params.to.y },
       this.params.targetDirection,
@@ -1174,7 +1028,7 @@ class at {
     this.path = M([s, a, h, o], this.params.roundness);
   }
 }
-class ht {
+class pt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
@@ -1182,10 +1036,10 @@ class ht {
     const t = this.params.to;
     this.midpoint = { x: t.x / 2, y: t.y / 2 };
     const s = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, o = this.params.hasTargetArrow ? m(
+      w
+    ) : w, o = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1193,9 +1047,9 @@ class ht {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, n = this.params.arrowLength + this.params.arrowOffset, a = n - this.params.roundness, h = m(
-      { x: a, y: p.y },
+      { x: a, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), d = m(
       { x: this.params.to.x - a, y: this.params.to.y },
       this.params.targetDirection,
@@ -1203,58 +1057,58 @@ class ht {
     ), c = Math.max((h.y + d.y) / 2, n), g = this.params.to.x / 2, l = {
       x: h.x,
       y: this.params.flipY > 0 ? c : -n
-    }, u = { x: g, y: l.y }, w = {
+    }, u = { x: g, y: l.y }, p = {
       x: d.x,
       y: this.params.flipY > 0 ? this.params.to.y - c : this.params.to.y + n
-    }, f = { x: g, y: w.y };
+    }, y = { x: g, y: p.y };
     this.path = M(
-      [s, h, l, u, f, w, d, o],
+      [s, h, l, u, y, p, d, o],
       this.params.roundness
     );
   }
 }
-class _ {
+class J {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.arrowOffset, s = this.params.side, o = this.params.arrowLength + t, n = o + 2 * s, h = [
-      { x: this.params.arrowLength, y: p.y },
-      { x: o, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
+      { x: o, y: w.y },
       { x: o, y: this.params.side },
       { x: n, y: this.params.side },
       { x: n, y: -this.params.side },
       { x: o, y: -this.params.side },
-      { x: o, y: p.y },
-      { x: this.params.arrowLength, y: p.y }
+      { x: o, y: w.y },
+      { x: this.params.arrowLength, y: w.y }
     ].map(
-      (c) => m(c, this.params.sourceDirection, p)
-    ), d = `M ${p.x} ${p.y} L ${h[0].x} ${h[0].y} `;
+      (c) => m(c, this.params.sourceDirection, w)
+    ), d = `M ${w.x} ${w.y} L ${h[0].x} ${h[0].y} `;
     this.path = `${this.params.hasSourceArrow || this.params.hasTargetArrow ? "" : d}${M(h, this.params.roundness)}`, this.midpoint = { x: (h[3].x + h[4].x) / 2, y: (h[3].y + h[4].y) / 2 };
   }
 }
-class dt {
+class wt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.smallRadius, s = this.params.radius, o = t + s, n = t * s / o, a = Math.sqrt(o * o - t * t), h = a * t / o, d = a + s + this.params.arrowLength, c = this.params.arrowLength + h, l = [
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       { x: c, y: n },
       { x: c, y: -n },
       { x: d, y: 0 }
     ].map(
-      (f) => m(f, this.params.sourceDirection, p)
+      (y) => m(y, this.params.sourceDirection, w)
     ), u = [
       `M ${l[0].x} ${l[0].y}`,
       `A ${t} ${t} 0 0 1 ${l[1].x} ${l[1].y}`,
       `A ${s} ${s} 0 1 0 ${l[2].x} ${l[2].y}`,
       `A ${t} ${t} 0 0 1 ${l[0].x} ${l[0].y}`
-    ].join(" "), w = `M 0 0 L ${l[0].x} ${l[0].y} `;
-    this.path = `${this.params.hasSourceArrow || this.params.hasTargetArrow ? "" : w}${u}`, this.midpoint = l[3];
+    ].join(" "), p = `M 0 0 L ${l[0].x} ${l[0].y} `;
+    this.path = `${this.params.hasSourceArrow || this.params.hasTargetArrow ? "" : p}${u}`, this.midpoint = l[3];
   }
 }
-class ct {
+class yt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
@@ -1273,7 +1127,7 @@ class ct {
       offset: this.params.sourceOffset,
       hasArrow: this.params.hasSourceArrow,
       flip: 1,
-      shift: p
+      shift: w
     }), n = this.createDirectLinePoint({
       offset: this.params.targetOffset,
       hasArrow: this.params.hasTargetArrow,
@@ -1290,16 +1144,16 @@ class ct {
     };
   }
 }
-class lt {
+class ft {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, s = this.params.hasTargetArrow ? m(
+      w
+    ) : w, s = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1307,9 +1161,9 @@ class lt {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, o = this.params.arrowLength + this.params.arrowOffset, n = m(
-      { x: o, y: p.y },
+      { x: o, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), a = m(
       { x: this.params.to.x - o, y: this.params.to.y },
       this.params.targetDirection,
@@ -1318,7 +1172,7 @@ class lt {
       x: (n.x + a.x) / 2,
       y: g
     };
-    this.midpoint = k(l, e.flipX, e.flipY, e.to), this.path = M(
+    this.midpoint = z(l, e.flipX, e.flipY, e.to), this.path = M(
       [
         t,
         n,
@@ -1331,16 +1185,16 @@ class lt {
     );
   }
 }
-class gt {
+class mt {
   constructor(e) {
     i(this, "path");
     i(this, "midpoint");
     this.params = e;
     const t = this.params.hasSourceArrow ? m(
-      { x: this.params.arrowLength, y: p.y },
+      { x: this.params.arrowLength, y: w.y },
       this.params.sourceDirection,
-      p
-    ) : p, s = this.params.hasTargetArrow ? m(
+      w
+    ) : w, s = this.params.hasTargetArrow ? m(
       {
         x: this.params.to.x - this.params.arrowLength,
         y: this.params.to.y
@@ -1348,9 +1202,9 @@ class gt {
       this.params.targetDirection,
       this.params.to
     ) : this.params.to, o = this.params.arrowLength + this.params.arrowOffset, n = m(
-      { x: o, y: p.y },
+      { x: o, y: w.y },
       this.params.sourceDirection,
-      p
+      w
     ), a = m(
       { x: this.params.to.x - o, y: this.params.to.y },
       this.params.targetDirection,
@@ -1359,7 +1213,7 @@ class gt {
       x: g,
       y: (n.y + a.y) / 2
     };
-    this.midpoint = k(l, e.flipX, e.flipY, e.to), this.path = M(
+    this.midpoint = z(l, e.flipX, e.flipY, e.to), this.path = M(
       [
         t,
         n,
@@ -1372,7 +1226,7 @@ class gt {
     );
   }
 }
-const y = Object.freeze({
+const f = Object.freeze({
   color: "#777777",
   width: 1,
   arrowLength: 20,
@@ -1394,8 +1248,8 @@ const y = Object.freeze({
   curvature: 90,
   interactiveWidth: 10,
   preOffset: 0
-}), we = (r, e, t) => ({ x: e * Math.cos(r), y: t * Math.sin(r) });
-class H {
+}), ye = (r, e, t) => ({ x: e * Math.cos(r), y: t * Math.sin(r) });
+class k {
   constructor(e) {
     i(this, "svg");
     i(this, "group", De());
@@ -1405,19 +1259,19 @@ class H {
     i(this, "onAfterRender");
     i(this, "afterRenderEmitter");
     i(this, "arrowRenderer");
-    this.params = e, [this.afterRenderEmitter, this.onAfterRender] = E(), this.arrowRenderer = this.params.arrowRenderer, this.svg = Ce(e.color), this.svg.appendChild(this.group), this.line = Me(e.width), this.group.appendChild(this.line), e.hasSourceArrow && (this.sourceArrow = W(), this.group.appendChild(this.sourceArrow)), e.hasTargetArrow && (this.targetArrow = W(), this.group.appendChild(this.targetArrow));
+    this.params = e, [this.afterRenderEmitter, this.onAfterRender] = S(), this.arrowRenderer = this.params.arrowRenderer, this.svg = Me(e.color), this.svg.appendChild(this.group), this.line = Re(e.width), this.group.appendChild(this.line), e.hasSourceArrow && (this.sourceArrow = W(), this.group.appendChild(this.sourceArrow)), e.hasTargetArrow && (this.targetArrow = W(), this.group.appendChild(this.targetArrow));
   }
   render(e) {
     const { x: t, y: s, width: o, height: n, flipX: a, flipY: h } = Te(
       e.from,
       e.to
     );
-    Re(this.svg, { x: t, y: s, width: o, height: n }), this.group.style.transform = `scale(${a}, ${h})`;
-    const d = we(
+    Le(this.svg, { x: t, y: s, width: o, height: n }), this.group.style.transform = `scale(${a}, ${h})`;
+    const d = ye(
       e.from.direction,
       a,
       h
-    ), c = we(
+    ), c = ye(
       e.to.direction,
       a,
       h
@@ -1426,54 +1280,54 @@ class H {
       y: n
     };
     let l = { x: -c.x, y: -c.y }, u;
-    e.category === D.PortCycle ? (u = this.params.createCyclePath, l = d) : e.category === D.NodeCycle ? u = this.params.createDetourPath : u = this.params.createLinePath;
-    const w = u(
+    e.category === R.PortCycle ? (u = this.params.createCyclePath, l = d) : e.category === R.NodeCycle ? u = this.params.createDetourPath : u = this.params.createLinePath;
+    const p = u(
       d,
       c,
       g,
       a,
       h
     );
-    this.line.setAttribute("d", w.path);
-    let f = null;
-    this.sourceArrow && (f = this.arrowRenderer({
+    this.line.setAttribute("d", p.path);
+    let y = null;
+    this.sourceArrow && (y = this.arrowRenderer({
       direction: d,
-      shift: p,
+      shift: w,
       arrowLength: this.params.arrowLength
-    }), this.sourceArrow.setAttribute("d", f));
+    }), this.sourceArrow.setAttribute("d", y));
     let v = null;
     this.targetArrow && (v = this.arrowRenderer({
       direction: l,
       shift: g,
       arrowLength: this.params.arrowLength
     }), this.targetArrow.setAttribute("d", v)), this.afterRenderEmitter.emit({
-      edgePath: w,
-      sourceArrowPath: f,
+      edgePath: p,
+      sourceArrowPath: y,
       targetArrowPath: v
     });
   }
 }
-const ut = (r) => (e) => {
+const vt = (r) => (e) => {
   const s = [
-    p,
+    w,
     { x: e.arrowLength, y: r.radius },
     { x: e.arrowLength, y: -r.radius }
   ].map(
-    (h) => m(h, e.direction, p)
+    (h) => m(h, e.direction, w)
   ).map((h) => ({
     x: h.x + e.shift.x,
     y: h.y + e.shift.y
   })), o = `M ${s[0].x} ${s[0].y}`, n = `L ${s[1].x} ${s[1].y}`, a = `L ${s[2].x} ${s[2].y}`;
   return `${o} ${n} ${a} Z`;
-}, pt = (r) => (e) => {
-  const t = r.radius, s = e.arrowLength, o = (s * s + 2 * s * t) / (2 * t), n = o + t, a = s + t - t * (s + t) / n, h = t * o / n, c = [p, { x: a, y: -h }, { x: a, y: h }].map(
-    (f) => m(f, e.direction, p)
-  ).map((f) => ({
-    x: f.x + e.shift.x,
-    y: f.y + e.shift.y
-  })), g = `M ${c[0].x} ${c[0].y}`, l = `A ${o} ${o} 0 0 0 ${c[1].x} ${c[1].y}`, u = `A ${t} ${t} 0 0 0 ${c[2].x} ${c[2].y}`, w = `A ${o} ${o} 0 0 0 ${c[0].x} ${c[0].y}`;
-  return `${g} ${l} ${u} ${w}`;
-}, wt = (r) => (e) => {
+}, At = (r) => (e) => {
+  const t = r.radius, s = e.arrowLength, o = (s * s + 2 * s * t) / (2 * t), n = o + t, a = s + t - t * (s + t) / n, h = t * o / n, c = [w, { x: a, y: -h }, { x: a, y: h }].map(
+    (y) => m(y, e.direction, w)
+  ).map((y) => ({
+    x: y.x + e.shift.x,
+    y: y.y + e.shift.y
+  })), g = `M ${c[0].x} ${c[0].y}`, l = `A ${o} ${o} 0 0 0 ${c[1].x} ${c[1].y}`, u = `A ${t} ${t} 0 0 0 ${c[2].x} ${c[2].y}`, p = `A ${o} ${o} 0 0 0 ${c[0].x} ${c[0].y}`;
+  return `${g} ${l} ${u} ${p}`;
+}, xt = (r) => (e) => {
   const t = r.smallRadius, s = r.radius, o = m(
     {
       x: e.arrowLength,
@@ -1487,8 +1341,8 @@ const ut = (r) => (e) => {
       x: e.arrowLength + r.smallRadius,
       y: 0
     }
-  ), a = [p, { x: o.x, y: -o.y }, o].map(
-    (l) => m(l, e.direction, p)
+  ), a = [w, { x: o.x, y: -o.y }, o].map(
+    (l) => m(l, e.direction, w)
   ).map((l) => ({
     x: l.x + e.shift.x,
     y: l.y + e.shift.y
@@ -1499,22 +1353,22 @@ const ut = (r) => (e) => {
     return r;
   switch (r.type) {
     case "triangle":
-      return ut({
-        radius: r.radius ?? y.polygonArrowRadius
+      return vt({
+        radius: r.radius ?? f.polygonArrowRadius
       });
     case "arc":
-      return pt({
-        radius: r.radius ?? y.circleArrowRadius
+      return At({
+        radius: r.radius ?? f.circleArrowRadius
       });
     default:
-      return wt({
-        smallRadius: r.smallRadius ?? y.wedgeArrowSmallRadius,
-        angle: r.angle ?? y.wedgeArrowAngle,
-        radius: r.radius ?? y.wedgeArrowRadius
+      return xt({
+        smallRadius: r.smallRadius ?? f.wedgeArrowSmallRadius,
+        angle: r.angle ?? f.wedgeArrowAngle,
+        radius: r.radius ?? f.wedgeArrowRadius
       });
   }
 };
-class ft {
+class Et {
   constructor(e) {
     i(this, "svg");
     i(this, "group");
@@ -1531,7 +1385,7 @@ class ft {
     i(this, "hasSourceArrow");
     i(this, "hasTargetArrow");
     i(this, "pathShape");
-    i(this, "createCyclePath", (e) => new dt({
+    i(this, "createCyclePath", (e) => new wt({
       sourceDirection: e,
       radius: this.portCycleRadius,
       smallRadius: this.portCycleSmallRadius,
@@ -1539,7 +1393,7 @@ class ft {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createDetourPath", (e, t, s, o, n) => new ot({
+    i(this, "createDetourPath", (e, t, s, o, n) => new ct({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1552,7 +1406,7 @@ class ft {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createLinePath", (e, t, s) => new st({
+    i(this, "createLinePath", (e, t, s) => new dt({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1561,9 +1415,9 @@ class ft {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? y.arrowLength, this.curvature = (e == null ? void 0 : e.curvature) ?? y.curvature, this.portCycleRadius = (e == null ? void 0 : e.cycleRadius) ?? y.cycleRadius, this.portCycleSmallRadius = (e == null ? void 0 : e.smallCycleRadius) ?? y.smallCycleRadius, this.detourDirection = (e == null ? void 0 : e.detourDirection) ?? y.detourDirection, this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? y.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? y.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? y.hasTargetArrow, this.pathShape = new H({
-      color: (e == null ? void 0 : e.color) ?? y.color,
-      width: (e == null ? void 0 : e.width) ?? y.width,
+    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? f.arrowLength, this.curvature = (e == null ? void 0 : e.curvature) ?? f.curvature, this.portCycleRadius = (e == null ? void 0 : e.cycleRadius) ?? f.cycleRadius, this.portCycleSmallRadius = (e == null ? void 0 : e.smallCycleRadius) ?? f.smallCycleRadius, this.detourDirection = (e == null ? void 0 : e.detourDirection) ?? f.detourDirection, this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? f.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? f.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? f.hasTargetArrow, this.pathShape = new k({
+      color: (e == null ? void 0 : e.color) ?? f.color,
+      width: (e == null ? void 0 : e.width) ?? f.width,
       arrowRenderer: I((e == null ? void 0 : e.arrowRenderer) ?? {}),
       arrowLength: this.arrowLength,
       hasSourceArrow: this.hasSourceArrow,
@@ -1577,7 +1431,7 @@ class ft {
     this.pathShape.render(e);
   }
 }
-class yt {
+class St {
   constructor(e) {
     i(this, "svg");
     i(this, "group");
@@ -1593,7 +1447,7 @@ class yt {
     i(this, "hasSourceArrow");
     i(this, "hasTargetArrow");
     i(this, "pathShape");
-    i(this, "createCyclePath", (e) => new _({
+    i(this, "createCyclePath", (e) => new J({
       sourceDirection: e,
       arrowLength: this.arrowLength,
       side: this.cycleSquareSide,
@@ -1602,7 +1456,7 @@ class yt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createDetourPath", (e, t, s, o, n) => new lt({
+    i(this, "createDetourPath", (e, t, s, o, n) => new ft({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1615,7 +1469,7 @@ class yt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createLinePath", (e, t, s, o) => new it({
+    i(this, "createLinePath", (e, t, s, o) => new lt({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1626,15 +1480,15 @@ class yt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? y.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? y.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? y.cycleSquareSide;
-    const t = (e == null ? void 0 : e.roundness) ?? y.roundness;
+    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? f.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? f.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? f.cycleSquareSide;
+    const t = (e == null ? void 0 : e.roundness) ?? f.roundness;
     this.roundness = Math.min(
       t,
       this.arrowOffset,
       this.cycleSquareSide / 2
-    ), this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? y.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? y.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? y.hasTargetArrow, this.pathShape = new H({
-      color: (e == null ? void 0 : e.color) ?? y.color,
-      width: (e == null ? void 0 : e.width) ?? y.width,
+    ), this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? f.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? f.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? f.hasTargetArrow, this.pathShape = new k({
+      color: (e == null ? void 0 : e.color) ?? f.color,
+      width: (e == null ? void 0 : e.width) ?? f.width,
       arrowRenderer: I((e == null ? void 0 : e.arrowRenderer) ?? {}),
       arrowLength: this.arrowLength,
       hasSourceArrow: this.hasSourceArrow,
@@ -1648,7 +1502,7 @@ class yt {
     this.pathShape.render(e);
   }
 }
-class mt {
+class bt {
   constructor(e) {
     i(this, "svg");
     i(this, "group");
@@ -1665,7 +1519,7 @@ class mt {
     i(this, "hasSourceArrow");
     i(this, "hasTargetArrow");
     i(this, "pathShape");
-    i(this, "createCyclePath", (e) => new _({
+    i(this, "createCyclePath", (e) => new J({
       sourceDirection: e,
       arrowLength: this.arrowLength,
       side: this.cycleSquareSide,
@@ -1674,7 +1528,7 @@ class mt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createDetourPath", (e, t, s, o, n) => new nt({
+    i(this, "createDetourPath", (e, t, s, o, n) => new gt({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1688,7 +1542,7 @@ class mt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createLinePath", (e, t, s) => new at({
+    i(this, "createLinePath", (e, t, s) => new ut({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1698,15 +1552,15 @@ class mt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? y.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? y.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? y.cycleSquareSide;
-    const t = (e == null ? void 0 : e.roundness) ?? y.roundness;
+    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? f.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? f.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? f.cycleSquareSide;
+    const t = (e == null ? void 0 : e.roundness) ?? f.roundness;
     this.roundness = Math.min(
       t,
       this.arrowOffset,
       this.cycleSquareSide / 2
-    ), this.detourDirection = (e == null ? void 0 : e.detourDirection) ?? y.detourDirection, this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? y.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? y.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? y.hasTargetArrow, this.pathShape = new H({
-      color: (e == null ? void 0 : e.color) ?? y.color,
-      width: (e == null ? void 0 : e.width) ?? y.width,
+    ), this.detourDirection = (e == null ? void 0 : e.detourDirection) ?? f.detourDirection, this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? f.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? f.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? f.hasTargetArrow, this.pathShape = new k({
+      color: (e == null ? void 0 : e.color) ?? f.color,
+      width: (e == null ? void 0 : e.width) ?? f.width,
       arrowRenderer: I((e == null ? void 0 : e.arrowRenderer) ?? {}),
       arrowLength: this.arrowLength,
       hasSourceArrow: this.hasSourceArrow,
@@ -1720,7 +1574,7 @@ class mt {
     this.pathShape.render(e);
   }
 }
-class vt {
+class Pt {
   constructor(e) {
     i(this, "svg");
     i(this, "group");
@@ -1736,7 +1590,7 @@ class vt {
     i(this, "hasSourceArrow");
     i(this, "hasTargetArrow");
     i(this, "pathShape");
-    i(this, "createCyclePath", (e) => new _({
+    i(this, "createCyclePath", (e) => new J({
       sourceDirection: e,
       arrowLength: this.arrowLength,
       side: this.cycleSquareSide,
@@ -1745,7 +1599,7 @@ class vt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createDetourPath", (e, t, s, o, n) => new gt({
+    i(this, "createDetourPath", (e, t, s, o, n) => new mt({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1758,7 +1612,7 @@ class vt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    i(this, "createLinePath", (e, t, s, o, n) => new ht({
+    i(this, "createLinePath", (e, t, s, o, n) => new pt({
       to: s,
       sourceDirection: e,
       targetDirection: t,
@@ -1769,15 +1623,15 @@ class vt {
       hasSourceArrow: this.hasSourceArrow,
       hasTargetArrow: this.hasTargetArrow
     }));
-    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? y.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? y.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? y.cycleSquareSide;
-    const t = (e == null ? void 0 : e.roundness) ?? y.roundness;
+    this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? f.arrowLength, this.arrowOffset = (e == null ? void 0 : e.arrowOffset) ?? f.arrowOffset, this.cycleSquareSide = (e == null ? void 0 : e.cycleSquareSide) ?? f.cycleSquareSide;
+    const t = (e == null ? void 0 : e.roundness) ?? f.roundness;
     this.roundness = Math.min(
       t,
       this.arrowOffset,
       this.cycleSquareSide / 2
-    ), this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? y.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? y.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? y.hasTargetArrow, this.pathShape = new H({
-      color: (e == null ? void 0 : e.color) ?? y.color,
-      width: (e == null ? void 0 : e.width) ?? y.width,
+    ), this.detourDistance = (e == null ? void 0 : e.detourDistance) ?? f.detourDistance, this.hasSourceArrow = (e == null ? void 0 : e.hasSourceArrow) ?? f.hasSourceArrow, this.hasTargetArrow = (e == null ? void 0 : e.hasTargetArrow) ?? f.hasTargetArrow, this.pathShape = new k({
+      color: (e == null ? void 0 : e.color) ?? f.color,
+      width: (e == null ? void 0 : e.width) ?? f.width,
       arrowRenderer: I((e == null ? void 0 : e.arrowRenderer) ?? {}),
       arrowLength: this.arrowLength,
       hasSourceArrow: this.hasSourceArrow,
@@ -1791,7 +1645,7 @@ class vt {
     this.pathShape.render(e);
   }
 }
-class Le {
+class Ve {
   constructor(e) {
     i(this, "svg");
     i(this, "group", De());
@@ -1806,15 +1660,15 @@ class Le {
     i(this, "onAfterRender");
     i(this, "afterRenderEmitter");
     i(this, "arrowRenderer");
-    [this.afterRenderEmitter, this.onAfterRender] = E(), this.color = (e == null ? void 0 : e.color) ?? y.color, this.width = (e == null ? void 0 : e.width) ?? y.width, this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? y.arrowLength, this.arrowRenderer = I((e == null ? void 0 : e.arrowRenderer) ?? {}), this.sourceOffset = (e == null ? void 0 : e.sourceOffset) ?? y.preOffset, this.targetOffset = (e == null ? void 0 : e.targetOffset) ?? y.preOffset, this.svg = Ce(this.color), this.svg.appendChild(this.group), this.line = Me(this.width), this.group.appendChild(this.line), e != null && e.hasSourceArrow && (this.sourceArrow = W(), this.group.appendChild(this.sourceArrow)), e != null && e.hasTargetArrow && (this.targetArrow = W(), this.group.appendChild(this.targetArrow));
+    [this.afterRenderEmitter, this.onAfterRender] = S(), this.color = (e == null ? void 0 : e.color) ?? f.color, this.width = (e == null ? void 0 : e.width) ?? f.width, this.arrowLength = (e == null ? void 0 : e.arrowLength) ?? f.arrowLength, this.arrowRenderer = I((e == null ? void 0 : e.arrowRenderer) ?? {}), this.sourceOffset = (e == null ? void 0 : e.sourceOffset) ?? f.preOffset, this.targetOffset = (e == null ? void 0 : e.targetOffset) ?? f.preOffset, this.svg = Me(this.color), this.svg.appendChild(this.group), this.line = Re(this.width), this.group.appendChild(this.line), e != null && e.hasSourceArrow && (this.sourceArrow = W(), this.group.appendChild(this.sourceArrow)), e != null && e.hasTargetArrow && (this.targetArrow = W(), this.group.appendChild(this.targetArrow));
   }
   render(e) {
     const { x: t, y: s, width: o, height: n, flipX: a, flipY: h } = Te(
       e.from,
       e.to
     );
-    Re(this.svg, { x: t, y: s, width: o, height: n }), this.group.style.transform = `scale(${a}, ${h})`;
-    const d = { x: o, y: n }, c = new ct({
+    Le(this.svg, { x: t, y: s, width: o, height: n }), this.group.style.transform = `scale(${a}, ${h})`;
+    const d = { x: o, y: n }, c = new yt({
       to: d,
       sourceOffset: this.sourceOffset,
       targetOffset: this.targetOffset,
@@ -1828,31 +1682,31 @@ class Le {
     if (u === 0)
       this.sourceArrow !== null && (g = "", this.sourceArrow.setAttribute("d", g)), this.targetArrow !== null && (l = "", this.targetArrow.setAttribute("d", l));
     else {
-      const w = {
+      const p = {
         x: d.x / u,
         y: d.y / u
       };
       if (this.sourceArrow) {
-        const f = {
-          x: w.x * this.sourceOffset,
-          y: w.y * this.sourceOffset
+        const y = {
+          x: p.x * this.sourceOffset,
+          y: p.y * this.sourceOffset
         };
         g = this.arrowRenderer({
-          direction: w,
-          shift: f,
+          direction: p,
+          shift: y,
           arrowLength: this.arrowLength
         }), this.sourceArrow.setAttribute("d", g);
       }
       if (this.targetArrow) {
-        const f = {
-          x: w.x * this.targetOffset,
-          y: w.y * this.targetOffset
+        const y = {
+          x: p.x * this.targetOffset,
+          y: p.y * this.targetOffset
         };
         l = this.arrowRenderer({
-          direction: { x: -w.x, y: -w.y },
+          direction: { x: -p.x, y: -p.y },
           shift: {
-            x: d.x - f.x,
-            y: d.y - f.y
+            x: d.x - y.x,
+            y: d.y - y.y
           },
           arrowLength: this.arrowLength
         }), this.targetArrow.setAttribute("d", l);
@@ -1865,40 +1719,40 @@ class Le {
     });
   }
 }
-const At = () => {
+const Ct = () => {
   const r = document.createElementNS("http://www.w3.org/2000/svg", "g");
   return r.style.pointerEvents = "auto", r.style.cursor = "pointer", r;
-}, xt = (r) => {
+}, Nt = (r) => {
   const e = document.createElementNS("http://www.w3.org/2000/svg", "path");
   return e.setAttribute("stroke", "transparent"), e.setAttribute("stroke-width", `${r}`), e.setAttribute("fill", "none"), e.setAttribute("stroke-linecap", "round"), e;
 }, fe = (r) => {
   const e = document.createElementNS("http://www.w3.org/2000/svg", "path");
   return e.setAttribute("stroke-linejoin", "round"), e.setAttribute("stroke-width", `${r}`), e.setAttribute("fill", "transparent"), e.setAttribute("stroke", "transparent"), e;
 };
-class Et extends Error {
+class Tt extends Error {
   constructor(e) {
     super(e), this.name = "InteractiveEdgeError";
   }
 }
-class Ve {
+class Fe {
   constructor(e, t) {
     i(this, "svg");
     i(this, "group");
     i(this, "line");
     i(this, "sourceArrow");
     i(this, "targetArrow");
-    i(this, "handle", At());
+    i(this, "handle", Ct());
     i(this, "onAfterRender");
     i(this, "interactiveLine");
     i(this, "interactiveSourceArrow", null);
     i(this, "interactiveTargetArrow", null);
-    if (this.baseEdge = e, e instanceof Ve)
-      throw new Et(
+    if (this.baseEdge = e, e instanceof Fe)
+      throw new Tt(
         "interactive edge can be configured only once"
       );
     this.svg = this.baseEdge.svg, this.group = this.baseEdge.group, this.line = this.baseEdge.line, this.sourceArrow = this.baseEdge.sourceArrow, this.targetArrow = this.baseEdge.targetArrow, this.onAfterRender = this.baseEdge.onAfterRender;
-    const s = (t == null ? void 0 : t.distance) ?? y.interactiveWidth;
-    this.interactiveLine = xt(s), this.handle.appendChild(this.interactiveLine), this.sourceArrow && (this.interactiveSourceArrow = fe(s), this.handle.appendChild(this.interactiveSourceArrow)), this.targetArrow && (this.interactiveTargetArrow = fe(s), this.handle.appendChild(this.interactiveTargetArrow)), this.group.appendChild(this.handle), this.baseEdge.onAfterRender.subscribe((o) => {
+    const s = (t == null ? void 0 : t.distance) ?? f.interactiveWidth;
+    this.interactiveLine = Nt(s), this.handle.appendChild(this.interactiveLine), this.sourceArrow && (this.interactiveSourceArrow = fe(s), this.handle.appendChild(this.interactiveSourceArrow)), this.targetArrow && (this.interactiveTargetArrow = fe(s), this.handle.appendChild(this.interactiveTargetArrow)), this.group.appendChild(this.handle), this.baseEdge.onAfterRender.subscribe((o) => {
       this.interactiveLine.setAttribute("d", o.edgePath.path), this.interactiveSourceArrow && this.interactiveSourceArrow.setAttribute("d", o.sourceArrowPath), this.interactiveTargetArrow && this.interactiveTargetArrow.setAttribute("d", o.targetArrowPath);
     });
   }
@@ -1906,7 +1760,7 @@ class Ve {
     this.baseEdge.render(e);
   }
 }
-class yr {
+class Cr {
   constructor(e, t) {
     i(this, "group");
     i(this, "line");
@@ -1923,7 +1777,7 @@ class yr {
     this.baseShape.render(e);
   }
 }
-class Fe {
+class Ie {
   constructor(e) {
     i(this, "onAfterNodeAdded");
     i(this, "onAfterNodeUpdated");
@@ -2019,7 +1873,165 @@ class Fe {
     return this.graphStore.getNodeAdjacentEdgeIds(e);
   }
 }
-class Ie {
+class X {
+  constructor(e) {
+    i(this, "counter", 0);
+    this.checkExists = e;
+  }
+  create(e) {
+    if (e !== void 0)
+      return e;
+    for (; this.checkExists(this.counter); )
+      this.counter++;
+    return this.counter;
+  }
+  reset() {
+    this.counter = 0;
+  }
+}
+class Be {
+  constructor(e, t, s) {
+    i(this, "nodeIdGenerator", new X(
+      (e) => this.graphStore.hasNode(e)
+    ));
+    i(this, "portIdGenerator", new X(
+      (e) => this.graphStore.hasPort(e)
+    ));
+    i(this, "edgeIdGenerator", new X(
+      (e) => this.graphStore.hasEdge(e)
+    ));
+    i(this, "onAfterNodeAdded", (e) => {
+      this.htmlView.attachNode(e);
+    });
+    i(this, "onAfterNodeUpdated", (e) => {
+      this.htmlView.updateNodePosition(e), this.graphStore.getNodeAdjacentEdgeIds(e).forEach((t) => {
+        this.htmlView.renderEdge(t);
+      });
+    });
+    i(this, "onAfterNodePriorityUpdated", (e) => {
+      this.htmlView.updateNodePriority(e);
+    });
+    i(this, "onBeforeNodeRemoved", (e) => {
+      this.graphStore.getNodePortIds(e).forEach((t) => {
+        this.unmarkPort(t);
+      }), this.htmlView.detachNode(e);
+    });
+    i(this, "onAfterPortUpdated", (e) => {
+      this.graphStore.getPortAdjacentEdgeIds(e).forEach((t) => {
+        this.htmlView.renderEdge(t);
+      });
+    });
+    i(this, "onBeforePortUnmarked", (e) => {
+      this.graphStore.getPortAdjacentEdgeIds(e).forEach((t) => {
+        this.removeEdge(t);
+      });
+    });
+    i(this, "onAfterEdgeAdded", (e) => {
+      this.htmlView.attachEdge(e);
+    });
+    i(this, "onAfterEdgeShapeUpdated", (e) => {
+      this.htmlView.updateEdgeShape(e);
+    });
+    i(this, "onAfterEdgeUpdated", (e) => {
+      this.htmlView.renderEdge(e);
+    });
+    i(this, "onAfterEdgePriorityUpdated", (e) => {
+      this.htmlView.updateEdgePriority(e);
+    });
+    i(this, "onBeforeEdgeRemoved", (e) => {
+      this.htmlView.detachEdge(e);
+    });
+    i(this, "onBeforeClear", () => {
+      this.nodeIdGenerator.reset(), this.portIdGenerator.reset(), this.edgeIdGenerator.reset(), this.htmlView.clear();
+    });
+    this.graphStore = e, this.htmlView = t, this.params = s, this.graphStore.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.graphStore.onAfterNodeUpdated.subscribe(this.onAfterNodeUpdated), this.graphStore.onAfterNodePriorityUpdated.subscribe(
+      this.onAfterNodePriorityUpdated
+    ), this.graphStore.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.graphStore.onAfterPortUpdated.subscribe(this.onAfterPortUpdated), this.graphStore.onBeforePortRemoved.subscribe(this.onBeforePortUnmarked), this.graphStore.onAfterEdgeAdded.subscribe(this.onAfterEdgeAdded), this.graphStore.onAfterEdgeShapeUpdated.subscribe(
+      this.onAfterEdgeShapeUpdated
+    ), this.graphStore.onAfterEdgeUpdated.subscribe(this.onAfterEdgeUpdated), this.graphStore.onAfterEdgePriorityUpdated.subscribe(
+      this.onAfterEdgePriorityUpdated
+    ), this.graphStore.onBeforeEdgeRemoved.subscribe(this.onBeforeEdgeRemoved), this.graphStore.onBeforeClear.subscribe(this.onBeforeClear);
+  }
+  addNode(e) {
+    const t = this.nodeIdGenerator.create(e.id);
+    if (this.graphStore.addNode({
+      id: t,
+      element: e.element,
+      x: e.x ?? null,
+      y: e.y ?? null,
+      centerFn: e.centerFn ?? this.params.nodes.centerFn,
+      priority: e.priority ?? this.params.nodes.priorityFn()
+    }), e.ports !== void 0)
+      for (const s of e.ports)
+        this.markPort({
+          id: s.id,
+          element: s.element,
+          nodeId: t,
+          direction: s.direction
+        });
+  }
+  updateNode(e, t) {
+    this.graphStore.updateNode(e, t ?? {});
+  }
+  removeNode(e) {
+    this.graphStore.removeNode(e);
+  }
+  markPort(e) {
+    const t = this.portIdGenerator.create(e.id);
+    this.graphStore.addPort({
+      id: t,
+      element: e.element,
+      nodeId: e.nodeId,
+      direction: e.direction ?? this.params.ports.direction
+    });
+  }
+  updatePort(e, t) {
+    this.graphStore.updatePort(e, t ?? {});
+  }
+  unmarkPort(e) {
+    this.graphStore.removePort(e);
+  }
+  addEdge(e) {
+    const t = this.edgeIdGenerator.create(e.id);
+    this.graphStore.addEdge({
+      id: t,
+      from: e.from,
+      to: e.to,
+      shape: e.shape ?? this.params.edges.shapeFactory(t),
+      priority: e.priority ?? this.params.edges.priorityFn()
+    });
+  }
+  updateEdge(e, t) {
+    this.graphStore.updateEdge(e, t ?? {});
+  }
+  removeEdge(e) {
+    this.graphStore.removeEdge(e);
+  }
+  clear() {
+    this.graphStore.clear();
+  }
+  destroy() {
+    this.graphStore.onAfterNodeAdded.unsubscribe(this.onAfterNodeAdded), this.graphStore.onAfterNodeUpdated.unsubscribe(this.onAfterNodeUpdated), this.graphStore.onAfterNodePriorityUpdated.unsubscribe(
+      this.onAfterNodePriorityUpdated
+    ), this.graphStore.onBeforeNodeRemoved.unsubscribe(this.onBeforeNodeRemoved), this.graphStore.onAfterPortUpdated.unsubscribe(this.onAfterPortUpdated), this.graphStore.onBeforePortRemoved.unsubscribe(this.onBeforePortUnmarked), this.graphStore.onAfterEdgeAdded.unsubscribe(this.onAfterEdgeAdded), this.graphStore.onAfterEdgeShapeUpdated.unsubscribe(
+      this.onAfterEdgeShapeUpdated
+    ), this.graphStore.onAfterEdgeUpdated.unsubscribe(this.onAfterEdgeUpdated), this.graphStore.onAfterEdgePriorityUpdated.unsubscribe(
+      this.onAfterEdgePriorityUpdated
+    ), this.graphStore.onBeforeEdgeRemoved.unsubscribe(this.onBeforeEdgeRemoved), this.graphStore.onBeforeClear.unsubscribe(this.onBeforeClear), this.htmlView.destroy();
+  }
+}
+const Mt = (r) => {
+  setTimeout(() => {
+    r();
+  });
+}, Rt = (r) => {
+  queueMicrotask(() => {
+    r();
+  });
+}, _ = (r) => {
+  r();
+};
+class $e {
   constructor(e) {
     i(this, "onBeforeUpdated");
     i(this, "onAfterUpdated");
@@ -2042,30 +2054,109 @@ class Ie {
     return this.viewportStore.createViewportCoords(e);
   }
 }
-const Be = (r, e) => {
-  const t = new Se(), s = new Fe(t), o = new Ie(e), n = new xe(t, e, r), a = {
+const Dt = (r, e) => Symbol.iterator in r ? {
+  minContentScale: e.focus.minContentScale,
+  nodes: r,
+  contentOffset: e.focus.contentOffset
+} : {
+  minContentScale: r.minContentScale ?? e.focus.minContentScale,
+  nodes: r.nodes ?? [],
+  contentOffset: r.contentOffset ?? e.focus.contentOffset
+}, Ue = (r, e, t) => ({
+  scale: r.scale,
+  x: r.x + r.scale * e,
+  y: r.y + r.scale * t
+}), Oe = (r, e, t, s) => ({
+  scale: r.scale * e,
+  x: r.scale * (1 - e) * t + r.x,
+  y: r.scale * (1 - e) * s + r.y
+});
+class We {
+  constructor(e, t, s) {
+    this.graphStore = e, this.viewportStore = t, this.params = s;
+  }
+  patchViewportMatrix(e) {
+    this.viewportStore.patchViewportMatrix(e);
+  }
+  patchContentMatrix(e) {
+    this.viewportStore.patchContentMatrix(e);
+  }
+  center(e, t) {
+    const { width: s, height: o } = this.viewportStore.getDimensions(), n = { x: s / 2, y: o / 2 }, a = this.viewportStore.getViewportMatrix(), h = this.viewportStore.createViewportCoords(e), d = h.x - n.x, c = h.y - n.y;
+    let g = Ue(a, d, c);
+    const l = t == null ? void 0 : t.contentScale;
+    if (l !== void 0) {
+      const u = 1 / l;
+      g = Oe(
+        g,
+        u / a.scale,
+        n.x,
+        n.y
+      );
+    }
+    this.viewportStore.patchViewportMatrix(g);
+  }
+  focus(e) {
+    const t = Dt(e ?? {}, this.params);
+    this.params.focus.schedule(() => {
+      this.navigate(t);
+    });
+  }
+  destroy() {
+    this.viewportStore.destroy();
+  }
+  navigate(e) {
+    let t = 1 / 0, s = -1 / 0, o = 1 / 0, n = -1 / 0, a = 0;
+    const h = /* @__PURE__ */ new Set();
+    for (const d of e.nodes)
+      h.add(d);
+    if (this.graphStore.getAllNodeIds().forEach((d) => {
+      const { payload: c } = this.graphStore.getNode(d);
+      c.x !== null && c.y !== null && (h.size === 0 || h.has(d)) && (t = Math.min(c.x, t), s = Math.max(c.x, s), o = Math.min(c.y, o), n = Math.max(c.y, n), a++);
+    }), a > 0) {
+      t -= e.contentOffset, o -= e.contentOffset, s += e.contentOffset, n += e.contentOffset;
+      const d = {
+        x: (t + s) / 2,
+        y: (o + n) / 2
+      }, c = (s - t) / 2, g = (n - o) / 2, { width: l, height: u } = this.viewportStore.getDimensions(), p = l / 2, y = u / 2, v = Math.max(
+        c / p,
+        g / y
+      ), { scale: x } = this.viewportStore.getContentMatrix(), b = v > 1 ? x / v : x, P = Math.max(b, e.minContentScale);
+      this.center(d, { contentScale: P });
+    }
+  }
+}
+const ze = (r, e) => {
+  const t = new be(), s = new Ie(t), o = new $e(e), n = new Ee(t, e, r), a = {
     nodes: {
       centerFn: Ne,
       priorityFn: () => 0
     },
     edges: {
-      shapeFactory: () => new Le(),
+      shapeFactory: () => new Ve(),
       priorityFn: () => 0
     },
     ports: {
       direction: 0
     }
-  };
-  return new Ee(
-    s,
-    o,
+  }, h = new Be(
     t,
-    e,
     n,
     a
+  ), d = {
+    focus: {
+      contentOffset: 0,
+      minContentScale: 0,
+      schedule: _
+    }
+  }, c = new We(
+    t,
+    e,
+    d
   );
+  return new Se(s, o, h, c);
 };
-class Y {
+class H {
   constructor(e, t, s, o) {
     i(this, "onAfterPortMarked", (e) => {
       const t = this.canvas.graph.getPort(e);
@@ -2090,7 +2181,7 @@ class Y {
       }));
     });
     i(this, "onWindowMouseMove", (e) => {
-      if (!R(
+      if (!D(
         this.window,
         this.element,
         e.clientX,
@@ -2122,7 +2213,7 @@ class Y {
     });
     i(this, "onWindowTouchMove", (e) => {
       const t = e.touches[0];
-      if (!R(
+      if (!D(
         this.window,
         this.element,
         t.clientX,
@@ -2137,19 +2228,19 @@ class Y {
       const t = e.changedTouches[0];
       this.params.onPointerUp({ x: t.clientX, y: t.clientY }), this.stopTouchDrag();
     });
-    i(this, "onBeforeClear", () => {
+    i(this, "reset", () => {
       this.canvas.graph.getAllPortIds().forEach((e) => {
         const t = this.canvas.graph.getPort(e);
         this.unhookPortEvents(t.element);
       });
     });
-    i(this, "onBeforeDestroy", () => {
-      this.params.onStopDrag(), this.removeWindowMouseListeners(), this.removeWindowTouchListeners();
+    i(this, "revert", () => {
+      this.params.onStopDrag(), this.reset(), this.removeWindowMouseListeners(), this.removeWindowTouchListeners();
     });
-    this.canvas = e, this.element = t, this.window = s, this.params = o, this.canvas.graph.onAfterPortMarked.subscribe(this.onAfterPortMarked), this.canvas.graph.onBeforePortUnmarked.subscribe(this.onBeforePortUnmarked), this.canvas.graph.onBeforeClear.subscribe(this.onBeforeClear), this.canvas.onBeforeDestroy.subscribe(this.onBeforeDestroy);
+    this.canvas = e, this.element = t, this.window = s, this.params = o, this.canvas.graph.onAfterPortMarked.subscribe(this.onAfterPortMarked), this.canvas.graph.onBeforePortUnmarked.subscribe(this.onBeforePortUnmarked), this.canvas.graph.onBeforeClear.subscribe(this.reset), this.canvas.onBeforeDestroy.subscribe(this.revert);
   }
   static configure(e, t, s, o) {
-    new Y(e, t, s, o);
+    new H(e, t, s, o);
   }
   hookPortEvents(e) {
     e.addEventListener("mousedown", this.onPortMouseDown, {
@@ -2174,7 +2265,7 @@ class Y {
     this.window.removeEventListener("touchmove", this.onWindowTouchMove), this.window.removeEventListener("touchend", this.onWindowTouchFinish), this.window.removeEventListener("touchcancel", this.onWindowTouchFinish);
   }
 }
-class St {
+class Lt {
   constructor(e, t, s) {
     this.canvas = e, this.layoutAlgorithm = t, this.params = s;
   }
@@ -2188,7 +2279,7 @@ class St {
     }), this.params.onAfterApplied();
   }
 }
-class bt {
+class Vt {
   constructor(e, t, s) {
     this.canvas = e, this.layoutAlgorithm = t, this.params = s;
   }
@@ -2224,15 +2315,6 @@ class ee {
       const { element: t } = this.graph.getNode(e);
       t.removeEventListener("mousedown", this.onMouseDown), t.removeEventListener("touchstart", this.onTouchStart);
     });
-    i(this, "onBeforeDestroy", () => {
-      this.removeMouseDragListeners(), this.removeTouchDragListeners();
-    });
-    i(this, "onBeforeClear", () => {
-      this.canvas.graph.getAllNodeIds().forEach((e) => {
-        const { element: t } = this.canvas.graph.getNode(e);
-        t.removeEventListener("mousedown", this.onMouseDown), t.removeEventListener("touchstart", this.onTouchStart);
-      }), this.maxNodePriority = 0;
-    });
     i(this, "onMouseDown", (e) => {
       const t = e;
       if (!this.params.mouseDownEventVerifier(t))
@@ -2285,7 +2367,7 @@ class ee {
       });
     });
     i(this, "onWindowMouseMove", (e) => {
-      if (!R(
+      if (!D(
         this.window,
         this.element,
         e.clientX,
@@ -2306,7 +2388,7 @@ class ee {
       if (e.touches.length !== 1)
         return;
       const t = e.touches[0];
-      if (!R(
+      if (!D(
         this.window,
         this.element,
         t.clientX,
@@ -2323,7 +2405,16 @@ class ee {
     i(this, "onWindowTouchFinish", () => {
       this.cancelTouchDrag();
     });
-    this.canvas = e, this.element = t, this.window = s, this.params = o, this.graph = e.graph, this.graph.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.graph.onAfterNodeUpdated.subscribe(this.onAfterNodeUpdated), this.graph.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.graph.onBeforeClear.subscribe(this.onBeforeClear), this.canvas.onBeforeDestroy.subscribe(this.onBeforeDestroy);
+    i(this, "reset", () => {
+      this.canvas.graph.getAllNodeIds().forEach((e) => {
+        const { element: t } = this.canvas.graph.getNode(e);
+        t.removeEventListener("mousedown", this.onMouseDown), t.removeEventListener("touchstart", this.onTouchStart);
+      }), this.maxNodePriority = 0;
+    });
+    i(this, "revert", () => {
+      this.reset(), this.removeMouseDragListeners(), this.removeTouchDragListeners();
+    });
+    this.canvas = e, this.element = t, this.window = s, this.params = o, this.graph = e.graph, this.graph.onAfterNodeAdded.subscribe(this.onAfterNodeAdded), this.graph.onAfterNodeUpdated.subscribe(this.onAfterNodeUpdated), this.graph.onBeforeNodeRemoved.subscribe(this.onBeforeNodeRemoved), this.graph.onBeforeClear.subscribe(this.reset), this.canvas.onBeforeDestroy.subscribe(this.revert);
   }
   static configure(e, t, s, o) {
     new ee(e, t, s, o);
@@ -2395,15 +2486,7 @@ class ee {
     return e;
   }
 }
-const Pt = (r, e, t) => ({
-  scale: r.scale,
-  x: r.x + r.scale * e,
-  y: r.y + r.scale * t
-}), Nt = (r, e, t, s) => ({
-  scale: r.scale * e,
-  x: r.scale * (1 - e) * t + r.x,
-  y: r.scale * (1 - e) * s + r.y
-}), B = (r) => {
+const B = (r) => {
   const e = [], t = r.touches.length;
   for (let h = 0; h < t; h++)
     e.push([r.touches[h].clientX, r.touches[h].clientY]);
@@ -2422,13 +2505,13 @@ const Pt = (r, e, t) => ({
     touches: e
   };
 };
-class X {
+class Y {
   constructor(e, t, s, o) {
     i(this, "viewport");
     i(this, "prevTouches", null);
     i(this, "wheelFinishTimer", null);
     i(this, "transformInProgress", !1);
-    i(this, "onBeforeDestroy", () => {
+    i(this, "revert", () => {
       this.removeMouseDragListeners(), this.removeTouchDragListeners();
     });
     i(this, "onMouseDown", (e) => {
@@ -2439,7 +2522,7 @@ class X {
       }), this.startRegisteredTransform());
     });
     i(this, "onWindowMouseMove", (e) => {
-      const t = R(
+      const t = D(
         this.window,
         this.element,
         e.clientX,
@@ -2479,7 +2562,7 @@ class X {
     i(this, "onWindowTouchMove", (e) => {
       const t = B(e);
       if (!t.touches.every(
-        (o) => R(this.window, this.element, o[0], o[1])
+        (o) => D(this.window, this.element, o[0], o[1])
       )) {
         this.stopTouchDrag();
         return;
@@ -2509,13 +2592,13 @@ class X {
       passive: !0
     }), this.element.addEventListener("touchstart", this.onTouchStart, {
       passive: !0
-    }), e.onBeforeDestroy.subscribe(this.onBeforeDestroy);
+    }), e.onBeforeDestroy.subscribe(this.revert);
   }
   static configure(e, t, s, o) {
-    new X(e, t, s, o);
+    new Y(e, t, s, o);
   }
   moveViewport(e, t) {
-    const s = this.viewport.getViewportMatrix(), o = Pt(s, e, t), { width: n, height: a } = this.viewport.getDimensions(), h = this.params.transformPreprocessor({
+    const s = this.viewport.getViewportMatrix(), o = Ue(s, e, t), { width: n, height: a } = this.viewport.getDimensions(), h = this.params.transformPreprocessor({
       prevTransform: s,
       nextTransform: o,
       canvasWidth: n,
@@ -2524,7 +2607,7 @@ class X {
     this.performTransform(h);
   }
   scaleViewport(e, t, s) {
-    const o = this.canvas.viewport.getViewportMatrix(), n = Nt(o, e, t, s), { width: a, height: h } = this.viewport.getDimensions(), d = this.params.transformPreprocessor({
+    const o = this.canvas.viewport.getViewportMatrix(), n = Oe(o, e, t, s), { width: a, height: h } = this.viewport.getDimensions(), d = this.params.transformPreprocessor({
       prevTransform: o,
       nextTransform: n,
       canvasWidth: a,
@@ -2610,7 +2693,7 @@ class te {
         this.scheduleLoadAreaAroundViewport(), o.onTransformFinished();
       }
     };
-    X.configure(
+    Y.configure(
       e,
       this.element,
       this.window,
@@ -2648,13 +2731,13 @@ class te {
     });
   }
 }
-const Tt = () => {
+const Ft = () => {
   const r = document.createElementNS("http://www.w3.org/2000/svg", "svg");
   return r.style.position = "absolute", r.style.inset = "0", r;
-}, Ct = () => {
+}, It = () => {
   const r = document.createElementNS("http://www.w3.org/2000/svg", "rect");
   return r.setAttribute("fill", "url(#pattern)"), r;
-}, Mt = () => {
+}, Bt = () => {
   const r = document.createElementNS(
     "http://www.w3.org/2000/svg",
     "pattern"
@@ -2663,9 +2746,9 @@ const Tt = () => {
 };
 class re {
   constructor(e, t, s) {
-    i(this, "svg", Tt());
-    i(this, "patternRenderingRectangle", Ct());
-    i(this, "pattern", Mt());
+    i(this, "svg", Ft());
+    i(this, "patternRenderingRectangle", It());
+    i(this, "pattern", Bt());
     i(this, "patternContent");
     i(this, "tileWidth");
     i(this, "tileHeight");
@@ -2707,10 +2790,10 @@ class se {
     i(this, "onEdgeCreated", (e) => {
       this.params.onAfterEdgeCreated(e);
     });
-    this.canvas = e, this.overlayLayer = t, this.viewportStore = s, this.window = o, this.params = n, this.overlayCanvas = Be(
+    this.canvas = e, this.overlayLayer = t, this.viewportStore = s, this.window = o, this.params = n, this.overlayCanvas = ze(
       this.overlayLayer,
       this.viewportStore
-    ), Y.configure(
+    ), H.configure(
       this.canvas,
       this.overlayLayer,
       this.window,
@@ -2761,10 +2844,10 @@ class se {
       portDirection: this.params.dragPortDirection
     };
     this.isTargetDragging = s === "direct";
-    const [w, f] = this.isTargetDragging ? [l, u] : [u, l];
-    this.overlayCanvas.addNode(O(w)), this.overlayCanvas.addNode(O(f)), this.overlayCanvas.addEdge({
-      from: w.overlayNodeId,
-      to: f.overlayNodeId,
+    const [p, y] = this.isTargetDragging ? [l, u] : [u, l];
+    this.overlayCanvas.addNode(O(p)), this.overlayCanvas.addNode(O(y)), this.overlayCanvas.addEdge({
+      from: p.overlayNodeId,
+      to: y.overlayNodeId,
       shape: this.params.edgeShapeFactory(N.EdgeId)
     });
   }
@@ -2772,7 +2855,7 @@ class se {
     this.staticPortId = null, this.isTargetDragging = !0, this.overlayCanvas.clear();
   }
   tryCreateConnection(e) {
-    const t = Pe(this.canvas.graph, e), s = this.staticPortId;
+    const t = Ce(this.canvas.graph, e), s = this.staticPortId;
     if (t === null) {
       this.params.onEdgeCreationInterrupted({
         staticPortId: s,
@@ -2803,10 +2886,10 @@ class oe {
     i(this, "onEdgeReattached", (e) => {
       this.params.onAfterEdgeReattached(e);
     });
-    this.canvas = e, this.overlayLayer = t, this.viewportStore = s, this.window = o, this.params = n, this.overlayCanvas = Be(
+    this.canvas = e, this.overlayLayer = t, this.viewportStore = s, this.window = o, this.params = n, this.overlayCanvas = ze(
       this.overlayLayer,
       this.viewportStore
-    ), Y.configure(
+    ), H.configure(
       this.canvas,
       this.overlayLayer,
       this.window,
@@ -2844,10 +2927,10 @@ class oe {
     const d = this.canvas.graph.getPort(e), c = this.canvas.graph.getPort(h), g = c.element.getBoundingClientRect(), l = {
       x: g.x + g.width / 2,
       y: g.y + g.height / 2
-    }, u = this.overlayLayer.getBoundingClientRect(), w = this.canvas.viewport.createContentCoords({
+    }, u = this.overlayLayer.getBoundingClientRect(), p = this.canvas.viewport.createContentCoords({
       x: l.x - u.x,
       y: l.y - u.y
-    }), f = this.canvas.viewport.createContentCoords({
+    }), y = this.canvas.viewport.createContentCoords({
       x: t.x - u.x,
       y: t.y - u.y
     });
@@ -2860,20 +2943,20 @@ class oe {
     }, this.canvas.removeEdge(s);
     const v = {
       overlayNodeId: N.StaticNodeId,
-      portCoords: w,
+      portCoords: p,
       portDirection: c.direction
-    }, S = {
+    }, x = {
       overlayNodeId: N.DraggingNodeId,
-      portCoords: f,
+      portCoords: y,
       portDirection: d.direction
-    }, [b, T] = this.isTargetDragging ? [v, S] : [S, v];
-    this.overlayCanvas.addNode(O(b)), this.overlayCanvas.addNode(O(T));
-    const P = this.params.draggingEdgeShapeFactory !== null ? this.params.draggingEdgeShapeFactory(N.EdgeId) : o.shape;
+    }, [b, P] = this.isTargetDragging ? [v, x] : [x, v];
+    this.overlayCanvas.addNode(O(b)), this.overlayCanvas.addNode(O(P));
+    const C = this.params.draggingEdgeShapeFactory !== null ? this.params.draggingEdgeShapeFactory(N.EdgeId) : o.shape;
     return this.overlayCanvas.addEdge({
       id: N.EdgeId,
       from: b.overlayNodeId,
-      to: T.overlayNodeId,
-      shape: P
+      to: P.overlayNodeId,
+      shape: C
     }), !0;
   }
   resetDragState() {
@@ -2890,7 +2973,7 @@ class oe {
     });
   }
   tryCreateConnection(e) {
-    const t = Pe(this.canvas.graph, e);
+    const t = Ce(this.canvas.graph, e);
     if (this.overlayCanvas.removeEdge(N.EdgeId), t === null) {
       const d = this.draggingEdgePayload;
       this.params.onEdgeReattachInterrupted({
@@ -2933,7 +3016,7 @@ class ie {
     new ie(e, t);
   }
 }
-class z {
+class ne {
   constructor(e, t, s) {
     i(this, "applyScheduled", !1);
     i(this, "apply", () => {
@@ -2950,7 +3033,7 @@ class z {
     });
   }
   static configure(e, t, s) {
-    new z(
+    new ne(
       e,
       t,
       s
@@ -2960,49 +3043,33 @@ class z {
     this.applyScheduled || (this.applyScheduled = !0, this.defererFn(this.apply));
   }
 }
-class Dt {
+class $t {
   static configure(e, t) {
-    const s = t.applyOn, o = new St(e, t.algorithm, {
+    const s = t.applyOn, o = new Lt(e, t.algorithm, {
       staticNodeResolver: t.staticNodeResolver,
       onBeforeApplied: t.onBeforeApplied,
       onAfterApplied: t.onAfterApplied
     });
     switch (s.type) {
-      case "manual": {
+      case "trigger": {
         ie.configure(
           o,
           s.trigger
         );
         break;
       }
-      case "topologyChangeMacrotask": {
-        z.configure(
-          e.graph,
-          o,
-          (n) => {
-            setTimeout(() => {
-              n();
-            });
-          }
-        );
-        break;
-      }
-      case "topologyChangeMicrotask": {
-        z.configure(
+      case "topologyChangeSchedule": {
+        ne.configure(
           e.graph,
           o,
-          (n) => {
-            queueMicrotask(() => {
-              n();
-            });
-          }
+          s.schedule
         );
         break;
       }
     }
   }
 }
-class Rt {
+class Ut {
   constructor(e, t) {
     i(this, "previousTimeStamp");
     i(this, "step", (e) => {
@@ -3017,150 +3084,51 @@ class Rt {
     this.win = e, this.callback = t, this.win.requestAnimationFrame(this.step);
   }
 }
-class ne {
+class ae {
   constructor(e, t, s) {
     i(this, "applier");
     i(this, "step", (e) => {
       this.applier.apply(e);
     });
-    this.win = s, this.applier = new bt(e, t.algorithm, {
+    this.win = s, this.applier = new Vt(e, t.algorithm, {
       staticNodeResolver: t.staticNodeResolver,
       onBeforeApplied: t.onBeforeApplied,
       onAfterApplied: t.onAfterApplied
-    }), new Rt(this.win, this.step);
+    }), new Ut(this.win, this.step);
   }
   static configure(e, t, s) {
-    new ne(e, t, s);
+    new ae(e, t, s);
   }
 }
-const Lt = () => {
+const Ot = () => {
   const r = document.createElement("div");
   return r.style.width = "100%", r.style.height = "100%", r.style.position = "relative", r;
-}, q = () => {
+}, j = () => {
   const r = document.createElement("div");
   return r.style.position = "absolute", r.style.inset = "0", r;
-}, ye = () => {
-  const r = q();
+}, me = () => {
+  const r = j();
   return r.style.pointerEvents = "none", r;
 };
-class Vt {
+class Wt {
   constructor(e) {
-    i(this, "background", q());
-    i(this, "main", q());
-    i(this, "overlayConnectablePorts", ye());
-    i(this, "overlayDraggableEdges", ye());
-    i(this, "host", Lt());
+    i(this, "background", j());
+    i(this, "main", j());
+    i(this, "overlayConnectablePorts", me());
+    i(this, "overlayDraggableEdges", me());
+    i(this, "host", Ot());
     this.element = e, this.element.appendChild(this.host), this.host.appendChild(this.background), this.host.appendChild(this.main), this.host.appendChild(this.overlayConnectablePorts), this.host.appendChild(this.overlayDraggableEdges);
   }
   destroy() {
     this.host.removeChild(this.background), this.host.removeChild(this.main), this.host.removeChild(this.overlayConnectablePorts), this.host.removeChild(this.overlayDraggableEdges), this.element.removeChild(this.host);
   }
 }
-const K = (r) => () => r, me = K(0), Ft = () => {
-  let r = 0;
-  return () => r++;
-}, It = (r, e) => {
-  let t = me, s = me;
-  const o = Ft();
-  return r === "incremental" && (t = o), e === "incremental" && (s = o), typeof r == "number" && (t = K(r)), typeof e == "number" && (s = K(e)), typeof r == "function" && (t = r), typeof e == "function" && (s = e), {
-    nodesPriorityFn: t,
-    edgesPriorityFn: s
-  };
-}, ae = (r) => {
-  if (typeof r == "function")
-    return r;
-  switch (r.type) {
-    case "straight":
-      return () => new mt({
-        color: r.color,
-        width: r.width,
-        arrowLength: r.arrowLength,
-        arrowOffset: r.arrowOffset,
-        arrowRenderer: r.arrowRenderer,
-        hasSourceArrow: r.hasSourceArrow,
-        hasTargetArrow: r.hasTargetArrow,
-        cycleSquareSide: r.cycleSquareSide,
-        roundness: r.roundness,
-        detourDistance: r.detourDistance,
-        detourDirection: r.detourDirection
-      });
-    case "horizontal":
-      return () => new yt({
-        color: r.color,
-        width: r.width,
-        arrowLength: r.arrowLength,
-        arrowOffset: r.arrowOffset,
-        arrowRenderer: r.arrowRenderer,
-        hasSourceArrow: r.hasSourceArrow,
-        hasTargetArrow: r.hasTargetArrow,
-        cycleSquareSide: r.cycleSquareSide,
-        roundness: r.roundness,
-        detourDistance: r.detourDistance
-      });
-    case "vertical":
-      return () => new vt({
-        color: r.color,
-        width: r.width,
-        arrowLength: r.arrowLength,
-        arrowOffset: r.arrowOffset,
-        arrowRenderer: r.arrowRenderer,
-        hasSourceArrow: r.hasSourceArrow,
-        hasTargetArrow: r.hasTargetArrow,
-        cycleSquareSide: r.cycleSquareSide,
-        roundness: r.roundness,
-        detourDistance: r.detourDistance
-      });
-    case "direct":
-      return () => new Le({
-        color: r.color,
-        width: r.width,
-        arrowLength: r.arrowLength,
-        arrowRenderer: r.arrowRenderer,
-        hasSourceArrow: r.hasSourceArrow,
-        hasTargetArrow: r.hasTargetArrow,
-        sourceOffset: r.sourceOffset,
-        targetOffset: r.targetOffset
-      });
-    default:
-      return () => new ft({
-        color: r.color,
-        width: r.width,
-        arrowLength: r.arrowLength,
-        arrowRenderer: r.arrowRenderer,
-        hasSourceArrow: r.hasSourceArrow,
-        hasTargetArrow: r.hasTargetArrow,
-        cycleRadius: r.cycleRadius,
-        smallCycleRadius: r.smallCycleRadius,
-        curvature: r.curvature,
-        detourDistance: r.detourDistance,
-        detourDirection: r.detourDirection
-      });
-  }
-}, Bt = (r) => {
-  var t, s, o, n, a;
-  const e = It(
-    (t = r.nodes) == null ? void 0 : t.priority,
-    (s = r.edges) == null ? void 0 : s.priority
-  );
-  return {
-    nodes: {
-      centerFn: ((o = r.nodes) == null ? void 0 : o.centerFn) ?? Ne,
-      priorityFn: e.nodesPriorityFn
-    },
-    ports: {
-      direction: ((n = r.ports) == null ? void 0 : n.direction) ?? 0
-    },
-    edges: {
-      shapeFactory: ae(((a = r.edges) == null ? void 0 : a.shape) ?? {}),
-      priorityFn: e.edgesPriorityFn
-    }
-  };
-}, $t = (r) => {
-  var w, f, v, S, b, T;
-  const e = ((w = r.events) == null ? void 0 : w.onNodeDragStarted) ?? (() => {
-  }), t = ((f = r.events) == null ? void 0 : f.onNodeDrag) ?? (() => {
+const zt = (r) => {
+  var p, y, v, x, b, P;
+  const e = ((p = r.events) == null ? void 0 : p.onNodeDragStarted) ?? (() => {
+  }), t = ((y = r.events) == null ? void 0 : y.onNodeDrag) ?? (() => {
   }), s = r.nodeDragVerifier ?? (() => !0), o = ((v = r.events) == null ? void 0 : v.onNodeDragFinished) ?? (() => {
-  }), n = r.moveOnTop !== !1, a = r.moveEdgesOnTop !== !1 && n, h = (S = r.mouse) == null ? void 0 : S.dragCursor, d = h !== void 0 ? h : "grab", c = (b = r.mouse) == null ? void 0 : b.mouseDownEventVerifier, g = c !== void 0 ? c : (P) => P.button === 0, l = (T = r.mouse) == null ? void 0 : T.mouseUpEventVerifier, u = l !== void 0 ? l : (P) => P.button === 0;
+  }), n = r.moveOnTop !== !1, a = r.moveEdgesOnTop !== !1 && n, h = (x = r.mouse) == null ? void 0 : x.dragCursor, d = h !== void 0 ? h : "grab", c = (b = r.mouse) == null ? void 0 : b.mouseDownEventVerifier, g = c !== void 0 ? c : (C) => C.button === 0, l = (P = r.mouse) == null ? void 0 : P.mouseUpEventVerifier, u = l !== void 0 ? l : (C) => C.button === 0;
   return {
     moveOnTop: n,
     moveEdgesOnTop: a,
@@ -3173,7 +3141,7 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     nodeDragVerifier: s,
     onNodeDragFinished: o
   };
-}, Ut = (r) => {
+}, kt = (r) => {
   const e = r.minX !== null ? r.minX : -1 / 0, t = r.maxX !== null ? r.maxX : 1 / 0, s = r.minY !== null ? r.minY : -1 / 0, o = r.maxY !== null ? r.maxY : 1 / 0;
   return (n) => {
     let a = n.nextTransform.x, h = n.nextTransform.y;
@@ -3183,7 +3151,7 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     const g = n.canvasHeight * n.prevTransform.scale, l = o - g;
     return h > l && h > n.prevTransform.y && (h = Math.max(n.prevTransform.y, l)), { scale: n.nextTransform.scale, x: a, y: h };
   };
-}, Ot = (r) => {
+}, Ht = (r) => {
   const e = r.maxContentScale, t = r.minContentScale, s = e !== null ? 1 / e : 0, o = t !== null ? 1 / t : 1 / 0;
   return (n) => {
     const a = n.prevTransform, h = n.nextTransform;
@@ -3204,7 +3172,7 @@ const K = (r) => () => r, me = K(0), Ft = () => {
       y: g
     };
   };
-}, Wt = (r) => (e) => r.reduce(
+}, Yt = (r) => (e) => r.reduce(
   (t, s) => s({
     prevTransform: e.prevTransform,
     nextTransform: t,
@@ -3217,12 +3185,12 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     return r;
   switch (r.type) {
     case "scale-limit":
-      return Ot({
+      return Ht({
         minContentScale: r.minContentScale ?? 0,
         maxContentScale: r.maxContentScale ?? 1 / 0
       });
     case "shift-limit":
-      return Ut({
+      return kt({
         minX: r.minX ?? -1 / 0,
         maxX: r.maxX ?? 1 / 0,
         minY: r.minY ?? -1 / 0,
@@ -3230,22 +3198,22 @@ const K = (r) => () => r, me = K(0), Ft = () => {
       });
   }
 }, Ae = (r) => {
-  var f, v, S, b, T, P, L, V, he, de, ce, le;
-  const e = (f = r == null ? void 0 : r.scale) == null ? void 0 : f.mouseWheelSensitivity, t = e !== void 0 ? e : 1.2, s = r == null ? void 0 : r.transformPreprocessor;
+  var y, v, x, b, P, C, L, V, de, ce, le, ge;
+  const e = (y = r == null ? void 0 : r.scale) == null ? void 0 : y.mouseWheelSensitivity, t = e !== void 0 ? e : 1.2, s = r == null ? void 0 : r.transformPreprocessor;
   let o;
-  s !== void 0 ? Array.isArray(s) ? o = Wt(
+  s !== void 0 ? Array.isArray(s) ? o = Yt(
     s.map(
-      (C) => ve(C)
+      (T) => ve(T)
     )
-  ) : o = ve(s) : o = (C) => C.nextTransform;
-  const n = ((v = r == null ? void 0 : r.shift) == null ? void 0 : v.cursor) !== void 0 ? r.shift.cursor : "grab", a = ((S = r == null ? void 0 : r.events) == null ? void 0 : S.onBeforeTransformChange) ?? (() => {
+  ) : o = ve(s) : o = (T) => T.nextTransform;
+  const n = ((v = r == null ? void 0 : r.shift) == null ? void 0 : v.cursor) !== void 0 ? r.shift.cursor : "grab", a = ((x = r == null ? void 0 : r.events) == null ? void 0 : x.onBeforeTransformChange) ?? (() => {
   }), h = ((b = r == null ? void 0 : r.events) == null ? void 0 : b.onTransformChange) ?? (() => {
-  }), d = (T = r == null ? void 0 : r.shift) == null ? void 0 : T.mouseDownEventVerifier, c = d !== void 0 ? d : (C) => C.button === 0, g = (P = r == null ? void 0 : r.shift) == null ? void 0 : P.mouseUpEventVerifier, l = g !== void 0 ? g : (C) => C.button === 0, u = (L = r == null ? void 0 : r.scale) == null ? void 0 : L.mouseWheelEventVerifier, w = u !== void 0 ? u : () => !0;
+  }), d = (P = r == null ? void 0 : r.shift) == null ? void 0 : P.mouseDownEventVerifier, c = d !== void 0 ? d : (T) => T.button === 0, g = (C = r == null ? void 0 : r.shift) == null ? void 0 : C.mouseUpEventVerifier, l = g !== void 0 ? g : (T) => T.button === 0, u = (L = r == null ? void 0 : r.scale) == null ? void 0 : L.mouseWheelEventVerifier, p = u !== void 0 ? u : () => !0;
   return {
     wheelSensitivity: t,
     onTransformStarted: ((V = r == null ? void 0 : r.events) == null ? void 0 : V.onTransformStarted) ?? (() => {
     }),
-    onTransformFinished: ((he = r == null ? void 0 : r.events) == null ? void 0 : he.onTransformFinished) ?? (() => {
+    onTransformFinished: ((de = r == null ? void 0 : r.events) == null ? void 0 : de.onTransformFinished) ?? (() => {
     }),
     onBeforeTransformChange: a,
     onTransformChange: h,
@@ -3253,31 +3221,101 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     shiftCursor: n,
     mouseDownEventVerifier: c,
     mouseUpEventVerifier: l,
-    mouseWheelEventVerifier: w,
-    scaleWheelFinishTimeout: ((de = r == null ? void 0 : r.scale) == null ? void 0 : de.wheelFinishTimeout) ?? 500,
-    onResizeTransformStarted: ((ce = r == null ? void 0 : r.events) == null ? void 0 : ce.onResizeTransformStarted) ?? (() => {
+    mouseWheelEventVerifier: p,
+    scaleWheelFinishTimeout: ((ce = r == null ? void 0 : r.scale) == null ? void 0 : ce.wheelFinishTimeout) ?? 500,
+    onResizeTransformStarted: ((le = r == null ? void 0 : r.events) == null ? void 0 : le.onResizeTransformStarted) ?? (() => {
     }),
-    onResizeTransformFinished: ((le = r == null ? void 0 : r.events) == null ? void 0 : le.onResizeTransformFinished) ?? (() => {
+    onResizeTransformFinished: ((ge = r == null ? void 0 : r.events) == null ? void 0 : ge.onResizeTransformFinished) ?? (() => {
     })
   };
-}, zt = (r, e) => {
+}, Xt = (r, e) => {
   const t = document.createElementNS(
     "http://www.w3.org/2000/svg",
     "circle"
   );
   return t.setAttribute("cx", "0"), t.setAttribute("cy", "0"), t.setAttribute("r", `${r}`), t.setAttribute("fill", `${e}`), t;
-}, kt = (r) => r instanceof SVGElement ? r : zt(
+}, Gt = (r) => r instanceof SVGElement ? r : Xt(
   (r == null ? void 0 : r.radius) ?? 1.5,
   (r == null ? void 0 : r.color) ?? "#d8d8d8"
-), Ht = (r) => {
-  const e = r.tileDimensions, t = (e == null ? void 0 : e.width) ?? 25, s = (e == null ? void 0 : e.height) ?? 25, o = kt(r.renderer ?? {});
+), jt = (r) => {
+  const e = r.tileDimensions, t = (e == null ? void 0 : e.width) ?? 25, s = (e == null ? void 0 : e.height) ?? 25, o = Gt(r.renderer ?? {});
   return {
     tileWidth: t,
     tileHeight: s,
     renderer: o,
     maxViewportScale: r.maxViewportScale ?? 10
   };
-}, Yt = (r, e, t) => {
+}, he = (r) => {
+  if (typeof r == "function")
+    return r;
+  switch (r.type) {
+    case "straight":
+      return () => new bt({
+        color: r.color,
+        width: r.width,
+        arrowLength: r.arrowLength,
+        arrowOffset: r.arrowOffset,
+        arrowRenderer: r.arrowRenderer,
+        hasSourceArrow: r.hasSourceArrow,
+        hasTargetArrow: r.hasTargetArrow,
+        cycleSquareSide: r.cycleSquareSide,
+        roundness: r.roundness,
+        detourDistance: r.detourDistance,
+        detourDirection: r.detourDirection
+      });
+    case "horizontal":
+      return () => new St({
+        color: r.color,
+        width: r.width,
+        arrowLength: r.arrowLength,
+        arrowOffset: r.arrowOffset,
+        arrowRenderer: r.arrowRenderer,
+        hasSourceArrow: r.hasSourceArrow,
+        hasTargetArrow: r.hasTargetArrow,
+        cycleSquareSide: r.cycleSquareSide,
+        roundness: r.roundness,
+        detourDistance: r.detourDistance
+      });
+    case "vertical":
+      return () => new Pt({
+        color: r.color,
+        width: r.width,
+        arrowLength: r.arrowLength,
+        arrowOffset: r.arrowOffset,
+        arrowRenderer: r.arrowRenderer,
+        hasSourceArrow: r.hasSourceArrow,
+        hasTargetArrow: r.hasTargetArrow,
+        cycleSquareSide: r.cycleSquareSide,
+        roundness: r.roundness,
+        detourDistance: r.detourDistance
+      });
+    case "direct":
+      return () => new Ve({
+        color: r.color,
+        width: r.width,
+        arrowLength: r.arrowLength,
+        arrowRenderer: r.arrowRenderer,
+        hasSourceArrow: r.hasSourceArrow,
+        hasTargetArrow: r.hasTargetArrow,
+        sourceOffset: r.sourceOffset,
+        targetOffset: r.targetOffset
+      });
+    default:
+      return () => new Et({
+        color: r.color,
+        width: r.width,
+        arrowLength: r.arrowLength,
+        arrowRenderer: r.arrowRenderer,
+        hasSourceArrow: r.hasSourceArrow,
+        hasTargetArrow: r.hasTargetArrow,
+        cycleRadius: r.cycleRadius,
+        smallCycleRadius: r.smallCycleRadius,
+        curvature: r.curvature,
+        detourDistance: r.detourDistance,
+        detourDirection: r.detourDirection
+      });
+  }
+}, qt = (r, e, t) => {
   var c, g, l;
   const s = () => "direct", o = (u) => u, n = (u) => u.button === 0, a = () => {
   }, h = () => {
@@ -3292,13 +3330,13 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     onEdgeCreationInterrupted: ((g = r.events) == null ? void 0 : g.onEdgeCreationInterrupted) ?? d,
     onEdgeCreationPrevented: ((l = r.events) == null ? void 0 : l.onEdgeCreationPrevented) ?? h,
     dragPortDirection: r.dragPortDirection ?? t,
-    edgeShapeFactory: r.edgeShape !== void 0 ? ae(r.edgeShape) : e
+    edgeShapeFactory: r.edgeShape !== void 0 ? he(r.edgeShape) : e
   };
-}, Xt = (r, e) => {
+}, Kt = (r, e) => {
   var c, g, l;
   const t = (u) => u, s = (u) => u.button === 0 && u.ctrlKey, o = (u) => u.button === 0, n = (u) => {
-    const w = e.getPortAdjacentEdgeIds(u);
-    return w.length > 0 ? w[w.length - 1] : null;
+    const p = e.getPortAdjacentEdgeIds(u);
+    return p.length > 0 ? p[p.length - 1] : null;
   }, a = () => {
   }, h = () => {
   }, d = () => {
@@ -3308,15 +3346,15 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     mouseDownEventVerifier: r.mouseDownEventVerifier ?? s,
     mouseUpEventVerifier: r.mouseUpEventVerifier ?? o,
     draggingEdgeResolver: r.draggingEdgeResolver ?? n,
-    draggingEdgeShapeFactory: r.draggingEdgeShape !== void 0 ? ae(r.draggingEdgeShape) : null,
+    draggingEdgeShapeFactory: r.draggingEdgeShape !== void 0 ? he(r.draggingEdgeShape) : null,
     onAfterEdgeReattached: ((c = r.events) == null ? void 0 : c.onAfterEdgeReattached) ?? a,
     onEdgeReattachInterrupted: ((g = r.events) == null ? void 0 : g.onEdgeReattachInterrupted) ?? d,
     onEdgeReattachPrevented: ((l = r.events) == null ? void 0 : l.onEdgeReattachPrevented) ?? h
   };
-}, Gt = (r) => ({
+}, Qt = (r) => ({
   nodeVerticalRadius: r.nodeContainingRadius.vertical,
   nodeHorizontalRadius: r.nodeContainingRadius.horizontal
-}), jt = (r) => {
+}), Zt = (r) => {
   var e, t;
   return {
     onAfterNodeDetached: ((e = r == null ? void 0 : r.events) == null ? void 0 : e.onAfterNodeDetached) ?? (() => {
@@ -3325,13 +3363,13 @@ const K = (r) => () => r, me = K(0), Ft = () => {
     })
   };
 };
-class qt extends Error {
+class Jt extends Error {
   constructor() {
     super(...arguments);
     i(this, "name", "CanvasBuilderError");
   }
 }
-class $e {
+class ke {
   constructor(e, t, s) {
     i(this, "dt");
     i(this, "nodeMass");
@@ -3364,12 +3402,12 @@ class $e {
       const s = this.graph.getEdge(t), o = this.graph.getPort(s.from), n = this.graph.getPort(s.to), a = this.currentCoords.get(o.nodeId), h = this.currentCoords.get(n.nodeId), d = this.distanceVectorGenerator.create(
         a,
         h
-      ), g = (d.d - this.edgeEquilibriumLength) * this.edgeStiffness, l = d.ex * g, u = d.ey * g, w = e.get(o.nodeId), f = e.get(n.nodeId);
-      w.x += l, w.y += u, f.x -= l, f.y -= u;
+      ), g = (d.d - this.edgeEquilibriumLength) * this.edgeStiffness, l = d.ex * g, u = d.ey * g, p = e.get(o.nodeId), y = e.get(n.nodeId);
+      p.x += l, p.y += u, y.x -= l, y.y -= u;
     });
   }
 }
-class Ue {
+class He {
   constructor(e) {
     i(this, "PI2", 2 * Math.PI);
     this.rand = e;
@@ -3388,13 +3426,13 @@ class Ue {
     return { ex: h, ey: d, d: a };
   }
 }
-const Oe = (r) => {
+const Ye = (r) => {
   if (r.distance === 0)
     return r.maxForce;
   const e = r.coefficient * (r.sourceCharge * r.targetCharge / (r.distance * r.distance));
   return Math.min(e, r.maxForce);
 };
-class Kt {
+class _t {
   constructor(e) {
     i(this, "nodeCharge");
     i(this, "distanceVectorGenerator");
@@ -3409,19 +3447,19 @@ class Kt {
         const d = s[h], c = e.get(a), g = e.get(d), l = this.distanceVectorGenerator.create(
           c,
           g
-        ), u = Oe({
+        ), u = Ye({
           coefficient: 1,
           sourceCharge: this.nodeCharge,
           targetCharge: this.nodeCharge,
           distance: l.d,
           maxForce: this.maxForce
-        }), w = u * l.ex, f = u * l.ey, v = t.get(a), S = t.get(d);
-        v.x -= w, v.y -= f, S.x += w, S.y += f;
+        }), p = u * l.ex, y = u * l.ey, v = t.get(a), x = t.get(d);
+        v.x -= p, v.y -= y, x.x += p, x.y += y;
       }
     }
   }
 }
-const Qt = (r) => {
+const er = (r) => {
   if (r.size === 0)
     return {
       centerX: 0,
@@ -3439,7 +3477,7 @@ const Qt = (r) => {
     radius: h / 2
   };
 };
-class Zt {
+class tr {
   constructor(e) {
     i(this, "root");
     i(this, "leaves", /* @__PURE__ */ new Map());
@@ -3494,8 +3532,8 @@ class Zt {
     this.sortedParentNodes.push(e);
     const n = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), c = o / 2;
     e.nodeIds.forEach((u) => {
-      const { x: w, y: f } = this.coords.get(u);
-      w < t ? f < s ? d.add(u) : h.add(u) : f < s ? a.add(u) : n.add(u), e.nodeIds.delete(u);
+      const { x: p, y } = this.coords.get(u);
+      p < t ? y < s ? d.add(u) : h.add(u) : y < s ? a.add(u) : n.add(u), e.nodeIds.delete(u);
     });
     const g = {
       parent: e,
@@ -3596,7 +3634,7 @@ class Zt {
     }), { x: t / e.size, y: s / e.size };
   }
 }
-class Jt {
+class rr {
   constructor(e) {
     i(this, "areaRadiusThreshold");
     i(this, "nodeMass");
@@ -3608,7 +3646,7 @@ class Jt {
     this.areaRadiusThreshold = e.areaRadiusThreshold, this.nodeMass = e.nodeMass, this.nodeCharge = e.nodeCharge, this.theta = e.theta, this.distanceVectorGenerator = e.distanceVectorGenerator, this.nodeForceCoefficient = e.nodeForceCoefficient, this.maxForce = e.maxForce;
   }
   apply(e, t) {
-    const s = Qt(e), o = new Zt({
+    const s = er(e), o = new tr({
       box: s,
       coords: e,
       areaRadiusThreshold: this.areaRadiusThreshold,
@@ -3723,7 +3761,7 @@ class Jt {
     const t = this.distanceVectorGenerator.create(
       e.sourceCoords,
       e.targetCoords
-    ), s = Oe({
+    ), s = Ye({
       coefficient: this.nodeForceCoefficient,
       sourceCharge: e.sourceCharge,
       targetCharge: e.targetCharge,
@@ -3758,7 +3796,7 @@ class Jt {
     }
   }
 }
-const We = (r) => r.theta !== 0 ? new Jt({
+const Xe = (r) => r.theta !== 0 ? new rr({
   nodeCharge: r.nodeCharge,
   nodeForceCoefficient: r.nodeForceCoefficient,
   distanceVectorGenerator: r.distanceVectorGenerator,
@@ -3766,36 +3804,36 @@ const We = (r) => r.theta !== 0 ? new Jt({
   theta: r.theta,
   nodeMass: r.nodeMass,
   areaRadiusThreshold: r.areaRadiusThreshold
-}) : new Kt({
+}) : new _t({
   nodeCharge: r.nodeCharge,
   nodeForceCoefficient: r.nodeForceCoefficient,
   distanceVectorGenerator: r.distanceVectorGenerator,
   maxForce: r.maxForce
 });
-class ze {
+class Ge {
   constructor(e) {
     i(this, "rand");
     i(this, "sparsity");
     this.rand = e.rand, this.sparsity = e.sparsity;
   }
   calculateCoordinates(e) {
-    const { graph: t, viewport: s } = e, o = /* @__PURE__ */ new Map(), n = t.getAllNodeIds().filter((f) => {
-      const v = t.getNode(f);
+    const { graph: t, viewport: s } = e, o = /* @__PURE__ */ new Map(), n = t.getAllNodeIds().filter((y) => {
+      const v = t.getNode(y);
       return v.x === null || v.y === null;
     }), a = Math.sqrt(n.length) * this.sparsity, { width: h, height: d } = s.getDimensions(), c = { x: h / 2, y: d / 2 }, g = s.createContentCoords(c), l = a / 2, u = {
       x: g.x - l,
       y: g.y - l
     };
-    return t.getAllNodeIds().forEach((f) => {
-      const v = t.getNode(f);
-      o.set(f, {
+    return t.getAllNodeIds().forEach((y) => {
+      const v = t.getNode(y);
+      o.set(y, {
         x: v.x ?? u.x + a * this.rand(),
         y: v.y ?? u.y + a * this.rand()
       });
     }), o;
   }
 }
-class _t {
+class sr {
   constructor(e) {
     i(this, "distanceVectorGenerator");
     i(this, "nodeForcesApplicationStrategy");
@@ -3806,7 +3844,7 @@ class _t {
     i(this, "edgeEquilibriumLength");
     i(this, "edgeStiffness");
     i(this, "convergenceVelocity");
-    this.maxIterations = e.maxIterations, this.dtSec = e.dtSec, this.nodeMass = e.nodeMass, this.edgeEquilibriumLength = e.edgeEquilibriumLength, this.edgeStiffness = e.edgeStiffness, this.convergenceVelocity = e.convergenceVelocity, this.distanceVectorGenerator = new Ue(e.rand), this.nodeForcesApplicationStrategy = We({
+    this.maxIterations = e.maxIterations, this.dtSec = e.dtSec, this.nodeMass = e.nodeMass, this.edgeEquilibriumLength = e.edgeEquilibriumLength, this.edgeStiffness = e.edgeStiffness, this.convergenceVelocity = e.convergenceVelocity, this.distanceVectorGenerator = new He(e.rand), this.nodeForcesApplicationStrategy = Xe({
       distanceVectorGenerator: this.distanceVectorGenerator,
       nodeCharge: e.nodeCharge,
       maxForce: e.maxForce,
@@ -3814,7 +3852,7 @@ class _t {
       theta: e.barnesHutTheta,
       areaRadiusThreshold: e.barnesHutAreaRadiusThreshold,
       nodeMass: e.nodeMass
-    }), this.fillerLayoutAlgorithm = new ze({
+    }), this.fillerLayoutAlgorithm = new Ge({
       rand: e.rand,
       sparsity: e.edgeEquilibriumLength
     });
@@ -3824,7 +3862,7 @@ class _t {
       graph: t,
       viewport: s
     });
-    for (let n = 0; n < this.maxIterations && !(new $e(
+    for (let n = 0; n < this.maxIterations && !(new ke(
       t,
       o,
       {
@@ -3840,7 +3878,7 @@ class _t {
     return o;
   }
 }
-class er {
+class or {
   constructor(e) {
     i(this, "forest", /* @__PURE__ */ new Set());
     i(this, "remainingNodeIds");
@@ -3883,7 +3921,7 @@ class er {
     }
   }
 }
-class tr {
+class ir {
   constructor(e) {
     i(this, "baseRadius");
     this.baseRadius = e.radius;
@@ -3911,12 +3949,12 @@ class tr {
     };
   }
 }
-class rr {
+class nr {
   constructor(e, t) {
     i(this, "offsets", /* @__PURE__ */ new Map());
     i(this, "childrenRadii", /* @__PURE__ */ new Map());
     i(this, "layerNodePlacementResolver");
-    this.tree = e, this.layerNodePlacementResolver = new tr({
+    this.tree = e, this.layerNodePlacementResolver = new ir({
       radius: t.spaceAroundRadius
     }), [...this.tree.sequence].reverse().forEach((s) => {
       if (s.children.size === 0)
@@ -3937,16 +3975,16 @@ class rr {
     return this.offsets;
   }
 }
-class sr {
+class ar {
   constructor(e) {
     this.params = e;
   }
   calculateCoordinates(e) {
-    const t = /* @__PURE__ */ new Map(), o = new er(e.graph).generate();
+    const t = /* @__PURE__ */ new Map(), o = new or(e.graph).generate();
     let n = 0;
     return o.forEach((a) => {
       t.set(a.root.nodeId, { x: n, y: 0 });
-      const d = new rr(a, {
+      const d = new nr(a, {
         spaceAroundRadius: this.params.layerSpace / 2
       }).generate();
       let c = [a.root];
@@ -3954,9 +3992,9 @@ class sr {
         const g = [];
         n += this.params.layerWidth, c.forEach((l) => {
           l.children.forEach((u) => {
-            const w = t.get(l.nodeId).y;
+            const p = t.get(l.nodeId).y;
             t.set(u.nodeId, {
-              y: w + d.get(u.nodeId),
+              y: p + d.get(u.nodeId),
               x: n
             }), g.push(u);
           });
@@ -3968,7 +4006,7 @@ class sr {
     }), t;
   }
 }
-class or {
+class hr {
   constructor(e) {
     i(this, "distanceVectorGenerator");
     i(this, "nodeForcesApplicationStrategy");
@@ -3978,7 +4016,7 @@ class or {
     i(this, "edgeEquilibriumLength");
     i(this, "edgeStiffness");
     i(this, "fillerLayoutAlgorithm");
-    this.convergenceVelocity = e.convergenceVelocity, this.maxTimeDeltaSec = e.maxTimeDeltaSec, this.nodeMass = e.nodeMass, this.edgeEquilibriumLength = e.edgeEquilibriumLength, this.edgeStiffness = e.edgeStiffness, this.distanceVectorGenerator = new Ue(e.rand), this.nodeForcesApplicationStrategy = We({
+    this.convergenceVelocity = e.convergenceVelocity, this.maxTimeDeltaSec = e.maxTimeDeltaSec, this.nodeMass = e.nodeMass, this.edgeEquilibriumLength = e.edgeEquilibriumLength, this.edgeStiffness = e.edgeStiffness, this.distanceVectorGenerator = new He(e.rand), this.nodeForcesApplicationStrategy = Xe({
       distanceVectorGenerator: this.distanceVectorGenerator,
       nodeCharge: e.nodeCharge,
       maxForce: e.maxForce,
@@ -3986,7 +4024,7 @@ class or {
       theta: e.barnesHutTheta,
       areaRadiusThreshold: e.barnesHutAreaRadiusThreshold,
       nodeMass: e.nodeMass
-    }), this.fillerLayoutAlgorithm = new ze({
+    }), this.fillerLayoutAlgorithm = new Ge({
       rand: e.rand,
       sparsity: e.edgeEquilibriumLength
     });
@@ -3996,7 +4034,7 @@ class or {
       graph: t,
       viewport: s
     });
-    return new $e(
+    return new ke(
       t,
       n,
       {
@@ -4013,12 +4051,12 @@ class or {
     }) ? /* @__PURE__ */ new Map() : n;
   }
 }
-const ke = (r) => {
+const je = (r) => {
   let e = 1779033703, t = 3144134277, s = 1013904242, o = 2773480762;
   for (let n = 0, a; n < r.length; n++)
     a = r.charCodeAt(n), e = t ^ Math.imul(e ^ a, 597399067), t = s ^ Math.imul(t ^ a, 2869860233), s = o ^ Math.imul(s ^ a, 951274213), o = e ^ Math.imul(o ^ a, 2716044179);
   return e = Math.imul(s ^ e >>> 18, 597399067), t = Math.imul(o ^ t >>> 22, 2869860233), s = Math.imul(e ^ s >>> 17, 951274213), o = Math.imul(t ^ o >>> 19, 2716044179), e ^= t ^ s ^ o, t ^= e, s ^= e, o ^= e, [e >>> 0, t >>> 0, s >>> 0, o >>> 0];
-}, He = (r, e, t, s) => function() {
+}, qe = (r, e, t, s) => function() {
   r |= 0, e |= 0, t |= 0, s |= 0;
   const o = (r + e | 0) + s | 0;
   return s = s + 1 | 0, r = e ^ e >>> 9, e = t + (t << 3) | 0, t = t << 21 | t >>> 11, t = t + o | 0, (o >>> 0) / 4294967296;
@@ -4036,14 +4074,14 @@ const ke = (r) => {
   nodeForceCoefficient: 1,
   barnesHutAreaRadiusThreshold: 0.01,
   barnesHutTheta: 1
-}), ir = (r) => {
+}), dr = (r) => {
   var e, t;
   switch (r == null ? void 0 : r.type) {
     case "custom":
       return r.instance;
     default: {
-      const s = ke((r == null ? void 0 : r.seed) ?? A.seed), o = He(s[0], s[1], s[2], s[3]);
-      return new or({
+      const s = je((r == null ? void 0 : r.seed) ?? A.seed), o = qe(s[0], s[1], s[2], s[3]);
+      return new hr({
         rand: o,
         maxTimeDeltaSec: (r == null ? void 0 : r.maxTimeDeltaSec) ?? A.maxTimeDeltaSec,
         nodeCharge: (r == null ? void 0 : r.nodeCharge) ?? A.nodeCharge,
@@ -4058,27 +4096,29 @@ const ke = (r) => {
       });
     }
   }
-}, j = {
+}, G = {
   staticNodeResolver: () => !1,
   onBeforeApplied: () => {
   },
   onAfterApplied: () => {
   }
-}, nr = (r) => {
+}, cr = (r) => {
   var t, s;
   return {
-    algorithm: ir((r == null ? void 0 : r.algorithm) ?? {}),
-    staticNodeResolver: (r == null ? void 0 : r.staticNodeResolver) ?? j.staticNodeResolver,
-    onBeforeApplied: ((t = r == null ? void 0 : r.events) == null ? void 0 : t.onBeforeApplied) ?? j.onBeforeApplied,
-    onAfterApplied: ((s = r == null ? void 0 : r.events) == null ? void 0 : s.onAfterApplied) ?? j.onAfterApplied
+    algorithm: dr((r == null ? void 0 : r.algorithm) ?? {}),
+    staticNodeResolver: (r == null ? void 0 : r.staticNodeResolver) ?? G.staticNodeResolver,
+    onBeforeApplied: ((t = r == null ? void 0 : r.events) == null ? void 0 : t.onBeforeApplied) ?? G.onBeforeApplied,
+    onAfterApplied: ((s = r == null ? void 0 : r.events) == null ? void 0 : s.onAfterApplied) ?? G.onAfterApplied
   };
-}, ar = (r) => r instanceof Q ? {
-  type: "manual",
+}, lr = (r) => r instanceof K ? {
+  type: "trigger",
   trigger: r
 } : (r == null ? void 0 : r.type) === "topologyChangeMacrotask" ? {
-  type: "topologyChangeMacrotask"
+  type: "topologyChangeSchedule",
+  schedule: Mt
 } : {
-  type: "topologyChangeMicrotask"
+  type: "topologyChangeSchedule",
+  schedule: Rt
 }, F = Object.freeze({
   staticNodeResolver: () => !1,
   onBeforeApplied: () => {
@@ -4096,7 +4136,7 @@ const ke = (r) => {
   d: r.d * e.a + r.e * e.d,
   e: r.d * e.b + r.e * e.e,
   f: r.d * e.c + r.e * e.f + r.f
-}), hr = (r) => {
+}), gr = (r) => {
   const { a: e, b: t, c: s, d: o, e: n, f: a } = r, h = e * n - t * o;
   return {
     a: n / h,
@@ -4107,7 +4147,7 @@ const ke = (r) => {
     f: (s * o - e * a) / h
   };
 };
-class dr {
+class ur {
   resolve(e) {
     if ("shift" in e)
       return this.createShiftBaseMatrix(e.shift);
@@ -4151,7 +4191,7 @@ class dr {
     const s = $(
       t,
       e
-    ), o = hr(t);
+    ), o = gr(t);
     return $(s, o);
   }
   createShiftBaseMatrix(e) {
@@ -4196,7 +4236,7 @@ class dr {
     };
   }
 }
-const cr = (r) => {
+const pr = (r) => {
   if (r === void 0)
     return (o) => o;
   if (typeof r == "function")
@@ -4210,7 +4250,7 @@ const cr = (r) => {
     e: 1,
     f: 0
   };
-  const s = new dr();
+  const s = new ur();
   return e.forEach((o) => {
     const n = s.resolve(o);
     t = $(t, n);
@@ -4221,20 +4261,20 @@ const cr = (r) => {
       y: t.d * n + t.e * a + t.f
     };
   };
-}, lr = (r) => {
+}, wr = (r) => {
   var e, t;
   switch (r == null ? void 0 : r.type) {
     case "custom":
       return r.instance;
     case "hierarchical":
-      return new sr({
+      return new ar({
         layerWidth: r.layerWidth ?? F.hierarchicalLayout.layerWidth,
         layerSpace: r.layerSpace ?? F.hierarchicalLayout.layerSpace,
-        transform: cr(r.transform)
+        transform: pr(r.transform)
       });
     default: {
-      const s = ke((r == null ? void 0 : r.seed) ?? A.seed), o = He(s[0], s[1], s[2], s[3]);
-      return new _t({
+      const s = je((r == null ? void 0 : r.seed) ?? A.seed), o = qe(s[0], s[1], s[2], s[3]);
+      return new sr({
         dtSec: (r == null ? void 0 : r.dtSec) ?? A.dtSec,
         maxIterations: (r == null ? void 0 : r.maxIterations) ?? A.maxIterations,
         rand: o,
@@ -4250,16 +4290,16 @@ const cr = (r) => {
       });
     }
   }
-}, gr = (r) => {
+}, yr = (r) => {
   var e, t;
   return {
-    algorithm: lr(r == null ? void 0 : r.algorithm),
-    applyOn: ar(r == null ? void 0 : r.applyOn),
-    staticNodeResolver: (r == null ? void 0 : r.staticNodeResolver) ?? F.staticNodeResolver,
-    onBeforeApplied: ((e = r == null ? void 0 : r.events) == null ? void 0 : e.onBeforeApplied) ?? F.onBeforeApplied,
-    onAfterApplied: ((t = r == null ? void 0 : r.events) == null ? void 0 : t.onAfterApplied) ?? F.onAfterApplied
+    algorithm: wr(r.algorithm),
+    applyOn: lr(r.applyOn),
+    staticNodeResolver: r.staticNodeResolver ?? F.staticNodeResolver,
+    onBeforeApplied: ((e = r.events) == null ? void 0 : e.onBeforeApplied) ?? F.onBeforeApplied,
+    onAfterApplied: ((t = r.events) == null ? void 0 : t.onAfterApplied) ?? F.onAfterApplied
   };
-}, ur = (r, e) => ({
+}, fr = (r, e) => ({
   ...r,
   onNodeDragStarted: (t) => {
     e.add(t), r.onNodeDragStarted(t);
@@ -4267,17 +4307,58 @@ const cr = (r) => {
   onNodeDragFinished: (t) => {
     e.delete(t), r.onNodeDragFinished(t);
   }
-}), pr = (r, e) => {
-  r.onBeforeNodeRemoved.subscribe((t) => {
+}), mr = (r, e) => {
+  r.graph.onBeforeNodeRemoved.subscribe((t) => {
     e.delete(t);
-  }), r.onBeforeClear.subscribe(() => {
+  }), r.graph.onBeforeClear.subscribe(() => {
+    e.clear();
+  }), r.onBeforeDestroy.subscribe(() => {
     e.clear();
   });
-}, wr = (r, e) => ({
+}, vr = (r, e) => ({
   ...r,
   staticNodeResolver: (t) => r.staticNodeResolver(t) || e.has(t)
-});
-class mr {
+}), q = (r) => () => r, xe = q(0), Ar = () => {
+  let r = 0;
+  return () => r++;
+}, xr = (r, e) => {
+  let t = xe, s = xe;
+  const o = Ar();
+  return r === "incremental" && (t = o), e === "incremental" && (s = o), typeof r == "number" && (t = q(r)), typeof e == "number" && (s = q(e)), typeof r == "function" && (t = r), typeof e == "function" && (s = e), {
+    nodesPriorityFn: t,
+    edgesPriorityFn: s
+  };
+}, Er = (r) => {
+  var t, s, o, n, a;
+  const e = xr(
+    (t = r.nodes) == null ? void 0 : t.priority,
+    (s = r.edges) == null ? void 0 : s.priority
+  );
+  return {
+    nodes: {
+      centerFn: ((o = r.nodes) == null ? void 0 : o.centerFn) ?? Ne,
+      priorityFn: e.nodesPriorityFn
+    },
+    ports: {
+      direction: ((n = r.ports) == null ? void 0 : n.direction) ?? 0
+    },
+    edges: {
+      shapeFactory: he(((a = r.edges) == null ? void 0 : a.shape) ?? {}),
+      priorityFn: e.edgesPriorityFn
+    }
+  };
+}, Sr = (r) => r.applyOn.type === "topologyChangeSchedule" ? r.applyOn.schedule : _, br = (r) => {
+  var s, o;
+  const { canvasDefaults: e } = r, t = r.hasLayout ? Sr(r.layoutParams) : _;
+  return {
+    focus: {
+      contentOffset: ((s = e.focus) == null ? void 0 : s.contentOffset) ?? 100,
+      minContentScale: ((o = e.focus) == null ? void 0 : o.minContentScale) ?? 0,
+      schedule: t
+    }
+  };
+};
+class Nr {
   constructor(e) {
     i(this, "used", !1);
     i(this, "canvasDefaults", {});
@@ -4297,192 +4378,167 @@ class mr {
     i(this, "hasUserDraggableEdges", !1);
     i(this, "hasAnimatedLayout", !1);
     i(this, "hasLayout", !1);
-    i(this, "boxRenderingTrigger", new Q());
+    i(this, "boxRenderingTrigger", new K());
     i(this, "graphStore");
     i(this, "viewportStore");
     i(this, "graph");
     i(this, "viewport");
     i(this, "window", window);
     i(this, "animationStaticNodes", /* @__PURE__ */ new Set());
-    this.element = e, this.viewportStore = new _e(this.element), this.viewport = new Ie(this.viewportStore), this.graphStore = new Se(), this.graph = new Fe(this.graphStore);
+    this.element = e, this.viewportStore = new it(this.element), this.viewport = new $e(this.viewportStore), this.graphStore = new be(), this.graph = new Ie(this.graphStore);
   }
-  /**
-   * specifies default values for graph entities
-   */
   setDefaults(e) {
     return this.canvasDefaults = e, this;
   }
-  /**
-   * enables nodes draggable by user
-   */
   enableUserDraggableNodes(e) {
     return this.hasDraggableNodes = !0, this.dragConfig = e ?? {}, this;
   }
-  /**
-   * enables viewport transformable by user
-   */
   enableUserTransformableViewport(e) {
     return this.hasTransformableViewport = !0, this.transformConfig = e ?? {}, this;
   }
-  /**
-   * enables automatic edges update on node resize
-   */
   enableNodeResizeReactiveEdges() {
     return this.hasNodeResizeReactiveEdges = !0, this;
   }
-  /**
-   * enables built-in virtual scroll behavior, when only nodes and edges close
-   * to viewport are rendered
-   */
   enableVirtualScroll(e) {
     return this.virtualScrollConfig = e, this;
   }
-  /**
-   * enables built-in background rendering
-   */
   enableBackground(e) {
     return this.hasBackground = !0, this.backgroundConfig = e ?? {}, this;
   }
-  /**
-   * enables edge creation by dragging one port to another
-   */
   enableUserConnectablePorts(e) {
     return this.hasUserConnectablePorts = !0, this.connectablePortsConfig = e ?? {}, this;
   }
-  /**
-   * enables edges dragging by dragging one of the adjacent ports
-   */
   enableUserDraggableEdges(e) {
     return this.hasUserDraggableEdges = !0, this.draggableEdgesConfig = e ?? {}, this;
   }
-  /**
-   * enables nodes positioning with specified layout
-   */
   enableLayout(e) {
     return this.layoutConfig = e ?? {}, this.hasLayout = !0, this.hasAnimatedLayout = !1, this;
   }
-  /**
-   * enables animated nodes positioning with specified layout
-   */
   enableAnimatedLayout(e) {
     return this.animatedLayoutConfig = e ?? {}, this.hasAnimatedLayout = !0, this.hasLayout = !1, this;
   }
-  /**
-   * builds final canvas
-   */
   build() {
     if (this.used)
-      throw new qt("CanvasBuilder is a single use object");
+      throw new Jt("CanvasBuilder is a single use object");
     this.used = !0;
-    const e = new Vt(this.element), t = this.createHtmlView(e.main), s = Bt(this.canvasDefaults), o = new Ee(
-      this.graph,
-      this.viewport,
+    const e = new Wt(this.element), t = this.createHtmlView(e.main), s = Er(
+      this.canvasDefaults
+    ), o = new Be(
       this.graphStore,
-      this.viewportStore,
       t,
       s
+    ), n = yr(this.layoutConfig), a = br({
+      canvasDefaults: this.canvasDefaults,
+      hasLayout: this.hasLayout,
+      layoutParams: n
+    }), h = new We(
+      this.graphStore,
+      this.viewportStore,
+      a
+    ), d = new Se(
+      this.graph,
+      this.viewport,
+      o,
+      h
     );
     if (this.hasBackground && re.configure(
-      o,
-      Ht(this.backgroundConfig),
+      d,
+      jt(this.backgroundConfig),
       e.background
-    ), this.hasNodeResizeReactiveEdges && Z.configure(o), this.hasDraggableNodes) {
-      let a = $t(this.dragConfig);
-      this.hasAnimatedLayout && (a = ur(
-        a,
+    ), this.hasNodeResizeReactiveEdges && Q.configure(d), this.hasDraggableNodes) {
+      let g = zt(this.dragConfig);
+      this.hasAnimatedLayout && (g = fr(
+        g,
         this.animationStaticNodes
       )), ee.configure(
-        o,
+        d,
         e.main,
         this.window,
-        a
+        g
       );
     }
     if (this.hasUserConnectablePorts) {
-      const a = Yt(
+      const g = qt(
         this.connectablePortsConfig,
         s.edges.shapeFactory,
         s.ports.direction
       );
       se.configure(
-        o,
+        d,
         e.overlayConnectablePorts,
         this.viewportStore,
         this.window,
-        a
+        g
       );
     }
     if (this.hasUserDraggableEdges) {
-      const a = Xt(
+      const g = Kt(
         this.draggableEdgesConfig,
-        o.graph
+        d.graph
       );
       oe.configure(
-        o,
+        d,
         e.overlayDraggableEdges,
         this.viewportStore,
         this.window,
-        a
+        g
       );
     }
     if (this.virtualScrollConfig !== void 0 ? te.configure(
-      o,
+      d,
       e.main,
       this.window,
       Ae(this.transformConfig),
       this.boxRenderingTrigger,
-      Gt(this.virtualScrollConfig)
-    ) : this.hasTransformableViewport && X.configure(
-      o,
+      Qt(this.virtualScrollConfig)
+    ) : this.hasTransformableViewport && Y.configure(
+      d,
       e.main,
       this.window,
       Ae(this.transformConfig)
-    ), this.hasLayout && Dt.configure(
-      o,
-      gr(this.layoutConfig)
-    ), this.hasAnimatedLayout) {
-      let a = nr(
+    ), this.hasLayout && $t.configure(d, n), this.hasAnimatedLayout) {
+      let g = cr(
         this.animatedLayoutConfig
       );
-      this.hasDraggableNodes && (pr(
-        o.graph,
+      this.hasDraggableNodes && (mr(
+        d,
         this.animationStaticNodes
-      ), a = wr(
-        a,
+      ), g = vr(
+        g,
         this.animationStaticNodes
-      )), ne.configure(o, a, this.window);
+      )), ae.configure(d, g, this.window);
     }
-    const n = () => {
-      e.destroy(), o.onBeforeDestroy.unsubscribe(n);
+    const c = () => {
+      e.destroy(), d.onBeforeDestroy.unsubscribe(c);
     };
-    return o.onBeforeDestroy.subscribe(n), o;
+    return d.onBeforeDestroy.subscribe(c), d;
   }
   createHtmlView(e) {
-    let t = new xe(
+    let t = new Ee(
       this.graphStore,
       this.viewportStore,
       e
     );
-    return this.virtualScrollConfig !== void 0 && (t = new Qe(
+    return this.virtualScrollConfig !== void 0 && (t = new rt(
       t,
       this.graphStore,
       this.boxRenderingTrigger,
-      jt(this.virtualScrollConfig)
-    )), new Ze(t, this.graphStore);
+      Zt(this.virtualScrollConfig)
+    )), t = new st(t, this.graphStore), t;
   }
 }
 export {
-  ft as BezierEdgeShape,
-  mr as CanvasBuilder,
-  qt as CanvasBuilderError,
-  x as CanvasError,
-  D as ConnectionCategory,
-  Le as DirectEdgeShape,
-  Q as EventSubject,
-  yt as HorizontalEdgeShape,
-  Et as InteractiveEdgeError,
-  Ve as InteractiveEdgeShape,
-  yr as MidpointEdgeShape,
-  mt as StraightEdgeShape,
-  vt as VerticalEdgeShape
+  Et as BezierEdgeShape,
+  Nr as CanvasBuilder,
+  Jt as CanvasBuilderError,
+  E as CanvasError,
+  R as ConnectionCategory,
+  Ve as DirectEdgeShape,
+  K as EventSubject,
+  St as HorizontalEdgeShape,
+  Tt as InteractiveEdgeError,
+  Fe as InteractiveEdgeShape,
+  Cr as MidpointEdgeShape,
+  bt as StraightEdgeShape,
+  Pt as VerticalEdgeShape
 };