@3plate/graph-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1612 @@
+// src/graph.js
+import { Map as IMap, List as IList, Set as ISet4 } from "immutable";
+
+// src/options.js
+var defaultOptions = {
+  mergeOrder: ["target", "source"],
+  nodeMargin: 15,
+  dummyNodeSize: 15,
+  defaultPortOffset: 20,
+  nodeAlign: "natural",
+  // 'natural' || 'top' || 'bottom' || 'left' || 'right'
+  edgeSpacing: 10,
+  turnRadius: 10,
+  graphPadding: 20,
+  orientation: "TB",
+  layerMargin: 5,
+  alignIterations: 5,
+  alignThreshold: 10,
+  separateTrackSets: true
+};
+
+// src/graph-nodes.js
+import { Set as ISet } from "immutable";
+
+// src/log.js
+import winston, { loggers } from "winston";
+
+// src/vitest-transport.js
+import Transport from "winston-transport";
+var VitestTransport = class extends Transport {
+  constructor(opts) {
+    super(opts);
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+    const message = info[/* @__PURE__ */ Symbol.for("message")] || info.message;
+    switch (info.level) {
+      case "error":
+        console.error(message);
+        break;
+      case "warn":
+        console.warn(message);
+        break;
+      case "info":
+        console.info(message);
+        break;
+      default:
+        console.log(message);
+    }
+    callback();
+  }
+};
+
+// src/log.js
+var { combine, timestamp, printf, colorize, align } = winston.format;
+var format;
+var transports;
+switch (process.env.NODE_ENV) {
+  case "development":
+  case "test":
+    format = combine(
+      colorize(),
+      align(),
+      printf((info) => `${info.level}: ${info.module ?? "core"}: ${info.message}`)
+    );
+    transports = process.env.VITEST ? [new VitestTransport()] : [new winston.transports.Console()];
+    break;
+  default:
+    format = combine(
+      timestamp({
+        format: "YYYY-MM-DD hh:mm:ss.SSS A"
+      }),
+      json()
+    );
+    transports = [new winston.transports.Console()];
+    break;
+}
+var log = winston.createLogger({
+  level: process.env.LOG_LEVEL || "warn",
+  format,
+  transports
+});
+function logger(module) {
+  return log.child({ module });
+}
+
+// src/graph-nodes.js
+var log2 = logger("nodes");
+var GraphNodes = {
+  /**
+   * Add a node to the graph
+   * 
+   * @param {Object} props - Node properties
+   * @param {string} props.id - Node ID (required)
+   * @param {string} props.layerId - Node layer ID (optional)
+   * @returns {Object} The added node
+   */
+  _addNode(props) {
+    const node = {
+      ...props,
+      edges: { in: ISet(), out: ISet() },
+      segs: { in: ISet(), out: ISet() },
+      aligned: {}
+    };
+    if (!node.layerId)
+      node.layerId = this._layerAtIndex(0).id;
+    this._layerAddNode(node.layerId, node.id);
+    this.nodes.set(node.id, node);
+    this._markDirty(node.id);
+    return node;
+  },
+  /**
+   * Add a dummy node to the graph
+   * 
+   * @param {Object} props - Node properties
+   * @param {string} props.layerId - Node layer ID (optional)
+   * @returns {Object} The added node
+   */
+  _addDummy(props) {
+    return this._addNode({
+      ...props,
+      id: this._newDummyId(),
+      isDummy: true,
+      dims: {
+        width: this.options.dummyNodeSize,
+        height: this.options.dummyNodeSize
+      }
+    });
+  },
+  /**
+   * Remove a node from the graph
+   * 
+   * @param {string} nodeId - Node ID
+   */
+  _deleteNode(nodeId) {
+    log2.debug(`deleting node ${nodeId}`);
+    const node = this.nodes.get(nodeId);
+    if (!node) return;
+    this._layerDeleteNode(node.layerId, nodeId);
+    for (const relId of this._relIds(nodeId))
+      this._deleteRelById(relId);
+    this.nodes.delete(nodeId);
+  },
+  /**
+   * Check if a node is unlinked (has no relationships)
+   * 
+   * @param {string} nodeId - Node ID
+   * @returns {boolean} True if the node is unlinked, false otherwise
+   */
+  _nodeIsUnlinked(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return false;
+    return node.edges.in.isEmpty() && node.edges.out.isEmpty() && node.segs.in.isEmpty() && node.segs.out.isEmpty();
+  },
+  /**
+   * Generate a new dummy node ID
+   * 
+   * @returns {string} A new dummy node ID
+   */
+  _newDummyId() {
+    return `d:${this.nextDummyId++}`;
+  },
+  /**
+   * Check if an ID is a dummy node ID
+   * 
+   * @param {string} nodeId - ID to check (required)
+   * @returns {boolean} True if the ID is a dummy node ID, false otherwise
+   */
+  _isDummyId(nodeId) {
+    return nodeId.startsWith("d:");
+  },
+  /**
+   * Iterate over all node IDs
+   * 
+   * @returns {Iterator} Iterator over node IDs
+   */
+  *_nodeIds() {
+    yield* this.nodes.keySeq();
+  }
+};
+
+// src/graph-edges.js
+var log3 = logger("edges");
+var GraphEdges = {
+  /**
+   * Get a relationship (edge or segment) by ID
+   * 
+   * @param {string} relId - Relationship ID
+   * @returns {Object} The relationship
+   */
+  _getRel(relId) {
+    return relId.startsWith("e:") ? this.getEdge(relId) : this.getSeg(relId);
+  },
+  /**
+   * Generate the ID of an edge or segment. The ID is in the format
+   * 
+   * {type}:{source.id}[.{source.port}]-[{type}]-{target.id}[.{target.port}]
+   * 
+   * Examples:
+   * 
+   * e:n1--n2
+   * e:n1.out1--n2
+   * e:n1--n2.in1
+   * e:n1.out1--n2.in1
+   * e:n1.out1-bold-n2.in1
+   * 
+   * @param {Object} obj - Edge or segment
+   * @param {string} type - Type of relationship
+   * @returns {string} The relationship ID
+   */
+  _edgeSegId(obj, type, side = "both") {
+    let source = "", target = "";
+    if (side == "source" || side == "both") {
+      source = obj.source.id;
+      if (obj.source.port) source += `.${obj.source.port}`;
+      source += "-";
+    }
+    if (side == "target" || side == "both") {
+      target = "-" + obj.target.id;
+      if (obj.target.port) target += `.${obj.target.port}`;
+    }
+    return `${type}:${source}${obj.type || ""}${target}`;
+  },
+  /**
+   * Generate the ID of an edge
+   * 
+   * @param {Object} edge - Edge
+   * @returns {string} The edge ID
+   */
+  _edgeId(edge) {
+    return this._edgeSegId(edge, "e");
+  },
+  /**
+   * Generate the ID of a segment
+   * 
+   * @param {Object} seg - Segment
+   * @returns {string} The segment ID
+   */
+  _segId(seg) {
+    return this._edgeSegId(seg, "s");
+  },
+  /**
+   * Generate a new layer ID
+   * 
+   * @returns {string} A new layer ID
+   */
+  _newLayerId() {
+    return `l:${this.nextLayerId++}`;
+  },
+  /**
+   * Link a segment to its source and target nodes
+   * 
+   * @param {Object} seg - Segment
+   */
+  _linkSeg(seg) {
+    this._linkObj(seg, "segs");
+  },
+  /**
+   * Link an edge to its source and target nodes
+   * 
+   * @param {Object} edge - Edge
+   */
+  _linkEdge(edge) {
+    this._linkObj(edge, "edges");
+  },
+  /**
+   * Unlink a segment from its source and target nodes
+   * 
+   * @param {Object} seg - Segment
+   */
+  _unlinkSeg(seg) {
+    this._unlinkRel(seg, "segs");
+  },
+  /**
+   * Unlink an edge from its source and target nodes
+   * 
+   * @param {Object} edge - Edge
+   */
+  _unlinkEdge(edge) {
+    this._unlinkRel(edge, "edges");
+  },
+  /**
+   * Link a relationship (edge or segment) to its source and target nodes
+   * 
+   * @param {Object} rel - Relationship
+   * @param {string} type - Type of relationship
+   */
+  _linkObj(rel, type) {
+    this._addRel(rel.source.id, rel.id, type, "out");
+    this._addRel(rel.target.id, rel.id, type, "in");
+  },
+  /**
+   * Unlink a relationship (edge or segment) from its source and target nodes
+   * 
+   * @param {Object} rel - Relationship
+   * @param {string} type - Type of relationship
+   */
+  _unlinkRel(rel, type) {
+    log3.debug(`unlinking rel ${rel.id} from ${rel.source.id} and ${rel.target.id}`);
+    this._deleteRel(rel.source.id, rel.id, type, "out");
+    this._deleteRel(rel.target.id, rel.id, type, "in");
+  },
+  /**
+   * Modify a relationship (edge or segment) in the graph.
+   * Either adds or deletes the relation from the appropriate
+   * immutable set on the node.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} relId - Relationship ID
+   * @param {string} type - Type of relationship
+   * @param {string} dir - Direction of relationship
+   * @param {string} op - Operation (add or delete)
+   */
+  _modRel(nodeId, relId, type, dir, op) {
+    log3.debug(`${op} rel ${relId} on ${nodeId} ${type} ${dir}`);
+    let node = this.getNode(nodeId);
+    let sets = node[type];
+    let set = sets[dir];
+    const exists = set.has(relId);
+    if (op == "add" && exists) return;
+    else if (op == "delete" && !exists) return;
+    set = set[op](relId);
+    sets = { ...sets, [dir]: set };
+    node = { ...node, [type]: sets };
+    this.nodes.set(nodeId, node);
+    this._markDirty(nodeId);
+  },
+  /**
+   * Add a relationship (edge or segment) to its source and target nodes
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} relId - Relationship ID
+   * @param {string} type - Type of relationship
+   * @param {string} dir - Direction of relationship
+   */
+  _addRel(nodeId, relId, type, dir) {
+    this._modRel(nodeId, relId, type, dir, "add");
+  },
+  /**
+   * Delete a relationship (edge or segment) from its source and target nodes
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} relId - Relationship ID
+   * @param {string} type - Type of relationship
+   * @param {string} dir - Direction of relationship
+   */
+  _deleteRel(nodeId, relId, type, dir) {
+    this._modRel(nodeId, relId, type, dir, "delete");
+  },
+  /**
+   * Add a new edge to the graph and link it to its source and target nodes
+   * 
+   * @param {Object} props - Edge properties
+   * @returns {Object} The edge object
+   */
+  _addEdge(props) {
+    const edge = {
+      ...props,
+      id: this._edgeId(props),
+      segs: []
+    };
+    this.edges.set(edge.id, edge);
+    this._linkEdge(edge);
+    return edge;
+  },
+  /**
+   * Remove an edge from the graph and unlink it from its source and target nodes.
+   * Also remove it from the edge list of any segments it includes. Any segments
+   * that become unused are deleted.
+   * 
+   * @param {string} edgeId - Edge ID
+   */
+  _deleteEdge(edgeId) {
+    log3.debug(`deleting edge ${edgeId}`);
+    const edge = this.edges.get(edgeId);
+    if (!edge) return;
+    log3.debug(`unlinking edge ${edgeId}`);
+    this._unlinkEdge(edge);
+    for (const segId of edge.segs)
+      this._segDeleteEdge(segId, edgeId);
+    this.edges.delete(edgeId);
+  },
+  /**
+   * Add a new segment to the graph and link it to its source and target nodes
+   * 
+   * @param {Object} props - Segment properties
+   * @returns {Object} The segment object
+   */
+  _addSeg(props) {
+    const seg = {
+      ...props,
+      id: this._segId(props)
+    };
+    this.segs.set(seg.id, seg);
+    this._linkSeg(seg);
+    return seg;
+  },
+  /**
+   * Remove a segment from the graph and unlink it from its source and target nodes.
+   * If a source or target is a dummy node and becomes unlinked (no segments), delete it.
+   * 
+   * @param {string} segId - Segment ID
+   */
+  _deleteSeg(segId) {
+    const seg = this.segs.get(segId);
+    if (!seg) return;
+    this._unlinkSeg(seg);
+    this.segs.delete(segId);
+    for (const side of ["source", "target"]) {
+      const node = this.getNode(seg[side].id);
+      if (node.isDummy && this._nodeIsUnlinked(node.id))
+        this._deleteNode(node.id);
+    }
+  },
+  /**
+   * Remove a relationship (edge or segment) from the graph and unlink it from its source and target nodes
+   * 
+   * @param {string} relId - Relationship ID
+   */
+  _deleteRelById(relId) {
+    if (relId.startsWith("e:"))
+      this._deleteEdge(relId);
+    else
+      this._deleteSeg(relId);
+  },
+  /**
+   * Return an iterator over the relationships (edges and segments) of a node.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} type - Type of relationship (defaults to 'both')
+   * @param {string} dir - Direction of relationship (defaults to 'both')
+   * @returns {Iterator} Iterator over the relationships
+   */
+  *_relIds(nodeId, type = "both", dir = "both") {
+    const node = this.getNode(nodeId);
+    const types = type == "both" ? ["edges", "segs"] : [type];
+    const dirs = dir == "both" ? ["in", "out"] : [dir];
+    for (const type2 of types)
+      for (const dir2 of dirs)
+        yield* node[type2][dir2];
+  },
+  /**
+   * Return an iterator over the relationships (edges and segments) of a node.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} type - Type of relationship (defaults to 'both')
+   * @param {string} dir - Direction of relationship (defaults to 'both')
+   * @returns {Iterator} Iterator over the relationships
+   */
+  *_rels(nodeId, type = "both", dir = "both") {
+    for (const relId of this._relIds(nodeId, type, dir))
+      yield this._getRel(relId);
+  },
+  /**
+   * Return an iterator over the neighbors of a node.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} type - Type of relationship (defaults to 'both')
+   * @param {string} dir - Direction of relationship (defaults to 'both')
+   * @returns {Iterator} Iterator over the neighbors
+   */
+  *_adjIds(nodeId, type = "both", dir = "both") {
+    const nodeIds = /* @__PURE__ */ new Set();
+    if (dir == "both" || dir == "in")
+      for (const rel of this._rels(nodeId, type, "in"))
+        nodeIds.add(rel.source.id);
+    if (dir == "both" || dir == "out")
+      for (const rel of this._rels(nodeId, type, "out"))
+        nodeIds.add(rel.target.id);
+    yield* nodeIds;
+  },
+  /**
+   * Return an iterator over the neighbors of a node.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {string} type - Type of relationship (defaults to 'both')
+   * @param {string} dir - Direction of relationship (defaults to 'both')
+   */
+  *_adjs(nodeId, type = "both", dir = "both") {
+    for (const adjId of this._adjIds(nodeId, type, dir))
+      yield this.getNode(adjId);
+  },
+  /**
+   * Remove a segment from an edge
+   * 
+   * @param {string} edgeId - Edge ID
+   * @param {string} segId - Segment ID
+   */
+  _edgeDeleteSeg(edgeId, segId) {
+    const edge = this.getEdge(edgeId);
+    const segs = edge.segs.filter((id) => id == segId);
+    this.edges.set(edgeId, { ...edge, segs });
+  },
+  /**
+   * Remove an edge from a segment and delete the segment if it becomes empty.
+   * 
+   * @param {string} segId - Segment ID
+   * @param {string} edgeId - Edge ID
+   */
+  _segDeleteEdge(segId, edgeId) {
+    const seg = this.getSeg(segId);
+    const edges = seg.edges.remove(edgeId);
+    if (edges.size == 0)
+      this._deleteSeg(segId);
+    else
+      this.segs.set(segId, { ...seg, edges });
+  },
+  /**
+   * Replace a segment in an edge
+   * 
+   * @param {string} edgeId - Edge ID
+   * @param {string} oldSegId - Old segment ID
+   * @param {string} newSegId - New segment ID
+   */
+  _edgeReplaceSeg(edgeId, oldSegId, newSegId) {
+    log3.debug(`edge ${edgeId}: replacing segment ${oldSegId} with ${newSegId}`);
+    this._segDeleteEdge(oldSegId, edgeId);
+    const edge = this.getEdge(edgeId);
+    const segs = edge.segs.map((id) => id == oldSegId ? newSegId : id);
+    this.edges.set(edgeId, { ...edge, segs });
+  }
+};
+
+// src/graph-layers.js
+import { Set as ISet2, Seq } from "immutable";
+var log4 = logger("layers");
+var GraphLayers = {
+  /**
+   * Get the index of a node's layer
+   * 
+   * @param {string} nodeId - Node ID
+   * @returns {number} The index of the node's layer
+   */
+  _nodeLayerIndex(nodeId) {
+    return this.getLayer(this.getNode(nodeId).layerId).index;
+  },
+  /**
+   * Add a node to a layer.
+   * 
+   * @param {string} layerId - Layer ID
+   * @param {string} nodeId - Node ID
+   */
+  _layerAddNode(layerId, nodeId) {
+    const layer = this.getLayer(layerId);
+    this.layers.set(layerId, {
+      ...layer,
+      nodes: layer.nodes.add(nodeId)
+    });
+  },
+  /**
+   * Remove a node from a layer.
+   * 
+   * @param {string} layerId - Layer ID
+   * @param {string} nodeId - Node ID
+   */
+  _layerDeleteNode(layerId, nodeId) {
+    const layer = this.getLayer(layerId);
+    let sorted = layer.sorted;
+    if (sorted) {
+      const idx = sorted.findIndex((id) => id == nodeId);
+      if (idx >= 0) {
+        sorted = sorted.filter((id) => id != nodeId);
+        for (let i = idx; i < sorted.length; i++) {
+          const node = this.getNode(sorted[i]);
+          this.nodes.set(sorted[i], { ...node, index: i });
+        }
+      }
+    }
+    this.layers.set(layerId, {
+      ...layer,
+      nodes: layer.nodes.delete(nodeId),
+      sorted
+    });
+    if (this._layerIsEmpty(layerId))
+      this._deleteLayer(layerId);
+  },
+  /**
+   * Update layers in two passes:
+   * 
+   *  - Move children up or down to just below lowest parent
+   *  - Move parents down to just above highest child
+   * 
+   * While moving nodes between layers, if any layer becomes empty,
+   * remove it from the list; at the end, renumber the remaining layers
+   */
+  _updateLayers() {
+    const stack = [...this._dirtyNodes].filter((id) => {
+      const node = this.nodes.get(id);
+      if (!node || node.isDummy) return false;
+      return true;
+    });
+    stack.sort((a, b) => this._nodeLayerIndex(b) - this._nodeLayerIndex(a));
+    const phase2 = new Set(stack);
+    const moved = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const id = stack.pop();
+      const parentIds = [...this._adjIds(id, "edges", "in")];
+      let correctLayer;
+      if (parentIds.length == 0) {
+        correctLayer = 0;
+      } else {
+        const maxParent = Seq(parentIds).map((id2) => this._nodeLayerIndex(id2)).max();
+        correctLayer = maxParent + 1;
+      }
+      const curLayer = this._nodeLayerIndex(id);
+      if (curLayer != correctLayer) {
+        moved.add(id);
+        this._moveNodeLayer(id, correctLayer);
+        stack.push(...this._adjIds(id, "edges", "out"));
+        for (const parentId of parentIds)
+          phase2.add(parentId);
+      }
+    }
+    const byLayer = /* @__PURE__ */ new Map();
+    const addParent = (nodeId) => {
+      let set;
+      const layerId = this.getNode(nodeId).layerId;
+      if (!byLayer.has(layerId)) {
+        set = /* @__PURE__ */ new Set();
+        byLayer.set(layerId, set);
+      } else {
+        set = byLayer.get(layerId);
+      }
+      set.add(nodeId);
+    };
+    for (const id of phase2) addParent(id);
+    const layerIds = [...byLayer.keys()].sort(
+      (a, b) => this.layers.get(b).index - this.layers.get(a).index
+    );
+    for (const layerId of layerIds) {
+      const curLayer = this.layers.get(layerId).index;
+      for (const parentId of byLayer.get(layerId)) {
+        const children = [...this._adjIds(parentId, "edges", "out")];
+        if (children.length == 0) continue;
+        const minChild = Seq(children).map((id) => this._nodeLayerIndex(id)).min();
+        const correctLayer = minChild - 1;
+        if (curLayer != correctLayer) {
+          moved.add(parentId);
+          this._moveNodeLayer(parentId, correctLayer);
+          for (const grandParentId of this._adjIds(parentId, "edges", "in"))
+            addParent(grandParentId);
+        }
+      }
+    }
+    for (const id of moved)
+      for (const edgeId of this._relIds(id, "edges", "both"))
+        this._dirtyEdges.add(edgeId);
+    for (const edge of this.changes.addedEdges)
+      this._dirtyEdges.add(this._edgeId(edge));
+  },
+  /**
+   * Move the node to a new layer, crushing the original layer
+   * if it becomes empty
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {number} newIndex - New layer index
+   */
+  _moveNodeLayer(nodeId, newIndex) {
+    log4.debug(`moving node ${nodeId} to layer ${newIndex}`);
+    const node = this.getNode(nodeId);
+    const oldLayerId = node.layerId;
+    const newLayerId = this._layerAtIndex(newIndex).id;
+    this._layerDeleteNode(oldLayerId, nodeId);
+    this._layerAddNode(newLayerId, nodeId);
+    this.nodes.set(nodeId, { ...node, layerId: newLayerId });
+  },
+  /**
+   * Get the layer at the given index, creating it if necessary
+   * 
+   * @param {number} index - Layer index
+   * @returns {Object} The layer
+   */
+  _layerAtIndex(index) {
+    while (index >= this.layerList.size)
+      this._addLayer();
+    const layerId = this.layerList.get(index);
+    return this.layers.get(layerId);
+  },
+  /**
+   * Add a new layer. The caller should add a node to it so that
+   * it's not empty.
+   */
+  _addLayer() {
+    const id = `l:${this.nextLayerId++}`;
+    this.layers.set(id, {
+      id,
+      index: this.layerList.size,
+      nodes: ISet2()
+    });
+    this.layerList.push(id);
+    this.dirtyLayers.add(id);
+  },
+  /**
+   * Check if a layer is empty
+   * 
+   * @param {string} layerId - Layer ID
+   * @returns {boolean} True if the layer is empty
+   */
+  _layerIsEmpty(layerId) {
+    return this.layers.get(layerId).nodes.size == 0;
+  },
+  /**
+   * Delete a layer and renumber the remaining layers
+   * 
+   * @param {string} layerId - Layer ID
+   */
+  _deleteLayer(layerId) {
+    const layer = this.getLayer(layerId);
+    const index = layer.index;
+    log4.debug(`deleting layer ${layerId} at index ${index} / ${this.layerList.size}`);
+    this.layerList.remove(index);
+    this.layers.delete(layerId);
+    for (let i = index; i < this.layerList.size; i++) {
+      const id = this.layerList.get(i);
+      this.layers.set(id, {
+        ...this.layers.get(id),
+        index: i
+      });
+    }
+  }
+};
+
+// src/mutator.js
+var Mutator = class {
+  constructor() {
+    this.changes = {
+      addedNodes: [],
+      removedNodes: [],
+      addedEdges: [],
+      removedEdges: []
+    };
+  }
+  addNode(node) {
+    this.changes.addedNodes.push(node);
+  }
+  addNodes(...nodes) {
+    nodes.forEach((node) => this.addNode(node));
+  }
+  addEdge(edge) {
+    this.changes.addedEdges.push(edge);
+  }
+  addEdges(...edges) {
+    edges.forEach((edge) => this.addEdge(edge));
+  }
+  removeNode(node) {
+    if (typeof node == "string")
+      this.changes.removedNodes.push({ id: node });
+    else
+      this.changes.removedNodes.push(node);
+  }
+  removeNodes(...nodes) {
+    nodes.forEach((node) => this.removeNode(node));
+  }
+  removeEdge(edge) {
+    this.changes.removedEdges.push(edge);
+  }
+  removeEdges(...edges) {
+    edges.forEach((edge) => this.removeEdge(edge));
+  }
+};
+
+// src/graph-api.js
+var GraphAPI = {
+  isEmpty() {
+    return this.nodes.isEmpty();
+  },
+  numNodes() {
+    return this.nodes.size;
+  },
+  numEdges() {
+    return this.edges.size;
+  },
+  getNode(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (node) return node;
+    throw new Error(`cannot find node ${nodeId}`);
+  },
+  getEdge(edgeId) {
+    const edge = this.edges.get(edgeId);
+    if (edge) return edge;
+    throw new Error(`cannot find edge ${edgeId}`);
+  },
+  getSeg(segId) {
+    const seg = this.segs.get(segId);
+    if (seg) return seg;
+    throw new Error(`cannot find segment ${segId}`);
+  },
+  getLayer(layerId) {
+    const layer = this.layers.get(layerId);
+    if (layer) return layer;
+    throw new Error(`cannot find layer ${layerId}`);
+  },
+  hasNode(nodeId) {
+    return this.nodes.has(nodeId);
+  },
+  hasEdge(edgeId) {
+    return this.edges.has(edgeId);
+  },
+  withMutations(callback) {
+    const mut = new Mutator();
+    callback(mut);
+    return new Graph({ prior: this, changes: mut.changes });
+  },
+  addNodes(...nodes) {
+    return this.withMutations((mutator) => {
+      nodes.forEach((node) => mutator.addNode(node));
+    });
+  },
+  addNode(node) {
+    return this.withMutations((mutator) => {
+      mutator.addNode(node);
+    });
+  },
+  addEdges(...edges) {
+    return this.withMutations((mutator) => {
+      edges.forEach((edge) => mutator.addEdge(edge));
+    });
+  },
+  addEdge(edge) {
+    return this.withMutations((mutator) => {
+      mutator.addEdge(edge);
+    });
+  },
+  removeNodes(...nodes) {
+    return this.withMutations((mutator) => {
+      nodes.forEach((node) => mutator.removeNode(node));
+    });
+  },
+  removeNode(node) {
+    return this.withMutations((mutator) => {
+      mutator.removeNode(node);
+    });
+  },
+  removeEdges(...edges) {
+    return this.withMutations((mutator) => {
+      edges.forEach((edge) => mutator.removeEdge(edge));
+    });
+  },
+  removeEdge(edge) {
+    return this.withMutations((mutator) => {
+      mutator.removeEdge(edge);
+    });
+  }
+};
+
+// src/graph-mutate.js
+var GraphMutate = {
+  /**
+   * Put the graph in mutate mode, where all the listed
+   * stateful (immutable) collections are also put in
+   * mutate mode. Within the callback, the collections
+   * are modified in place.
+   * 
+   * @param {Function} callback - The callback to run
+   */
+  _mutate(callback) {
+    const state = [
+      "nodes",
+      "edges",
+      "layers",
+      "layerList",
+      "segs"
+    ];
+    const mut = () => {
+      if (state.length == 0) return callback();
+      const name = state.shift();
+      this[name] = this[name].withMutations((map) => {
+        this[name] = map;
+        mut();
+      });
+    };
+    mut();
+  },
+  /**
+   * Update the graph by applying changes and updating
+   * the computed graph state.
+   */
+  _update() {
+    if (!this._dirty) return;
+    this._mutate(() => {
+      this._applyChanges();
+      this._checkCycles();
+      this._updateLayers();
+      this._updateDummies();
+      this._mergeDummies();
+      this._positionNodes();
+      this._alignAll();
+    });
+    this._dirty = false;
+  },
+  /**
+   * Mark a node as dirty if it exists in the graph.
+   * 
+   * @param {string} nodeId - Node ID
+   */
+  _markDirty(nodeId) {
+    if (this.nodes.has(nodeId))
+      this._dirtyNodes.add(nodeId);
+  },
+  /**
+   * Apply node and edge changes to the graph
+   */
+  _applyChanges() {
+    for (const node of this.changes.addedNodes)
+      this._addNode(node);
+    for (const node of this.changes.removedNodes)
+      this._deleteNode(node.id);
+    for (const edge of this.changes.addedEdges)
+      this._addEdge(edge);
+    for (const edge of this.changes.removedEdges)
+      this._deleteEdge(edge.id ?? this._edgeId(edge));
+  }
+};
+
+// src/graph-cycle.js
+var GraphCycle = {
+  /**
+   * Get the cycle info for a node
+   * 
+   * @param {string} nodeId - Node ID
+   * @returns {string} The cycle info
+   */
+  _cycleInfo(nodeId) {
+    return nodeId;
+  },
+  /**
+   * Check for cycles in the graph. If any are detected, throw an error.
+   * Depending on the size of the graph and the number of changes, use
+   * different algorithms.
+   */
+  _checkCycles() {
+    const totalNodes = this.nodes.size;
+    const newStuff = this.changes.addedNodes.length + this.changes.addedEdges.length;
+    const changeRatio = newStuff / totalNodes;
+    if (changeRatio > 0.2 || totalNodes < 20)
+      this._checkCyclesFull();
+    else
+      this._checkCyclesIncremental();
+  },
+  /**
+   * Use a graph traversal algorithm to check for cycles.
+   */
+  _checkCyclesFull() {
+    const colorMap = /* @__PURE__ */ new Map();
+    const parentMap = /* @__PURE__ */ new Map();
+    const white = 0, gray = 1, black = 2;
+    let start, end;
+    const visit = (nodeId2) => {
+      colorMap.set(nodeId2, gray);
+      for (const nextId of this._adjIds(nodeId2, "edges", "out")) {
+        switch (colorMap.get(nextId) ?? white) {
+          case gray:
+            start = nextId;
+            end = nodeId2;
+            return true;
+          case white:
+            parentMap.set(nextId, nodeId2);
+            if (visit(nextId)) return true;
+        }
+      }
+      colorMap.set(nodeId2, black);
+      return false;
+    };
+    for (const nodeId2 of this._nodeIds())
+      if ((colorMap.get(nodeId2) ?? white) == white) {
+        if (visit(nodeId2)) break;
+      }
+    if (!start) return;
+    const cycle = [this._cycleInfo(start)];
+    let nodeId = end;
+    while (nodeId != start) {
+      cycle.push(this._cycleInfo(nodeId));
+      nodeId = parentMap.get(nodeId);
+    }
+    cycle.push(this._cycleInfo(start));
+    cycle.reverse();
+    const error = new Error(`Cycle detected: ${cycle.join(" \u2192 ")}`);
+    error.cycle = cycle;
+    throw error;
+  },
+  /**
+   * Check for cycles in the graph incrementally. For each potential
+   * new edge, if the source is < the target, there won't be a cycle.
+   * Otherwise, check if there is a route from the target to the source;
+   * if so, throw an error.
+   */
+  _checkCyclesIncremental() {
+    for (const edge of this.changes.addedEdges) {
+      const layer1 = this._nodeLayerIndex(edge.source.id);
+      const layer2 = this._nodeLayerIndex(edge.target.id);
+      if (layer1 < layer2) continue;
+      const route = this._findRoute(edge.target.id, edge.source.id);
+      if (!route) continue;
+      const cycle = route.map((id) => this._cycleInfo(id));
+      cycle.reverse();
+      const error = new Error(`Cycle detected: ${cycle.join(" \u2192 ")}`);
+      error.cycle = cycle;
+      throw error;
+    }
+  },
+  /**
+   * Find a route from the source to the target.
+   * 
+   * @param {string} sourceId - Source node ID
+   * @param {string} targetId - Target node ID
+   * @returns {Array} The route, or null if no route exists
+   */
+  _findRoute(sourceId, targetId) {
+    const parentMap = /* @__PURE__ */ new Map();
+    const queue = [sourceId];
+    const visited = /* @__PURE__ */ new Set([sourceId]);
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (nodeId == targetId) {
+        const route = [];
+        let currId = targetId;
+        while (currId != sourceId) {
+          route.push(currId);
+          currId = parentMap.get(currId);
+        }
+        route.push(sourceId);
+        route.reverse();
+        return route;
+      }
+      for (const nextId of this._adjIds(nodeId, "edges", "out")) {
+        if (!visited.has(nextId)) {
+          visited.add(nextId);
+          parentMap.set(nextId, nodeId);
+          queue.push(nextId);
+        }
+      }
+    }
+    return null;
+  }
+};
+
+// src/graph-dummy.js
+import { Set as ISet3 } from "immutable";
+var log5 = logger("dummy");
+var GraphDummy = {
+  /**
+   * Update dummy nodes and segments. Dummy nodes are inserted along
+   * edges that span multiple layers. Segments are one-hop connections
+   * between adjacent layers. Edges store an array of their segment IDs.
+   * Since segments can be re-used once dummies are merged, the segments
+   * also store a set of the edges that use them.
+   */
+  _updateDummies() {
+    for (const edgeId of this._dirtyEdges) {
+      const edge = this.getEdge(edgeId);
+      const { type } = edge;
+      const sourceLayer = this._nodeLayerIndex(edge.source.id);
+      const targetLayer = this._nodeLayerIndex(edge.target.id);
+      let segIndex = 0;
+      let changed = false;
+      let source = edge.source;
+      const segs = edge.segs;
+      for (let layerIndex = sourceLayer + 1; layerIndex <= targetLayer; layerIndex++) {
+        const layer = this._layerAtIndex(layerIndex);
+        while (true) {
+          const segId = segs[segIndex];
+          let seg = segId ? this.getSeg(segId) : null;
+          const segLayer = seg ? this._nodeLayerIndex(seg.target.id) : null;
+          if (segIndex == segs.length || segLayer > layerIndex) {
+            let target;
+            if (layerIndex == targetLayer) {
+              target = edge.target;
+            } else {
+              const dummy = this._addDummy({
+                edgeId,
+                layerId: layer.id
+              });
+              target = { ...target, id: dummy.id };
+            }
+            seg = this._addSeg({ source, target, type, edges: ISet3([edgeId]) });
+            log5.debug(`edge ${edgeId}: adding segment ${seg.id} from ${source.id} at layer ${layerIndex - 1} to ${target.id} at layer ${layerIndex}`);
+            segs.splice(segIndex, 0, seg.id);
+            changed = true;
+          } else if (segLayer < layerIndex || seg.source.id != source.id || seg.source.port != source.port || layerIndex == targetLayer && (seg.target.id != edge.target.id || seg.target.port != edge.target.port)) {
+            log5.debug(`edge ${edgeId}: removing segment ${seg.id} from layer ${layerIndex - 1} to layer ${layerIndex}`);
+            this._segDeleteEdge(segId, edgeId);
+            segs.splice(segIndex, 1);
+            changed = true;
+            continue;
+          }
+          source = seg.target;
+          segIndex++;
+          break;
+        }
+      }
+      while (segIndex < segs.length) {
+        log5.debug(`edge ${edgeId}: removing trailing segment ${segs[segIndex]}`);
+        this._segDeleteEdge(segs[segIndex], edgeId);
+        segs.splice(segIndex, 1);
+        changed = true;
+        segIndex++;
+      }
+      if (changed) {
+        log5.debug(`edge ${edgeId}: updated segments to ${segs.join(", ")}`);
+        this.edges.set(edgeId, { ...edge, segs });
+      }
+    }
+  },
+  _mergeDummies() {
+    for (const side of this.options.mergeOrder)
+      this._mergeScan(side);
+  },
+  _mergeScan(side) {
+    let layers = [...this.layerList];
+    if (side == "target") layers.reverse();
+    const dir = side == "source" ? "in" : "out";
+    const altSide = side == "source" ? "target" : "source";
+    const altDir = altSide == "source" ? "in" : "out";
+    log5.debug(`merging dummies by ${side}`);
+    for (const layerId of layers) {
+      let layer = this.layers.get(layerId);
+      const groups = /* @__PURE__ */ new Map();
+      for (const nodeId of layer.nodes) {
+        if (!this._isDummyId(nodeId)) continue;
+        const node = this.getNode(nodeId);
+        if (node.merged) continue;
+        const edge = this.getEdge(node.edgeId);
+        const key = this._edgeSegId(edge, "k", side);
+        if (!groups.has(key)) groups.set(key, /* @__PURE__ */ new Set());
+        groups.get(key).add(node);
+      }
+      for (const [key, group] of groups) {
+        if (group.size == 1) continue;
+        const edgeIds = [...group].map((node) => node.edgeId);
+        const dummy = this._addDummy({ edgeIds, layerId, merged: true });
+        let seg;
+        for (const old of group) {
+          for (const segId of this._relIds(old.id, "segs", dir)) {
+            if (!seg) {
+              const example = this.getSeg(segId);
+              seg = this._addSeg({
+                ...example,
+                edges: ISet3([old.edgeId]),
+                [altSide]: { ...example[altSide], id: dummy.id }
+              });
+            }
+            this._edgeReplaceSeg(old.edgeId, segId, seg.id);
+          }
+        }
+        for (const old of group) {
+          for (const segId of this._relIds(old.id, "segs", altDir)) {
+            const example = this.getSeg(segId);
+            const seg2 = this._addSeg({
+              ...example,
+              edges: ISet3([old.edgeId]),
+              [side]: { ...example[side], id: dummy.id }
+            });
+            this._edgeReplaceSeg(old.edgeId, segId, seg2.id);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/graph-pos.js
+import { Seq as Seq2 } from "immutable";
+var log6 = logger("pos");
+var GraphPos = {
+  /**
+   * Find the minimum index of incoming edges to a node
+   * 
+   * @param {Object} node - Node
+   * @returns {number} The minimum index of incoming edges
+   */
+  _parentIndex(node) {
+    const parents = Seq2(this._adjs(node.id, "segs", "in"));
+    const pidx = parents.map((p) => p.index).min();
+    log6.debug(`node ${node.id}: parent index ${pidx}`);
+    if (pidx !== void 0) return pidx;
+    return node.isDummy ? -Infinity : Infinity;
+  },
+  /**
+   * Compare two nodes based on their parent index and natural ordering
+   * 
+   * @param {Object} aId - First node ID
+   * @param {Object} bId - Second node ID
+   * @returns {number} -1, 0, or 1
+   */
+  _compareNodes(aId, bId, pidxs) {
+    const ai = pidxs.get(aId);
+    const bi = pidxs.get(bId);
+    if (ai !== bi) return ai - bi;
+    const a = this.getNode(aId);
+    const b = this.getNode(bId);
+    if (a.isDummy && !b.isDummy) return -1;
+    if (!a.isDummy && b.isDummy) return 1;
+    if (!a.isDummy) return a.id.localeCompare(b.id);
+    const minA = a.edgeId ?? Seq2(a.edgeIds).min();
+    const minB = b.edgeId ?? Seq2(b.edgeIds).min();
+    return minA.localeCompare(minB);
+  },
+  /**
+   * Does a first pass of assigning X and Y positions to nodes.
+   * Nodes in each layer are ordered first by the order of their parents, and
+   * then by comparing their natural ordering. The Y position is assigned based
+   * on the layer index, and the X position is assigned based on the node index
+   * within the layer.
+   */
+  _positionNodes() {
+    var _a;
+    for (const nodeId of this._dirtyNodes) {
+      const node = this.nodes.get(nodeId);
+      if (!node) continue;
+      const layerId = node.layerId;
+      this.dirtyLayers.add(layerId);
+    }
+    let adjustNext = false;
+    for (const layerId of this.layerList) {
+      if (!adjustNext && !this.dirtyLayers.has(layerId)) continue;
+      adjustNext = false;
+      const layer = this.getLayer(layerId);
+      const pidxs = /* @__PURE__ */ new Map();
+      for (const nodeId of layer.nodes)
+        pidxs.set(nodeId, this._parentIndex(this.getNode(nodeId)));
+      const sorted = [...layer.nodes].sort((a, b) => this._compareNodes(a, b, pidxs));
+      if (layer.sorted && sorted.every((nodeId, i) => layer.sorted[i] == nodeId)) continue;
+      this.dirtyLayers.add(layerId);
+      this.layers.set(layerId, { ...layer, sorted });
+      adjustNext = true;
+      let lpos = 0;
+      for (let i = 0; i < sorted.length; i++) {
+        const node = this.getNode(sorted[i]);
+        log6.debug(`node ${node.id}: final index ${i}`);
+        this.nodes.set(node.id, { ...node, index: i, lpos });
+        const size = ((_a = node.dims) == null ? void 0 : _a[this._width]) ?? 0;
+        lpos += size + this.options.nodeMargin;
+      }
+    }
+  },
+  /** 
+   * Align the nodes based on either a specified procedure, or a default procedure,
+   * which consists of a number of iterations of:
+   * 
+   *  - Align children to parents
+   *  - Align parents to children
+   *  - Compact layout
+   */
+  _alignAll() {
+    if (this.options.layoutSteps !== void 0) {
+      for (const step of this.options.layoutSteps)
+        this[`_${step}`]();
+    } else {
+      for (let i = 0; i < this.options.alignIterations; i++) {
+        let anyChanged = this._alignChildren() || this._alignParents() || this._compact();
+        if (!anyChanged) break;
+      }
+    }
+    return this;
+  },
+  // Align children to their parents.
+  // 
+  //  - Sweep layers first to last
+  //  - Sweep nodes left to right
+  //  - Move nodes only to the right
+  //  - On overlap, shift the colliding nodes to the right
+  _alignChildren() {
+    return this._alignNodes(false, false, false, "in", false);
+  },
+  // Align parents to their children.
+  // 
+  //  - Sweep layers last to first
+  //  - Sweep nodes right to left
+  //  - Move nodes only to the left
+  //  - On overlap, abort the shift
+  _alignParents() {
+    return this._alignNodes(true, true, false, "out", true);
+  },
+  /**
+   * Aligns nodes in each layer, attempting to align child nodes
+   * with their parents (or vice versa). If this causes nodes to overlap as
+   * a result, they are pushed to the right (or left, depending on reverseMove).
+   * However, if conservative is true, nodes will only be moved if they would
+   * not cause a collision with another node.
+   * 
+   * "Aligned" means that the edge between the nodes is straight. This could mean
+   * the nodes themselves are not aligned, if they have different anchor positions.
+   * 
+   * @param {boolean} reverseLayers - Whether to reverse the order of layers
+   * @param {boolean} reverseNodes - Whether to reverse the order of nodes within each layer
+   * @param {boolean} reverseMove - Whether to move nodes to the left or right
+   * @param {'in' | 'out'} dir - Whether to align nodes based on incoming or outgoing edges
+   * @param {boolean} conservative - Whether to move nodes only if they would not cause a collision
+   */
+  _alignNodes(reverseLayers, reverseNodes, reverseMove, dir, conservative) {
+    let layerIds = [...this.layerList];
+    let anyChanged = false;
+    if (reverseLayers) layerIds.reverse();
+    let adjustNext = false;
+    for (const layerId of layerIds) {
+      if (!adjustNext && !this.dirtyLayers.has(layerId)) continue;
+      adjustNext = false;
+      while (true) {
+        let changed = false;
+        const nodeIds = this._sortLayer(layerId, reverseNodes);
+        for (const nodeId of nodeIds) {
+          const { isAligned, pos: newPos, nodeId: otherId } = this._nearestNode(nodeId, dir, reverseMove, !reverseMove);
+          if (isAligned || newPos === void 0) continue;
+          if (this._shiftNode(nodeId, otherId, dir, newPos, reverseMove, conservative)) {
+            changed = true;
+            anyChanged = true;
+            break;
+          }
+        }
+        if (!changed) break;
+        this.dirtyLayers.add(layerId);
+        adjustNext = true;
+      }
+    }
+    return anyChanged;
+  },
+  /**
+   * Sort the nodes of a layer by their position and store
+   * on layer.sorted. Return the sorted array, reversed if requested.
+   * 
+   * @param {string} layerId - The ID of the layer to sort
+   * @param {boolean} reverseNodes - Whether to reverse the order of nodes within the layer
+   * @returns {string[]} The sorted array of node IDs
+   */
+  _sortLayer(layerId, reverseNodes) {
+    const layer = this.getLayer(layerId);
+    const sorted = [...layer.nodes];
+    sorted.sort((a, b) => this.getNode(a).lpos - this.getNode(b).lpos);
+    if (!sorted.every((nodeId, i) => layer.sorted[i] == nodeId)) {
+      this.dirtyLayers.add(layerId);
+      this.layers.set(layerId, { ...layer, sorted });
+      for (let i = 0; i < sorted.length; i++) {
+        const node = this.getNode(sorted[i]);
+        if (node.index !== i)
+          this.nodes.set(sorted[i], { ...node, index: i });
+      }
+    }
+    if (reverseNodes)
+      return sorted.toReversed();
+    return sorted;
+  },
+  /**
+   * Find the nearest node in the given relation that is in the correct direction.
+   * If the nearest is already aligned, return isAligned: true. Nearest means that the anchor
+   * positions are close and in the right direction. Returns both the near node
+   * and the position to which the given node should move in order to be aligned.
+   * 
+   * @param {string} nodeId - The ID of the node to find the nearest node for
+   * @param {'in' | 'out'} dir - The direction to find the nearest node in
+   * @param {boolean} allowLeft - Whether to allow the nearest node to be to the left of the given node
+   * @param {boolean} allowRight - Whether to allow the nearest node to be to the right of the given node
+   * @returns {{ nodeId: string, pos: number, isAligned: boolean }} The nearest node and the position to which the given node should move
+   */
+  _nearestNode(nodeId, dir, allowLeft, allowRight) {
+    const node = this.getNode(nodeId);
+    let minDist = Infinity;
+    let bestPos, bestNodeId;
+    const mySide = dir == "in" ? "target" : "source";
+    const altSide = dir == "in" ? "source" : "target";
+    for (const seg of this._rels(nodeId, "segs", dir)) {
+      const altId = seg[altSide].id;
+      const myPos = this._anchorPos(seg, mySide)[this._x];
+      const altPos = this._anchorPos(seg, altSide)[this._x];
+      const diff = altPos - myPos;
+      if (diff == 0) return { nodeId: altId, isAligned: true };
+      if (diff < 0 && !allowLeft) continue;
+      if (diff > 0 && !allowRight) continue;
+      const dist = Math.abs(diff);
+      if (dist < minDist) {
+        minDist = dist;
+        bestNodeId = altId;
+        bestPos = node.lpos + diff;
+      }
+    }
+    return { nodeId: bestNodeId, pos: bestPos, isAligned: false };
+  },
+  /**
+   * Get the anchor point for an edge connection on a node
+   * 
+   * @param {Object} seg - The segment to get the anchor point for
+   * @param {'source' | 'target'} side - The side of the segment to get the anchor point for
+   * @returns {{ x: number, y: number }} The anchor point
+   */
+  _anchorPos(seg, side) {
+    var _a, _b;
+    const { _x, _y } = this;
+    const nodeId = seg[side].id;
+    const node = this.getNode(nodeId);
+    let p = { [_x]: node.lpos, ...node.pos || {} };
+    let w = ((_a = node.dims) == null ? void 0 : _a[this._width]) ?? 0;
+    let h = ((_b = node.dims) == null ? void 0 : _b[this._height]) ?? 0;
+    if (node.isDummy)
+      return { [_x]: p[_x] + w / 2, [_y]: p[_y] + h / 2 };
+    p[_x] += this._nodePortOffset(nodeId, seg[side].port);
+    if (side == "source" == this._reverse)
+      p[_y] += h;
+    return p;
+  },
+  /**
+   * Return an offset for a node's port; port is optional.
+   * 
+   * @param {string} nodeId - Node ID to check
+   * @param {string} port - The port to compute offset for
+   */
+  _nodePortOffset(nodeId, port) {
+    if (!port) return this.options.defaultPortOffset;
+    return this.options.defaultPortOffset;
+  },
+  /** 
+   * Shift the node to the given x position, pushing it to the right (or left, depending on reverseMove).
+   * If conservative is true, nodes will only be moved if they would not cause a collision with another node.
+   * If a collision does occur, recursively move collided nodes to find a valid position. 
+   * If the shift is successful, this node and the aligned node are linked explicitly; if the aligned
+   * node was already set, it is unlinked first.
+   * 
+   * @param {string} nodeId - ID of node to shift
+   * @param {string} alignId - ID of node we're aligning to
+   * @param {'in' | 'out'} dir - Direction of aligned node from this node
+   * @param {number} lpos - Position within layer to shift node to
+   * @param {boolean} reverseMove - Whether to move nodes to the left or right
+   * @param {boolean} conservative - Whether to move nodes only if they would not cause a collision
+   */
+  _shiftNode(nodeId, alignId, dir, lpos, reverseMove, conservative) {
+    var _a, _b;
+    const node = this.getNode(nodeId);
+    if (!conservative)
+      this._markAligned(nodeId, alignId, dir, lpos);
+    const space = this.options.nodeMargin;
+    const nodeWidth = ((_a = node.dims) == null ? void 0 : _a[this._width]) ?? 0;
+    const aMin = lpos - space, aMax = lpos + nodeWidth + space;
+    repeat:
+      for (const otherId of this.getLayer(node.layerId).nodes) {
+        if (otherId == nodeId) continue;
+        const other = this.getNode(otherId);
+        const opos = other.lpos;
+        const otherWidth = ((_b = other.dims) == null ? void 0 : _b[this._width]) ?? 0;
+        const bMin = opos, bMax = opos + otherWidth;
+        if (aMin < bMax && bMin < aMax) {
+          if (conservative) return false;
+          const safePos = reverseMove ? aMin - otherWidth : aMax;
+          this._shiftNode(otherId, void 0, dir, safePos, reverseMove, conservative);
+          continue repeat;
+        }
+      }
+    if (conservative)
+      this._markAligned(nodeId, alignId, dir, lpos);
+    return true;
+  },
+  /**
+   * Mark nodes as aligned, unlinking any existing alignment.
+   * 
+   * @param {string} nodeId - Node being aligned
+   * @param {string} otherId - Node we're aligning to
+   * @param {'in' | 'out'} dir - direction of other from node
+   * @param {number} lpos - new layer position
+   */
+  _markAligned(nodeId, otherId, dir, lpos) {
+    const node = this.getNode(nodeId);
+    const alt = dir == "in" ? "out" : "in";
+    if (node.aligned[dir]) {
+      const ex = this.getNode(node.aligned[dir]);
+      this.nodes.set(node.aligned[dir], { ...ex, aligned: { ...ex.aligned, [alt]: void 0 } });
+    }
+    if (otherId) {
+      const other = this.getNode(otherId);
+      this.nodes.set(otherId, { ...other, aligned: { ...other.aligned, [alt]: nodeId } });
+    }
+    this.nodes.set(nodeId, { ...node, lpos, aligned: { [dir]: otherId, [alt]: void 0 } });
+  },
+  /**
+   * Iterate over all nodes aligned with the given node, including itself,
+   * exactly once.
+   * 
+   * @param {string} nodeId - Node ID
+   * @param {'in' | 'out' | 'both'} dir - direction of alignment
+   * @returns {Iterator<Object>} Iterator over aligned nodes
+   */
+  *_aligned(nodeId, dir) {
+    const visit = function* (node2, dir2) {
+      const otherId = node2.aligned[dir2];
+      if (!otherId) return;
+      const other = this.getNode(otherId);
+      yield other;
+      yield* visit.call(this, other, dir2);
+    }.bind(this);
+    const node = this.getNode(nodeId);
+    yield node;
+    if (dir == "both") {
+      yield* visit(node, "in");
+      yield* visit(node, "out");
+    } else {
+      yield* visit(node, dir);
+    }
+  },
+  /** 
+   * Get the node ID immediately to the left of the given node in the same layer
+   * 
+   * @param {Object} node - Node to get left of
+   * @returns {string | null} Node ID to the left of the given node, or null if there is none
+   */
+  _leftOf(node) {
+    if (node.index == 0) return null;
+    return this.getLayer(node.layerId).sorted[node.index - 1];
+  },
+  /**
+   * Get the node id immediately to the right of the given node in the same layer
+   * 
+   * @param {Object} node - Node to get right of
+   * @returns {string | null} Node ID to the right of the given node, or null if there is none
+   */
+  _rightOf(node) {
+    const layer = this.getLayer(node.layerId);
+    if (node.index == layer.sorted.length - 1) return null;
+    return layer.sorted[node.index + 1];
+  },
+  /**
+   * Compact tries to eliminate empty space between nodes
+   */
+  _compact() {
+    var _a;
+    let anyChanged = false;
+    for (const layerId of this.layerList) {
+      const layer = this.getLayer(layerId);
+      if (layer.sorted.length < 2) continue;
+      for (const nodeId of layer.sorted) {
+        const node = this.getNode(nodeId);
+        if (node.index == 0) continue;
+        let minGap = Infinity;
+        const stack = [];
+        for (const right of this._aligned(nodeId, "both")) {
+          stack.push(right);
+          const leftId = this._leftOf(right);
+          if (!leftId) return;
+          const left = this.getNode(leftId);
+          const leftWidth = ((_a = left.dims) == null ? void 0 : _a[this._width]) ?? 0;
+          const gap = right.lpos - left.lpos - leftWidth;
+          if (gap < minGap) minGap = gap;
+        }
+        const delta = minGap - this.options.nodeMargin;
+        if (delta <= 0) continue;
+        anyChanged = true;
+        for (const right of stack)
+          this.nodes.set(right.id, { ...right, lpos: right.lpos - delta });
+      }
+    }
+    return anyChanged;
+  }
+};
+
+// src/graph.js
+var Graph = class {
+  constructor({ prior, changes, options, nodes, edges } = {}) {
+    this.nodes = (prior == null ? void 0 : prior.nodes) ?? IMap();
+    this.edges = (prior == null ? void 0 : prior.edges) ?? IMap();
+    this.layers = (prior == null ? void 0 : prior.layers) ?? IMap();
+    this.layerList = (prior == null ? void 0 : prior.layerList) ?? IList();
+    this.segs = (prior == null ? void 0 : prior.segs) ?? IMap();
+    this.nextLayerId = (prior == null ? void 0 : prior.nextLayerId) ?? 0;
+    this.nextDummyId = (prior == null ? void 0 : prior.nextDummyId) ?? 0;
+    this._dirtyNodes = /* @__PURE__ */ new Set();
+    this._dirtyEdges = /* @__PURE__ */ new Set();
+    this.dirtyLayers = /* @__PURE__ */ new Set();
+    this.prior = prior;
+    this.options = {
+      ...defaultOptions,
+      ...(prior == null ? void 0 : prior.options) ?? {},
+      ...options ?? {}
+    };
+    this.changes = changes ?? {
+      addedNodes: [],
+      removedNodes: [],
+      addedEdges: [],
+      removedEdges: []
+    };
+    this.changes.addedNodes.push(...nodes || []);
+    this.changes.addedEdges.push(...edges || []);
+    this._dirty = this.changes.addedNodes.length > 0 || this.changes.removedNodes.length > 0 || this.changes.addedEdges.length > 0 || this.changes.removedEdges.length > 0;
+    this._reverse = this.options.orientation === "BT" || this.options.orientation === "RL";
+    this._vertical = this.options.orientation === "TB" || this.options.orientation === "BT";
+    this._height = this._vertical ? "height" : "width";
+    this._width = this._vertical ? "width" : "height";
+    this._x = this._vertical ? "x" : "y";
+    this._y = this._vertical ? "y" : "x";
+    this._d = {
+      x: this._vertical ? 0 : this._reverse ? -1 : 1,
+      y: this._vertical ? this._reverse ? -1 : 1 : 0
+    };
+    const natAligns = { TB: "top", BT: "bottom", LR: "left", RL: "right" };
+    if (this.options.nodeAlign == "natural")
+      this._natural = true;
+    else
+      this._natural = natAligns[this.options.orientation] == this.options.nodeAlign;
+    if (this._dirty) this._update();
+  }
+};
+var mixins = [
+  GraphNodes,
+  GraphEdges,
+  GraphLayers,
+  GraphAPI,
+  GraphMutate,
+  GraphCycle,
+  GraphDummy,
+  GraphPos
+];
+for (const mixin of mixins)
+  Object.assign(Graph.prototype, mixin);
+export {
+  Graph
+};