@hkyhy/marsun-components-core 0.1.113 → 0.1.114

package/dist/node_modules/@antv/graphlib/esm/graph.js

@@ -0,0 +1,780 @@
+var M = Object.defineProperty;
+var N = (u, n, e) => n in u ? M(u, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[n] = e;
+var o = (u, n, e) => N(u, typeof n != "symbol" ? n + "" : n, e);
+import b from "../../event-emitter/esm/index.js";
+import { GraphView as w } from "./graphView.js";
+import { doDFS as p, doBFS as l } from "./utils/traverse.js";
+class E extends b {
+  /**
+   * Create a new Graph instance.
+   * @param options - The options to initialize a graph. See {@link GraphOptions}.
+   *
+   * ```ts
+   * const graph = new Graph({
+   *   // Optional, initial nodes.
+   *   nodes: [
+   *     // Each node has a unique ID.
+   *     { id: 'A', foo: 1 },
+   *     { id: 'B', foo: 1 },
+   *   ],
+   *   // Optional, initial edges.
+   *   edges: [
+   *     { id: 'C', source: 'B', target: 'B', weight: 1 },
+   *   ],
+   *   // Optional, called with a GraphChangedEvent.
+   *   onChanged: (event) => {
+   *     console.log(event);
+   *   }
+   * });
+   * ```
+   */
+  constructor(e) {
+    super();
+    o(this, "nodeMap", /* @__PURE__ */ new Map());
+    o(this, "edgeMap", /* @__PURE__ */ new Map());
+    o(this, "inEdgesMap", /* @__PURE__ */ new Map());
+    o(this, "outEdgesMap", /* @__PURE__ */ new Map());
+    o(this, "bothEdgesMap", /* @__PURE__ */ new Map());
+    o(this, "treeIndices", /* @__PURE__ */ new Map());
+    o(this, "changes", []);
+    o(this, "batchCount", 0);
+    /**
+     * This function is called with a {@link GraphChangedEvent} each time a graph change happened.
+     *
+     * `event.changes` contains all the graph changes in order since last `onChanged`.
+     */
+    o(this, "onChanged", () => {
+    });
+    /**
+     * Batch several graph changes into one.
+     *
+     * Make several changes, but dispatch only one ChangedEvent at the end of batch:
+     * ```ts
+     * graph.batch(() => {
+     *   graph.addNodes([]);
+     *   graph.addEdges([]);
+     * });
+     * ```
+     *
+     * Batches can be nested. Only the outermost batch will dispatch a ChangedEvent:
+     * ```ts
+     * graph.batch(() => {
+     *   graph.addNodes([]);
+     *   graph.batch(() => {
+     *     graph.addEdges([]);
+     *   });
+     * });
+     * ```
+     */
+    o(this, "batch", (e) => {
+      this.batchCount += 1, e(), this.batchCount -= 1, this.batchCount || this.commit();
+    });
+    e && (e.nodes && this.addNodes(e.nodes), e.edges && this.addEdges(e.edges), e.tree && this.addTree(e.tree), e.onChanged && (this.onChanged = e.onChanged));
+  }
+  /**
+   * Reset changes and dispatch a ChangedEvent.
+   */
+  commit() {
+    const e = this.changes;
+    this.changes = [];
+    const t = {
+      graph: this,
+      changes: e
+    };
+    this.emit("changed", t), this.onChanged(t);
+  }
+  /**
+   * Reduce the number of ordered graph changes by dropping or merging unnecessary changes.
+   *
+   * For example, if we update a node and remove it in a batch:
+   *
+   * ```ts
+   * graph.batch(() => {
+   *   graph.updateNodeData('A', 'foo', 2);
+   *   graph.removeNode('A');
+   * });
+   * ```
+   *
+   * We get 2 atomic graph changes like
+   *
+   * ```ts
+   * [
+   *   { type: 'NodeDataUpdated', id: 'A', propertyName: 'foo', oldValue: 1, newValue: 2 },
+   *   { type: 'NodeRemoved', value: { id: 'A', data: { foo: 2 } },
+   * ]
+   * ```
+   *
+   * Since node 'A' has been removed, we actually have no need to handle with NodeDataUpdated change.
+   *
+   * `reduceChanges()` here helps us remove such changes.
+   */
+  reduceChanges(e) {
+    let t = [];
+    return e.forEach((s) => {
+      switch (s.type) {
+        case "NodeRemoved": {
+          let d = !1;
+          t = t.filter((r) => {
+            if (r.type === "NodeAdded") {
+              const i = r.value.id === s.value.id;
+              return i && (d = !0), !i;
+            } else {
+              if (r.type === "NodeDataUpdated")
+                return r.id !== s.value.id;
+              if (r.type === "TreeStructureChanged")
+                return r.nodeId !== s.value.id;
+            }
+            return !0;
+          }), d || t.push(s);
+          break;
+        }
+        case "EdgeRemoved": {
+          let d = !1;
+          t = t.filter((r) => {
+            if (r.type === "EdgeAdded") {
+              const i = r.value.id === s.value.id;
+              return i && (d = !0), !i;
+            } else if (r.type === "EdgeDataUpdated" || r.type === "EdgeUpdated")
+              return r.id !== s.value.id;
+            return !0;
+          }), d || t.push(s);
+          break;
+        }
+        case "NodeDataUpdated":
+        case "EdgeDataUpdated":
+        case "EdgeUpdated": {
+          const d = t.findIndex((i) => i.type === s.type && i.id === s.id && (s.propertyName === void 0 || i.propertyName === s.propertyName)), r = t[d];
+          r ? s.propertyName !== void 0 ? r.newValue = s.newValue : (t.splice(d, 1), t.push(s)) : t.push(s);
+          break;
+        }
+        case "TreeStructureDetached": {
+          t = t.filter((d) => d.type === "TreeStructureAttached" || d.type === "TreeStructureChanged" ? d.treeKey !== s.treeKey : !0), t.push(s);
+          break;
+        }
+        case "TreeStructureChanged": {
+          const d = t.find((r) => r.type === "TreeStructureChanged" && r.treeKey === s.treeKey && r.nodeId === s.nodeId);
+          d ? d.newParentId = s.newParentId : t.push(s);
+          break;
+        }
+        default:
+          t.push(s);
+          break;
+      }
+    }), t;
+  }
+  // ================= Node =================
+  checkNodeExistence(e) {
+    this.getNode(e);
+  }
+  /**
+   * Check if a node exists in the graph.
+   * @group NodeMethods
+   */
+  hasNode(e) {
+    return this.nodeMap.has(e);
+  }
+  /**
+   * Tell if two nodes are neighbors.
+   * @group NodeMethods
+   */
+  areNeighbors(e, t) {
+    return this.getNeighbors(t).some((s) => s.id === e);
+  }
+  /**
+   * Get the node data with given ID.
+   * @group NodeMethods
+   */
+  getNode(e) {
+    const t = this.nodeMap.get(e);
+    if (!t)
+      throw new Error("Node not found for id: " + e);
+    return t;
+  }
+  /**
+   * Given a node ID, find all edges of the node.
+   * @param id - ID of the node
+   * @param direction - Edge direction, defaults to 'both'.
+   * @group NodeMethods
+   */
+  getRelatedEdges(e, t) {
+    if (this.checkNodeExistence(e), t === "in") {
+      const s = this.inEdgesMap.get(e);
+      return Array.from(s);
+    } else if (t === "out") {
+      const s = this.outEdgesMap.get(e);
+      return Array.from(s);
+    } else {
+      const s = this.bothEdgesMap.get(e);
+      return Array.from(s);
+    }
+  }
+  /**
+   * Get the degree of the given node.
+   * @group NodeMethods
+   */
+  getDegree(e, t) {
+    return this.getRelatedEdges(e, t).length;
+  }
+  /**
+   * Get all successors of the given node.
+   */
+  getSuccessors(e) {
+    const s = this.getRelatedEdges(e, "out").map((d) => this.getNode(d.target));
+    return Array.from(new Set(s));
+  }
+  /**
+   * Get all predecessors of the given node.
+   */
+  getPredecessors(e) {
+    const s = this.getRelatedEdges(e, "in").map((d) => this.getNode(d.source));
+    return Array.from(new Set(s));
+  }
+  /**
+   * Given a node ID, find its neighbors.
+   * @param id - ID of the node
+   * @group NodeMethods
+   */
+  getNeighbors(e) {
+    const t = this.getPredecessors(e), s = this.getSuccessors(e);
+    return Array.from(/* @__PURE__ */ new Set([...t, ...s]));
+  }
+  doAddNode(e) {
+    if (this.hasNode(e.id))
+      throw new Error("Node already exists: " + e.id);
+    this.nodeMap.set(e.id, e), this.inEdgesMap.set(e.id, /* @__PURE__ */ new Set()), this.outEdgesMap.set(e.id, /* @__PURE__ */ new Set()), this.bothEdgesMap.set(e.id, /* @__PURE__ */ new Set()), this.treeIndices.forEach((t) => {
+      t.childrenMap.set(e.id, /* @__PURE__ */ new Set());
+    }), this.changes.push({ type: "NodeAdded", value: e });
+  }
+  /**
+   * Add all nodes of the given array, or iterable, into the graph.
+   * @group NodeMethods
+   */
+  addNodes(e) {
+    this.batch(() => {
+      for (const t of e)
+        this.doAddNode(t);
+    });
+  }
+  /**
+   * Add a single node into the graph.
+   * @group NodeMethods
+   */
+  addNode(e) {
+    this.addNodes([e]);
+  }
+  doRemoveNode(e) {
+    const t = this.getNode(e), s = this.bothEdgesMap.get(e);
+    s == null || s.forEach((d) => this.doRemoveEdge(d.id)), this.nodeMap.delete(e), this.treeIndices.forEach((d) => {
+      var i, a;
+      (i = d.childrenMap.get(e)) == null || i.forEach((h) => {
+        d.parentMap.delete(h.id);
+      });
+      const r = d.parentMap.get(e);
+      r && ((a = d.childrenMap.get(r.id)) == null || a.delete(t)), d.parentMap.delete(e), d.childrenMap.delete(e);
+    }), this.bothEdgesMap.delete(e), this.inEdgesMap.delete(e), this.outEdgesMap.delete(e), this.changes.push({ type: "NodeRemoved", value: t });
+  }
+  /**
+   * Remove nodes and their attached edges from the graph.
+   * @group NodeMethods
+   */
+  removeNodes(e) {
+    this.batch(() => {
+      e.forEach((t) => this.doRemoveNode(t));
+    });
+  }
+  /**
+   * Remove a single node and its attached edges from the graph.
+   * @group NodeMethods
+   */
+  removeNode(e) {
+    this.removeNodes([e]);
+  }
+  updateNodeDataProperty(e, t, s) {
+    const d = this.getNode(e);
+    this.batch(() => {
+      const r = d.data[t], i = s;
+      d.data[t] = i, this.changes.push({
+        type: "NodeDataUpdated",
+        id: e,
+        propertyName: t,
+        oldValue: r,
+        newValue: i
+      });
+    });
+  }
+  /**
+   * Like Object.assign, merge all properties of `path` to the node data.
+   * @param id Node ID.
+   * @param patch A data object to merge.
+   */
+  mergeNodeData(e, t) {
+    this.batch(() => {
+      Object.entries(t).forEach(([s, d]) => {
+        this.updateNodeDataProperty(e, s, d);
+      });
+    });
+  }
+  updateNodeData(...e) {
+    const t = e[0], s = this.getNode(t);
+    if (typeof e[1] == "string") {
+      this.updateNodeDataProperty(t, e[1], e[2]);
+      return;
+    }
+    let d;
+    if (typeof e[1] == "function") {
+      const r = e[1];
+      d = r(s.data);
+    } else typeof e[1] == "object" && (d = e[1]);
+    this.batch(() => {
+      const r = s.data, i = d;
+      s.data = d, this.changes.push({
+        type: "NodeDataUpdated",
+        id: t,
+        oldValue: r,
+        newValue: i
+      });
+    });
+  }
+  // ================= Edge =================
+  checkEdgeExistence(e) {
+    if (!this.hasEdge(e))
+      throw new Error("Edge not found for id: " + e);
+  }
+  /**
+   * Check if an edge exists in the graph.
+   * @group NodeMethods
+   */
+  hasEdge(e) {
+    return this.edgeMap.has(e);
+  }
+  /**
+   * Get the edge data with given ID.
+   * @group EdgeMethods
+   */
+  getEdge(e) {
+    return this.checkEdgeExistence(e), this.edgeMap.get(e);
+  }
+  /**
+   * Get the edge, the source node, and the target node by an edge ID.
+   * @group EdgeMethods
+   */
+  getEdgeDetail(e) {
+    const t = this.getEdge(e);
+    return {
+      edge: t,
+      source: this.getNode(t.source),
+      target: this.getNode(t.target)
+    };
+  }
+  doAddEdge(e) {
+    if (this.hasEdge(e.id))
+      throw new Error("Edge already exists: " + e.id);
+    this.checkNodeExistence(e.source), this.checkNodeExistence(e.target), this.edgeMap.set(e.id, e);
+    const t = this.inEdgesMap.get(e.target), s = this.outEdgesMap.get(e.source), d = this.bothEdgesMap.get(e.source), r = this.bothEdgesMap.get(e.target);
+    t.add(e), s.add(e), d.add(e), r.add(e), this.changes.push({ type: "EdgeAdded", value: e });
+  }
+  /**
+   * Add all edges of the given iterable(an array, a set, etc.) into the graph.
+   * @group EdgeMethods
+   */
+  addEdges(e) {
+    this.batch(() => {
+      for (const t of e)
+        this.doAddEdge(t);
+    });
+  }
+  /**
+   * Add a single edge pointing from `source` to `target` into the graph.
+   *
+   * ```ts
+   * graph.addNode({ id: 'NodeA' });
+   * graph.addNode({ id: 'NodeB' });
+   * graph.addEdge({ id: 'EdgeA', source: 'NodeA', target: 'NodeB' });
+   * ```
+   *
+   * If `source` or `target` were not found in the current graph, it throws an Error.
+   * @group EdgeMethods
+   */
+  addEdge(e) {
+    this.addEdges([e]);
+  }
+  doRemoveEdge(e) {
+    const t = this.getEdge(e), s = this.outEdgesMap.get(t.source), d = this.inEdgesMap.get(t.target), r = this.bothEdgesMap.get(t.source), i = this.bothEdgesMap.get(t.target);
+    s.delete(t), d.delete(t), r.delete(t), i.delete(t), this.edgeMap.delete(e), this.changes.push({ type: "EdgeRemoved", value: t });
+  }
+  /**
+   * Remove edges whose id was included in the given id list.
+   * @group EdgeMethods
+   */
+  removeEdges(e) {
+    this.batch(() => {
+      e.forEach((t) => this.doRemoveEdge(t));
+    });
+  }
+  /**
+   * Remove a single edge of the given id.
+   * @group EdgeMethods
+   */
+  removeEdge(e) {
+    this.removeEdges([e]);
+  }
+  /**
+   * Change the source of an edge. The source must be found in current graph.
+   * @group EdgeMethods
+   */
+  updateEdgeSource(e, t) {
+    const s = this.getEdge(e);
+    this.checkNodeExistence(t);
+    const d = s.source, r = t;
+    this.outEdgesMap.get(d).delete(s), this.bothEdgesMap.get(d).delete(s), this.outEdgesMap.get(r).add(s), this.bothEdgesMap.get(r).add(s), s.source = t, this.batch(() => {
+      this.changes.push({
+        type: "EdgeUpdated",
+        id: e,
+        propertyName: "source",
+        oldValue: d,
+        newValue: r
+      });
+    });
+  }
+  /**
+   * Change the target of an edge. The target must be found in current graph.
+   * @group EdgeMethods
+   */
+  updateEdgeTarget(e, t) {
+    const s = this.getEdge(e);
+    this.checkNodeExistence(t);
+    const d = s.target, r = t;
+    this.inEdgesMap.get(d).delete(s), this.bothEdgesMap.get(d).delete(s), this.inEdgesMap.get(r).add(s), this.bothEdgesMap.get(r).add(s), s.target = t, this.batch(() => {
+      this.changes.push({
+        type: "EdgeUpdated",
+        id: e,
+        propertyName: "target",
+        oldValue: d,
+        newValue: r
+      });
+    });
+  }
+  updateEdgeDataProperty(e, t, s) {
+    const d = this.getEdge(e);
+    this.batch(() => {
+      const r = d.data[t], i = s;
+      d.data[t] = i, this.changes.push({
+        type: "EdgeDataUpdated",
+        id: e,
+        propertyName: t,
+        oldValue: r,
+        newValue: i
+      });
+    });
+  }
+  updateEdgeData(...e) {
+    const t = e[0], s = this.getEdge(t);
+    if (typeof e[1] == "string") {
+      this.updateEdgeDataProperty(t, e[1], e[2]);
+      return;
+    }
+    let d;
+    if (typeof e[1] == "function") {
+      const r = e[1];
+      d = r(s.data);
+    } else typeof e[1] == "object" && (d = e[1]);
+    this.batch(() => {
+      const r = s.data, i = d;
+      s.data = d, this.changes.push({
+        type: "EdgeDataUpdated",
+        id: t,
+        oldValue: r,
+        newValue: i
+      });
+    });
+  }
+  /**
+   * @group EdgeMethods
+   */
+  mergeEdgeData(e, t) {
+    this.batch(() => {
+      Object.entries(t).forEach(([s, d]) => {
+        this.updateEdgeDataProperty(e, s, d);
+      });
+    });
+  }
+  // ================= Tree =================
+  checkTreeExistence(e) {
+    if (!this.hasTreeStructure(e))
+      throw new Error("Tree structure not found for treeKey: " + e);
+  }
+  hasTreeStructure(e) {
+    return this.treeIndices.has(e);
+  }
+  /**
+   * Attach a new tree structure representing the hierarchy of all nodes in the graph.
+   * @param treeKey A unique key of the tree structure. You can attach multiple tree structures with different keys.
+   *
+   * ```ts
+   * const graph = new Graph({
+   *   nodes: [{ id: 1 }, { id: 2 }, { id: 3 }],
+   * });
+   * graph.attachTreeStructure('Inheritance');
+   * graph.setParent(2, 1, 'Inheritance');
+   * graph.setParent(3, 1, 'Inheritance');
+   * graph.getRoots('Inheritance'); // [1]
+   * graph.getChildren(1, 'Inheritance'); // [2,3]
+   * ```
+   * @group TreeMethods
+   */
+  attachTreeStructure(e) {
+    this.treeIndices.has(e) || (this.treeIndices.set(e, {
+      parentMap: /* @__PURE__ */ new Map(),
+      childrenMap: /* @__PURE__ */ new Map()
+    }), this.batch(() => {
+      this.changes.push({
+        type: "TreeStructureAttached",
+        treeKey: e
+      });
+    }));
+  }
+  /**
+   * Detach the tree structure of the given tree key from the graph.
+   *
+   * ```ts
+   * graph.detachTreeStructure('Inheritance');
+   * graph.getRoots('Inheritance'); // Error!
+   * ```
+   * @group TreeMethods
+   */
+  detachTreeStructure(e) {
+    this.checkTreeExistence(e), this.treeIndices.delete(e), this.batch(() => {
+      this.changes.push({
+        type: "TreeStructureDetached",
+        treeKey: e
+      });
+    });
+  }
+  /**
+   * Traverse the given tree data, add each node into the graph, then attach the tree structure.
+   *
+   * ```ts
+   * graph.addTree({
+   *   id: 1,
+   *   children: [
+   *     { id: 2 },
+   *     { id: 3 },
+   *   ],
+   * }, 'Inheritance');
+   * graph.getRoots('Inheritance'); // [1]
+   * graph.getChildren(1, 'Inheritance'); // [2, 3]
+   * graph.getAllNodes(); // [1, 2, 3]
+   * graph.getAllEdges(); // []
+   * ```
+   * @group TreeMethods
+   */
+  addTree(e, t) {
+    this.batch(() => {
+      this.attachTreeStructure(t);
+      const s = [], d = Array.isArray(e) ? e : [e];
+      for (; d.length; ) {
+        const r = d.shift();
+        s.push(r), r.children && d.push(...r.children);
+      }
+      this.addNodes(s), s.forEach((r) => {
+        var i;
+        (i = r.children) == null || i.forEach((a) => {
+          this.setParent(a.id, r.id, t);
+        });
+      });
+    });
+  }
+  /**
+   * Get the root nodes of an attached tree structure.
+   *
+   * Consider a graph with the following tree structure attached:
+   * ```
+   * Tree structure:
+   *    O     3
+   *   / \    |
+   *  1   2   4
+   * ```
+   * `graph.getRoots()` takes all nodes without a parent, therefore [0, 3] was returned.
+   *
+   * Newly added nodes are also unparented. So they are counted as roots.
+   * ```ts
+   * graph.addNode({ id: 5 });
+   * graph.getRoots(); // [0, 3, 5]
+   * ```
+   *
+   * Here is how the tree structure looks like:
+   * ```
+   * Tree structure:
+   *    O     3  5
+   *   / \    |
+   *  1   2   4
+   * ```
+   *
+   * By setting a parent, a root node no more be a root.
+   * ```ts
+   * graph.setParent(5, 2);
+   * graph.getRoots(); // [0, 3]
+   * ```
+   *
+   * The tree structure now becomes:
+   * ```
+   * Tree structure:
+   *    O     3
+   *   / \    |
+   *  1   2   4
+   *      |
+   *      5
+   * ```
+   *
+   * Removing a node forces its children to be unparented, or roots.
+   * ```ts
+   * graph.removeNode(0);
+   * graph.getRoots(); // [1, 2, 3]
+   * ```
+   *
+   * You might draw the the structure as follow:
+   * ```
+   * Tree structure:
+   *  1   2  3
+   *      |  |
+   *      5  4
+   * ```
+   * @group TreeMethods
+   */
+  getRoots(e) {
+    return this.checkTreeExistence(e), this.getAllNodes().filter((t) => !this.getParent(t.id, e));
+  }
+  /**
+   * Given a node ID and an optional tree key, get the children of the node in the specified tree structure.
+   * @group TreeMethods
+   */
+  getChildren(e, t) {
+    this.checkNodeExistence(e), this.checkTreeExistence(t);
+    const d = this.treeIndices.get(t).childrenMap.get(e);
+    return Array.from(d || []);
+  }
+  /**
+   * Given a node ID and an optional tree key, get the parent of the node in the specified tree structure.
+   * If the given node is one of the tree roots, this returns null.
+   * @group TreeMethods
+   */
+  getParent(e, t) {
+    return this.checkNodeExistence(e), this.checkTreeExistence(t), this.treeIndices.get(t).parentMap.get(e) || null;
+  }
+  /**
+   * Returns an array of all the ancestor nodes, staring from the parent to the root.
+   */
+  getAncestors(e, t) {
+    const s = [];
+    let d = this.getNode(e), r;
+    for (; r = this.getParent(d.id, t); )
+      s.push(r), d = r;
+    return s;
+  }
+  /**
+   * Set node parent. If this operation causes a circle, it fails with an error.
+   * @param id - ID of the child node.
+   * @param parent - ID of the parent node. If it is undefined or null, means unset parent for node with id.
+   * @param treeKey - Which tree structure the relation is applied to.
+   * @group TreeMethods
+   */
+  setParent(e, t, s) {
+    var c, g;
+    this.checkTreeExistence(s);
+    const d = this.treeIndices.get(s);
+    if (!d)
+      return;
+    const r = this.getNode(e), i = d.parentMap.get(e);
+    if ((i == null ? void 0 : i.id) === t)
+      return;
+    if (t == null) {
+      i && ((c = d.childrenMap.get(i.id)) == null || c.delete(r)), d.parentMap.delete(e);
+      return;
+    }
+    const a = this.getNode(t);
+    d.parentMap.set(e, a), i && ((g = d.childrenMap.get(i.id)) == null || g.delete(r));
+    let h = d.childrenMap.get(a.id);
+    h || (h = /* @__PURE__ */ new Set(), d.childrenMap.set(a.id, h)), h.add(r), this.batch(() => {
+      this.changes.push({
+        type: "TreeStructureChanged",
+        treeKey: s,
+        nodeId: e,
+        oldParentId: i == null ? void 0 : i.id,
+        newParentId: a.id
+      });
+    });
+  }
+  dfsTree(e, t, s) {
+    const d = (r) => this.getChildren(r, s);
+    return p(this.getNode(e), /* @__PURE__ */ new Set(), t, d);
+  }
+  bfsTree(e, t, s) {
+    const d = (r) => this.getChildren(r, s);
+    return l([this.getNode(e)], /* @__PURE__ */ new Set(), t, d);
+  }
+  // ================= Graph =================
+  /**
+   * Get all nodes in the graph as an array.
+   */
+  getAllNodes() {
+    return Array.from(this.nodeMap.values());
+  }
+  /**
+   * Get all edges in the graph as an array.
+   */
+  getAllEdges() {
+    return Array.from(this.edgeMap.values());
+  }
+  bfs(e, t, s = "out") {
+    const d = {
+      in: this.getPredecessors.bind(this),
+      out: this.getSuccessors.bind(this),
+      both: this.getNeighbors.bind(this)
+    }[s];
+    return l([this.getNode(e)], /* @__PURE__ */ new Set(), t, d);
+  }
+  dfs(e, t, s = "out") {
+    const d = {
+      in: this.getPredecessors.bind(this),
+      out: this.getSuccessors.bind(this),
+      both: this.getNeighbors.bind(this)
+    }[s];
+    return p(this.getNode(e), /* @__PURE__ */ new Set(), t, d);
+  }
+  clone() {
+    const e = this.getAllNodes().map((d) => ({ ...d, data: { ...d.data } })), t = this.getAllEdges().map((d) => ({ ...d, data: { ...d.data } })), s = new E({
+      nodes: e,
+      edges: t
+    });
+    return this.treeIndices.forEach(({ parentMap: d, childrenMap: r }, i) => {
+      const a = /* @__PURE__ */ new Map();
+      d.forEach((c, g) => {
+        a.set(g, s.getNode(c.id));
+      });
+      const h = /* @__PURE__ */ new Map();
+      r.forEach((c, g) => {
+        h.set(g, new Set(Array.from(c).map((f) => s.getNode(f.id))));
+      }), s.treeIndices.set(i, {
+        parentMap: a,
+        childrenMap: h
+      });
+    }), s;
+  }
+  toJSON() {
+    return JSON.stringify({
+      nodes: this.getAllNodes(),
+      edges: this.getAllEdges()
+      // FIXME: And tree structures?
+    });
+  }
+  createView(e) {
+    return new w({
+      graph: this,
+      ...e
+    });
+  }
+}
+export {
+  E as Graph
+};
+//# sourceMappingURL=graph.js.map