@statelyai/graph 1.0.0 → 2.1.0

package/dist/{index-CHoriXZD.d.mts → index-CNvqxPLJ.d.mts}

@@ -1,4 +1,4 @@
-import { B as WeightedWalkOptions, E as PortConfig, M as VisualGraph, N as VisualGraphConfig, _ as GraphNode, b as GraphPort, c as EntitiesUpdate, d as GraphConfig, f as GraphDiff, g as GraphMode, i as DeleteNodeOptions, k as TransitionOptions, o as EdgeConfig, p as GraphEdge, r as CoverageStats, s as EntitiesConfig, u as Graph, v as GraphPatch, w as NodeConfig, x as GraphStep, z as WalkOptions } from "./types-3-FS9NV2.mjs";
+import { A as PortConfig, C as GraphStep, D as NodeUpdate, E as NodeConfig, I as VisualGraph, L as VisualGraphConfig, N as TransitionOptions, S as GraphPort, U as WalkOptions, W as WeightedWalkOptions, b as GraphPatch, c as EdgeUpdate, f as Graph, h as GraphEdge, i as DeleteNodeOptions, l as EntitiesConfig, m as GraphDiff, o as EdgeConfig, p as GraphConfig, r as CoverageStats, u as EntitiesUpdate, v as GraphMode, y as GraphNode } from "./types-BAEQTwK_.mjs";
 
 //#region src/graph.d.ts
 
@@ -193,18 +193,23 @@ declare function deleteNode(graph: Graph, id: string, opts?: DeleteNodeOptions):
 declare function deleteEdge(graph: Graph, id: string): void;
 /**
  * **Mutable.** Update a node in place.
+ * Optional fields (`x`, `y`, `width`, `height`, `shape`, `color`, `style`,
+ * `ports`) accept `null` to unset; `undefined` leaves them unchanged.
  * @returns The updated node.
  *
  * @example
  * ```ts
  * const graph = createGraph({ nodes: [{ id: 'a', label: 'old' }] });
- * const updated = updateNode(graph, 'a', { label: 'new' });
- * // updated.label === 'new'
+ * const updated = updateNode(graph, 'a', { label: 'new', x: 100 });
+ * // updated.label === 'new', updated.x === 100
  * ```
  */
-declare function updateNode<N, P = any>(graph: Graph<N, any, any, P>, id: string, update: Partial<Omit<NodeConfig<N, P>, 'id'>>): GraphNode<N, P>;
+declare function updateNode<N, P = any>(graph: Graph<N, any, any, P>, id: string, update: NodeUpdate<N, P>): GraphNode<N, P>;
 /**
  * **Mutable.** Update an edge in place.
+ * Optional fields (`weight`, `mode`, `sourcePort`, `targetPort`, `x`, `y`,
+ * `width`, `height`, `color`, `style`) accept `null` to unset; `undefined`
+ * leaves them unchanged.
  * @returns The updated edge.
  *
  * @example
@@ -213,11 +218,11 @@ declare function updateNode<N, P = any>(graph: Graph<N, any, any, P>, id: string
  *   nodes: [{ id: 'a' }, { id: 'b' }],
  *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b', label: 'old' }],
  * });
- * const updated = updateEdge(graph, 'e1', { label: 'new' });
- * // updated.label === 'new'
+ * const updated = updateEdge(graph, 'e1', { label: 'new', weight: 2 });
+ * // updated.label === 'new', updated.weight === 2
  * ```
  */
-declare function updateEdge<N, E>(graph: Graph<N, E>, id: string, update: Partial<Omit<EdgeConfig<E>, 'id'>>): GraphEdge<E>;
+declare function updateEdge<N, E>(graph: Graph<N, E>, id: string, update: EdgeUpdate<E>): GraphEdge<E>;
 /**
  * **Mutable.** Add multiple nodes and edges to the graph.
  * Nodes are added first, then edges (so edges can reference new nodes).
@@ -308,8 +313,8 @@ declare class GraphInstance<N = any, E = any, G = any, P = any> {
   addEdge(config: EdgeConfig<E>): GraphEdge<E>;
   deleteNode(id: string, opts?: DeleteNodeOptions): void;
   deleteEdge(id: string): void;
-  updateNode(id: string, update: Partial<Omit<NodeConfig<N, P>, 'id'>>): GraphNode<N, P>;
-  updateEdge(id: string, update: Partial<Omit<EdgeConfig<E>, 'id'>>): GraphEdge<E>;
+  updateNode(id: string, update: NodeUpdate<N, P>): GraphNode<N, P>;
+  updateEdge(id: string, update: EdgeUpdate<E>): GraphEdge<E>;
   addEntities(entities: EntitiesConfig<N, E, P>): void;
   deleteEntities(ids: string | string[], opts?: DeleteNodeOptions): void;
   updateEntities(updates: EntitiesUpdate<N, E, P>): void;
@@ -325,26 +330,105 @@ declare function getEdgeMode(graph: Graph, edge: GraphEdge): GraphMode;
 /** Whether an edge points only from source to target. */
 declare function isEdgeDirected(graph: Graph, edge: GraphEdge): boolean;
 //#endregion
+//#region src/validate.d.ts
+/**
+ * A structural problem found in a graph by {@link getGraphIssues}.
+ */
+interface GraphIssue {
+  /** Stable machine-readable code, e.g. `'duplicate-node-id'`. */
+  code: string;
+  /** What is wrong, which entity is affected, and how to fix it. */
+  message: string;
+  /** Location of the offending value, e.g. `['nodes', 0, 'id']`. */
+  path?: (string | number)[];
+}
+/**
+ * Validates the structural invariants of a graph and returns the issues
+ * found, or `[]` when the graph is valid. Pure — never throws, never mutates.
+ *
+ * This is the recommended gate for untrusted or imported graphs (e.g. parsed
+ * from a file or received over the wire) before handing them to queries and
+ * algorithms: the mutation APIs (`addNode`, `addEdge`, `updateNode`, …)
+ * validate incrementally, but `createGraph` does **not** — it accepts
+ * dangling `parentId`/edge references and even `parentId` cycles as-is.
+ *
+ * For Zod-based shape validation of arbitrary unknown values, see
+ * `validateGraph` in `@statelyai/graph/schemas` (which reuses these checks).
+ *
+ * Issue codes: `duplicate-node-id`, `duplicate-edge-id`,
+ * `missing-initial-node`, `missing-parent`, `missing-node-initial`,
+ * `duplicate-port-name`, `parent-cycle`, `dangling-edge-endpoint`,
+ * `missing-source-port`, `missing-target-port`.
+ *
+ * @example
+ * ```ts
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a', parentId: 'ghost' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * getGraphIssues(graph);
+ * // => [
+ * //   { code: 'missing-parent', message: '...', path: ['nodes', 0, 'parentId'] },
+ * //   { code: 'dangling-edge-endpoint', message: '...', path: ['edges', 0, 'targetId'] },
+ * // ]
+ * ```
+ */
+declare function getGraphIssues(graph: Graph): GraphIssue[];
+//#endregion
 //#region src/indexing.d.ts
 /**
- * Clear the cached index. Call this if you mutate graph.nodes/edges directly.
+ * Clear the cached index. Call this if you mutate fields of existing
+ * nodes/edges in place (e.g. `edge.targetId = 'a'`) — such mutations are not
+ * auto-detected. Array replacement and length changes are auto-detected.
  *
  * @example
  * ```ts
- * import { createGraph, invalidateIndex, getIndex } from '@statelyai/graph';
+ * import { createGraph, getSuccessors, invalidateIndex } from '@statelyai/graph';
  *
- * const graph = createGraph({ nodes: [{ id: 'a' }], edges: [] });
- * // manually mutate nodes array
- * graph.nodes.push({ type: 'node', id: 'b', parentId: null, initialNodeId: null, label: '', data: undefined });
- * invalidateIndex(graph); // forces rebuild on next getIndex()
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
+ * });
+ * graph.edges[0].targetId = 'a'; // in-place field mutation
+ * invalidateIndex(graph); // forces rebuild on next indexed read
+ * getSuccessors(graph, 'a');
  * ```
  */
 declare function invalidateIndex(graph: Graph): void;
 //#endregion
+//#region src/generators.d.ts
+/**
+ * Create the complete graph K_n: every pair of distinct nodes connected by
+ * one undirected edge. Nodes are `n0..n{n-1}` (`options.idPrefix` overrides
+ * the `n` prefix); edges are `e0..`.
+ */
+declare function createCompleteGraph(n: number, options?: {
+  idPrefix?: string;
+}): Graph;
+/**
+ * Create a `rows × cols` grid graph: node `(r, c)` is connected to its right
+ * and down neighbors by undirected edges. Nodes are `n{r}_{c}`
+ * (`options.idPrefix` overrides the `n` prefix); edges are `e0..`.
+ */
+declare function createGridGraph(rows: number, cols: number, options?: {
+  idPrefix?: string;
+}): Graph;
+/**
+ * Create an Erdős–Rényi G(n, p) random graph: each of the n·(n-1)/2 node
+ * pairs gets an undirected edge with probability `probability`. With
+ * `options.seed` the result is deterministic per seed (mulberry32);
+ * otherwise `Math.random` is used. Nodes are `n0..n{n-1}`
+ * (`options.idPrefix` overrides the `n` prefix); edges are `e0..`.
+ */
+declare function createRandomGraph(n: number, probability: number, options?: {
+  seed?: number;
+  idPrefix?: string;
+}): Graph;
+//#endregion
 //#region src/equivalence.d.ts
 declare const LAYOUT_KEYS: {
   node: readonly ["x", "y", "width", "height", "style", "color", "shape"];
-  edge: readonly ["x", "y", "width", "height", "style", "color"];
+  edge: readonly ["x", "y", "width", "height", "points", "routing", "style", "color"];
 };
 /**
  * Compare two entities on a given set of keys.
@@ -427,21 +511,26 @@ declare function isEmptyDiff(diff: GraphDiff): boolean;
  *
  * @example
  * ```ts
- * import { createGraph, getDiff, invertDiff } from '@statelyai/graph';
+ * import { createGraph, getDiff, getInvertedDiff } from '@statelyai/graph';
  *
  * const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
  * const b = createGraph({ nodes: [{ id: 'n2' }], edges: [] });
  *
  * const diff = getDiff(a, b);
- * const inv = invertDiff(diff);
+ * const inv = getInvertedDiff(diff);
  * // inv.nodes.added contains n1 (was removed)
  * // inv.nodes.removed contains n2 (was added)
  * ```
  */
+declare function getInvertedDiff<N, E>(diff: GraphDiff<N, E>): GraphDiff<N, E>;
+/**
+ * @deprecated Use {@link getInvertedDiff}.
+ */
 declare function invertDiff<N, E>(diff: GraphDiff<N, E>): GraphDiff<N, E>;
 /**
  * Compute an ordered patch list from graph `a` to graph `b`.
- * Order: delete edges → delete nodes → add nodes → add edges → update nodes → update edges.
+ * Order (see {@link toPatches}): add nodes → update edges → delete edges →
+ * delete nodes → add edges → update nodes.
  *
  * @example
  * ```ts
@@ -461,16 +550,20 @@ declare function getPatches<N, E>(a: Graph<N, E>, b: Graph<N, E>): GraphPatch<N,
  *
  * @example
  * ```ts
- * import { createGraph, getPatches, applyPatches } from '@statelyai/graph';
+ * import { createGraph, getPatches, updateGraphWithPatches } from '@statelyai/graph';
  *
  * const a = createGraph({ nodes: [{ id: 'n1' }], edges: [] });
  * const b = createGraph({ nodes: [{ id: 'n1' }, { id: 'n2' }], edges: [] });
  *
  * const patches = getPatches(a, b);
- * applyPatches(a, patches);
+ * updateGraphWithPatches(a, patches);
  * // a now contains both n1 and n2
  * ```
  */
+declare function updateGraphWithPatches<N, E>(graph: Graph<N, E>, patches: GraphPatch<N, E>[]): void;
+/**
+ * @deprecated Use {@link updateGraphWithPatches}.
+ */
 declare function applyPatches<N, E>(graph: Graph<N, E>, patches: GraphPatch<N, E>[]): void;
 /**
  * Flatten a structured diff into an ordered patch list.
@@ -519,7 +612,7 @@ declare function toDiff<N, E>(patches: GraphPatch<N, E>[]): GraphDiff<N, E>;
  *
  * @example
  * ```ts
- * import { createGraph, flatten } from '@statelyai/graph';
+ * import { createGraph, getFlattenedGraph } from '@statelyai/graph';
  *
  * const graph = createGraph({
  *   nodes: [
@@ -531,11 +624,15 @@ declare function toDiff<N, E>(patches: GraphPatch<N, E>[]): GraphDiff<N, E>;
  *   edges: [{ id: 'e1', sourceId: 'other', targetId: 'parent' }],
  * });
  *
- * const flat = flatten(graph);
+ * const flat = getFlattenedGraph(graph);
  * // flat.nodes → [child1, child2, other] (leaf nodes only)
  * // flat.edges → edge from 'other' → 'child1' (resolved via initialNodeId)
  * ```
  */
+declare function getFlattenedGraph<N, E, G>(graph: Graph<N, E, G>): Graph<N, E, G>;
+/**
+ * @deprecated Use {@link getFlattenedGraph}.
+ */
 declare function flatten<N, E, G>(graph: Graph<N, E, G>): Graph<N, E, G>;
 /**
  * Returns the induced subgraph containing only the given node IDs
@@ -566,7 +663,7 @@ declare function getSubgraph<N, E, G>(graph: Graph<N, E, G>, nodeIds: string[]):
  *
  * @example
  * ```ts
- * import { createGraph, reverseGraph } from '@statelyai/graph';
+ * import { createGraph, getReversedGraph } from '@statelyai/graph';
  *
  * const graph = createGraph({
  *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
@@ -576,18 +673,23 @@ declare function getSubgraph<N, E, G>(graph: Graph<N, E, G>, nodeIds: string[]):
  *   ],
  * });
  *
- * const rev = reverseGraph(graph);
+ * const rev = getReversedGraph(graph);
  * // rev edges: b→a, c→b
  *
- * const filtered = reverseGraph(graph, (e) => e.id !== 'bc');
+ * const filtered = getReversedGraph(graph, (e) => e.id !== 'bc');
  * // filtered edges: b→a (only ab reversed, bc excluded)
  * ```
  */
+declare function getReversedGraph<N, E, G>(graph: Graph<N, E, G>, filterEdge?: (edge: GraphEdge<E>) => boolean): Graph<N, E, G>;
+/**
+ * @deprecated Use {@link getReversedGraph}.
+ */
 declare function reverseGraph<N, E, G>(graph: Graph<N, E, G>, filterEdge?: (edge: GraphEdge<E>) => boolean): Graph<N, E, G>;
 //#endregion
 //#region src/walks.d.ts
 /**
- * Random walk. At each node, picks a uniformly random outgoing edge.
+ * Random walk. At each node, picks a uniformly random traversable edge
+ * (outgoing edges, plus non-directed edges both ways).
  * Yields steps indefinitely (may revisit nodes) until a sink node is reached.
  */
 declare function genRandomWalk<N, E>(graph: Graph<N, E>, options?: WalkOptions<E>): Generator<GraphStep<N, E>>;
@@ -597,36 +699,61 @@ declare function genRandomWalk<N, E>(graph: Graph<N, E>, options?: WalkOptions<E
 declare function genWeightedRandomWalk<N, E>(graph: Graph<N, E>, options?: WeightedWalkOptions<E>): Generator<GraphStep<N, E>>;
 /**
  * Quick random walk targeting unvisited edges.
- * If unvisited outgoing edges exist, picks one randomly.
- * Otherwise, finds shortest path to a node with unvisited outgoing edges.
+ * If unvisited traversable edges exist at the current node, picks one randomly.
+ * Otherwise, walks the fewest-hop path (BFS, honoring `filter` and edge modes)
+ * to the nearest unvisited edge. Ends when no unvisited edge is reachable.
  */
 declare function genQuickRandomWalk<N, E>(graph: Graph<N, E>, options?: WalkOptions<E>): Generator<GraphStep<N, E>>;
 /**
  * Walk a predefined sequence of edge IDs.
  * Validates each edge exists and connects from the current position.
+ * Edges whose effective mode is not `'directed'` may be traversed
+ * target → source as well.
  */
 declare function genPredefinedWalk<N, E>(graph: Graph<N, E>, edgeIds: string[], options?: Pick<WalkOptions<E>, 'from'>): Generator<GraphStep<N, E>>;
 /**
  * Yield at most `n` steps from the source generator.
  */
+declare function genWalkSteps<N, E>(gen: Generator<GraphStep<N, E>>, n: number): Generator<GraphStep<N, E>>;
+/**
+ * @deprecated Use {@link genWalkSteps}.
+ */
 declare function takeSteps<N, E>(gen: Generator<GraphStep<N, E>>, n: number): Generator<GraphStep<N, E>>;
 /**
  * Yield steps until a specific node is reached.
  */
+declare function genWalkUntilNode<N, E>(gen: Generator<GraphStep<N, E>>, nodeId: string): Generator<GraphStep<N, E>>;
+/**
+ * @deprecated Use {@link genWalkUntilNode}.
+ */
 declare function takeUntilNode<N, E>(gen: Generator<GraphStep<N, E>>, nodeId: string): Generator<GraphStep<N, E>>;
 /**
  * Yield steps until a specific edge is traversed.
  */
+declare function genWalkUntilEdge<N, E>(gen: Generator<GraphStep<N, E>>, edgeId: string): Generator<GraphStep<N, E>>;
+/**
+ * @deprecated Use {@link genWalkUntilEdge}.
+ */
 declare function takeUntilEdge<N, E>(gen: Generator<GraphStep<N, E>>, edgeId: string): Generator<GraphStep<N, E>>;
 /**
  * Yield steps until node coverage reaches the target (0–1).
  */
+declare function genWalkUntilNodeCoverage<N, E>(gen: Generator<GraphStep<N, E>>, graph: Graph<N, E>, coverage: number, options?: {
+  from?: string;
+}): Generator<GraphStep<N, E>>;
+/**
+ * @deprecated Use {@link genWalkUntilNodeCoverage}.
+ */
 declare function takeUntilNodeCoverage<N, E>(gen: Generator<GraphStep<N, E>>, graph: Graph<N, E>, coverage: number, options?: {
   from?: string;
 }): Generator<GraphStep<N, E>>;
 /**
  * Yield steps until edge coverage reaches the target (0–1).
  */
+declare function genWalkUntilEdgeCoverage<N, E>(gen: Generator<GraphStep<N, E>>, graph: Graph<N, E>, coverage: number): Generator<GraphStep<N, E>>;
+/**
+ * @deprecated Use {@link genWalkUntilEdgeCoverage}.
+ */
 declare function takeUntilEdgeCoverage<N, E>(gen: Generator<GraphStep<N, E>>, graph: Graph<N, E>, coverage: number): Generator<GraphStep<N, E>>;
 /**
  * Compute coverage statistics for a completed walk.
@@ -635,4 +762,4 @@ declare function getCoverage<N, E>(graph: Graph<N, E>, steps: GraphStep<N, E>[],
   from?: string;
 }): CoverageStats;
 //#endregion
-export { addEntities as A, deleteNode as B, isLayoutEqual as C, isEdgeDirected as D, getEdgeMode as E, createGraphNode as F, updateEdge as G, getNode as H, createGraphPort as I, updateEntities as K, createVisualGraph as L, createGraph as M, createGraphEdge as N, GraphInstance as O, createGraphFromTransition as P, deleteEdge as R, areEntitiesEqual as S, invalidateIndex as T, hasEdge as U, getEdge as V, hasNode as W, invertDiff as _, getCoverage as a, toPatches as b, takeUntilEdgeCoverage as c, flatten as d, getSubgraph as f, getPatches as g, getDiff as h, genWeightedRandomWalk as i, addNode as j, addEdge as k, takeUntilNode as l, applyPatches as m, genQuickRandomWalk as n, takeSteps as o, reverseGraph as p, updateNode as q, genRandomWalk as r, takeUntilEdge as s, genPredefinedWalk as t, takeUntilNodeCoverage as u, isEmptyDiff as v, isNonLayoutEqual as w, LAYOUT_KEYS as x, toDiff as y, deleteEntities as z };
+export { deleteEntities as $, LAYOUT_KEYS as A, getEdgeMode as B, getInvertedDiff as C, toDiff as D, isEmptyDiff as E, createGridGraph as F, addNode as G, GraphInstance as H, createRandomGraph as I, createGraphFromTransition as J, createGraph as K, invalidateIndex as L, isLayoutEqual as M, isNonLayoutEqual as N, toPatches as O, createCompleteGraph as P, deleteEdge as Q, GraphIssue as R, getDiff as S, invertDiff as T, addEdge as U, isEdgeDirected as V, addEntities as W, createGraphPort as X, createGraphNode as Y, createVisualGraph as Z, getFlattenedGraph as _, genWalkUntilEdge as a, updateEdge as at, reverseGraph as b, genWalkUntilNodeCoverage as c, takeSteps as d, deleteNode as et, takeUntilEdge as f, flatten as g, takeUntilNodeCoverage as h, genWalkSteps as i, hasNode as it, areEntitiesEqual as j, updateGraphWithPatches as k, genWeightedRandomWalk as l, takeUntilNode as m, genQuickRandomWalk as n, getNode as nt, genWalkUntilEdgeCoverage as o, updateEntities as ot, takeUntilEdgeCoverage as p, createGraphEdge as q, genRandomWalk as r, hasEdge as rt, genWalkUntilNode as s, updateNode as st, genPredefinedWalk as t, getEdge as tt, getCoverage as u, getReversedGraph as v, getPatches as w, applyPatches as x, getSubgraph as y, getGraphIssues as z };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { A as TraversalOptions, B as WeightedWalkOptions, C as NodeChange, D as PortDirection, E as PortConfig, F as VisualGraphFormatConverter, I as VisualNode, L as VisualPort, M as VisualGraph, N as VisualGraphConfig, O as SinglePathOptions, P as VisualGraphEntity, R as WalkContext, S as MSTOptions, T as PathOptions, _ as GraphNode, a as EdgeChange, b as GraphPort, c as EntitiesUpdate, d as GraphConfig, f as GraphDiff, g as GraphMode, h as GraphFormatConverter, i as DeleteNodeOptions, j as VisualEdge, k as TransitionOptions, l as EntityRect, m as GraphEntity, n as AllPairsShortestPathsOptions, o as EdgeConfig, p as GraphEdge, r as CoverageStats, s as EntitiesConfig, t as AStarOptions, u as Graph, v as GraphPatch, w as NodeConfig, x as GraphStep, y as GraphPath, z as WalkOptions } from "./types-3-FS9NV2.mjs";
-import { A as genCycles, B as getStronglyConnectedComponents, C as getMinimumSpanningTree, D as getPostorders, E as getPostorder, F as getCycles, G as getTopologicalSort, H as bfs, I as getShortestPath, J as isConnected, K as hasPath, L as getShortestPaths, M as genSimplePaths, N as getAStarPath, O as getPreorder, P as getAllPairsShortestPaths, R as getSimplePath, S as getPageRank, T as genPreorders, U as dfs, V as joinPaths, W as getConnectedComponents, Y as isTree, _ as getDegreeCentrality, a as getBridges, b as getInDegreeCentrality, c as genGirvanNewmanCommunities, d as getLabelPropagationCommunities, f as getModularity, g as getClosenessCentrality, h as getBetweennessCentrality, i as getBiconnectedComponents, j as genShortestPaths, k as getPreorders, l as getGirvanNewmanCommunities, m as IterativeCentralityOptions, n as isIsomorphic, o as GirvanNewmanOptions, p as HITSResult, q as isAcyclic, r as getArticulationPoints, s as LabelPropagationOptions, t as IsomorphismOptions, u as getGreedyModularityCommunities, v as getEigenvectorCentrality, w as genPostorders, x as getOutDegreeCentrality, y as getHITS, z as getSimplePaths } from "./algorithms-fTqmvhzP.mjs";
-import { n as createFormatConverter } from "./index-D9Kj6Fe3.mjs";
-import { A as addEntities, B as deleteNode, C as isLayoutEqual, D as isEdgeDirected, E as getEdgeMode, F as createGraphNode, G as updateEdge, H as getNode, I as createGraphPort, K as updateEntities, L as createVisualGraph, M as createGraph, N as createGraphEdge, O as GraphInstance, P as createGraphFromTransition, R as deleteEdge, S as areEntitiesEqual, T as invalidateIndex, U as hasEdge, V as getEdge, W as hasNode, _ as invertDiff, a as getCoverage, b as toPatches, c as takeUntilEdgeCoverage, d as flatten, f as getSubgraph, g as getPatches, h as getDiff, i as genWeightedRandomWalk, j as addNode, k as addEdge, l as takeUntilNode, m as applyPatches, n as genQuickRandomWalk, o as takeSteps, p as reverseGraph, q as updateNode, r as genRandomWalk, s as takeUntilEdge, t as genPredefinedWalk, u as takeUntilNodeCoverage, v as isEmptyDiff, w as isNonLayoutEqual, x as LAYOUT_KEYS, y as toDiff, z as deleteEntities } from "./index-CHoriXZD.mjs";
-import { C as getSinks, D as isLeaf, E as isCompound, S as getSiblings, T as getSuccessors, _ as getPorts, a as getDescendants, b as getRelativeDistanceMap, c as getEdgesOf, d as getLCA, f as getNeighbors, g as getPort, h as getParent, i as getDepth, l as getInDegree, m as getOutEdges, n as getChildren, o as getEdgesBetween, p as getOutDegree, r as getDegree, s as getEdgesByPort, t as getAncestors, u as getInEdges, v as getPredecessors, w as getSources, x as getRoots, y as getRelativeDistance } from "./queries-BlkA1HAN.mjs";
-export { AStarOptions, AllPairsShortestPathsOptions, CoverageStats, DeleteNodeOptions, EdgeChange, EdgeConfig, EntitiesConfig, EntitiesUpdate, EntityRect, GirvanNewmanOptions, Graph, GraphConfig, GraphDiff, GraphEdge, GraphEntity, GraphFormatConverter, GraphInstance, GraphMode, GraphNode, GraphPatch, GraphPath, GraphPort, GraphStep, HITSResult, IsomorphismOptions, IterativeCentralityOptions, LAYOUT_KEYS, LabelPropagationOptions, MSTOptions, NodeChange, NodeConfig, PathOptions, PortConfig, PortDirection, SinglePathOptions, TransitionOptions, TraversalOptions, VisualEdge, VisualGraph, VisualGraphConfig, VisualGraphEntity, VisualGraphFormatConverter, VisualNode, VisualPort, WalkContext, WalkOptions, WeightedWalkOptions, addEdge, addEntities, addNode, applyPatches, areEntitiesEqual, bfs, createFormatConverter, createGraph, createGraphEdge, createGraphFromTransition, createGraphNode, createGraphPort, createVisualGraph, deleteEdge, deleteEntities, deleteNode, dfs, flatten, genCycles, genGirvanNewmanCommunities, genPostorders, genPredefinedWalk, genPreorders, genQuickRandomWalk, genRandomWalk, genShortestPaths, genSimplePaths, genWeightedRandomWalk, getAStarPath, getAllPairsShortestPaths, getAncestors, getArticulationPoints, getBetweennessCentrality, getBiconnectedComponents, getBridges, getChildren, getClosenessCentrality, getConnectedComponents, getCoverage, getCycles, getDegree, getDegreeCentrality, getDepth, getDescendants, getDiff, getEdge, getEdgeMode, getEdgesBetween, getEdgesByPort, getEdgesOf, getEigenvectorCentrality, getGirvanNewmanCommunities, getGreedyModularityCommunities, getHITS, getInDegree, getInDegreeCentrality, getInEdges, getLCA, getLabelPropagationCommunities, getMinimumSpanningTree, getModularity, getNeighbors, getNode, getOutDegree, getOutDegreeCentrality, getOutEdges, getPageRank, getParent, getPatches, getPort, getPorts, getPostorder, getPostorders, getPredecessors, getPreorder, getPreorders, getRelativeDistance, getRelativeDistanceMap, getRoots, getShortestPath, getShortestPaths, getSiblings, getSimplePath, getSimplePaths, getSinks, getSources, getStronglyConnectedComponents, getSubgraph, getSuccessors, getTopologicalSort, hasEdge, hasNode, hasPath, invalidateIndex, invertDiff, isAcyclic, isCompound, isConnected, isEdgeDirected, isEmptyDiff, isIsomorphic, isLayoutEqual, isLeaf, isNonLayoutEqual, isTree, joinPaths, reverseGraph, takeSteps, takeUntilEdge, takeUntilEdgeCoverage, takeUntilNode, takeUntilNodeCoverage, toDiff, toPatches, updateEdge, updateEntities, updateNode };
+import { A as PortConfig, B as VisualNode, C as GraphStep, D as NodeUpdate, E as NodeConfig, F as VisualEdge, H as WalkContext, I as VisualGraph, L as VisualGraphConfig, M as SinglePathOptions, N as TransitionOptions, O as PathOptions, P as TraversalOptions, R as VisualGraphEntity, S as GraphPort, T as NodeChange, U as WalkOptions, V as VisualPort, W as WeightedWalkOptions, _ as GraphFormatConverter, a as EdgeChange, b as GraphPatch, c as EdgeUpdate, d as EntityRect, f as Graph, g as GraphEntity, h as GraphEdge, i as DeleteNodeOptions, j as PortDirection, k as Point, l as EntitiesConfig, m as GraphDiff, n as AllPairsShortestPathsOptions, o as EdgeConfig, p as GraphConfig, r as CoverageStats, s as EdgeRouting, t as AStarOptions, u as EntitiesUpdate, v as GraphMode, w as MSTOptions, x as GraphPath, y as GraphNode, z as VisualGraphFormatConverter } from "./types-BAEQTwK_.mjs";
+import { $ as getAllPairsShortestPaths, A as HITSResult, B as getOutDegreeCentrality, C as getModularity, D as getCoreNumbers, E as isBipartite, F as getDegreeCentrality, G as getPostorder, H as getMinimumSpanningTree, I as getEigenvectorCentrality, J as getPreorders, K as getPostorders, L as getHITS, M as KatzCentralityOptions, N as getBetweennessCentrality, O as getKCore, P as getClosenessCentrality, Q as getAStarPath, R as getInDegreeCentrality, S as getLabelPropagationCommunities, T as getMaximumBipartiteMatching, U as genPostorders, V as getPageRank, W as genPreorders, X as genShortestPaths, Y as genCycles, Z as genSimplePaths, _ as GirvanNewmanOptions, _t as isTree, a as MaxFlowResult, at as getSimplePaths, b as getGirvanNewmanCommunities, c as getMaxFlow, ct as bfs, d as getLouvainCommunities, dt as genDFS, et as getCycles, f as IsomorphismOptions, ft as getConnectedComponents, g as getBridges, gt as isConnected, h as getBiconnectedComponents, ht as isAcyclic, i as MaxFlowOptions, it as getSimplePath, j as IterativeCentralityOptions, k as EigenvectorCentralityOptions, l as getMinCut, lt as dfs, m as getArticulationPoints, mt as hasPath, n as DominatorTreeOptions, nt as getShortestPath, o as MinCutOptions, ot as getStronglyConnectedComponents, p as isIsomorphic, pt as getTopologicalSort, q as getPreorder, r as getDominatorTree, rt as getShortestPaths, s as MinCutResult, st as joinPaths, t as getTransitiveReduction, tt as getJoinedPath, u as LouvainOptions, ut as genBFS, v as LabelPropagationOptions, w as BipartiteMatch, x as getGreedyModularityCommunities, y as genGirvanNewmanCommunities, z as getKatzCentrality } from "./algorithms-D1cgly0g.mjs";
+import { n as createFormatConverter } from "./index-BlbSWUvH.mjs";
+import { $ as deleteEntities, A as LAYOUT_KEYS, B as getEdgeMode, C as getInvertedDiff, D as toDiff, E as isEmptyDiff, F as createGridGraph, G as addNode, H as GraphInstance, I as createRandomGraph, J as createGraphFromTransition, K as createGraph, L as invalidateIndex, M as isLayoutEqual, N as isNonLayoutEqual, O as toPatches, P as createCompleteGraph, Q as deleteEdge, R as GraphIssue, S as getDiff, T as invertDiff, U as addEdge, V as isEdgeDirected, W as addEntities, X as createGraphPort, Y as createGraphNode, Z as createVisualGraph, _ as getFlattenedGraph, a as genWalkUntilEdge, at as updateEdge, b as reverseGraph, c as genWalkUntilNodeCoverage, d as takeSteps, et as deleteNode, f as takeUntilEdge, g as flatten, h as takeUntilNodeCoverage, i as genWalkSteps, it as hasNode, j as areEntitiesEqual, k as updateGraphWithPatches, l as genWeightedRandomWalk, m as takeUntilNode, n as genQuickRandomWalk, nt as getNode, o as genWalkUntilEdgeCoverage, ot as updateEntities, p as takeUntilEdgeCoverage, q as createGraphEdge, r as genRandomWalk, rt as hasEdge, s as genWalkUntilNode, st as updateNode, t as genPredefinedWalk, tt as getEdge, u as getCoverage, v as getReversedGraph, w as getPatches, x as applyPatches, y as getSubgraph, z as getGraphIssues } from "./index-CNvqxPLJ.mjs";
+import { C as getSinks, D as isLeaf, E as isCompound, S as getSiblings, T as getSuccessors, _ as getPorts, a as getDescendants, b as getRelativeDistanceMap, c as getEdgesOf, d as getLCA, f as getNeighbors, g as getPort, h as getParent, i as getDepth, l as getInDegree, m as getOutEdges, n as getChildren, o as getEdgesBetween, p as getOutDegree, r as getDegree, s as getEdgesByPort, t as getAncestors, u as getInEdges, v as getPredecessors, w as getSources, x as getRoots, y as getRelativeDistance } from "./queries-B6quF529.mjs";
+export { AStarOptions, AllPairsShortestPathsOptions, BipartiteMatch, CoverageStats, DeleteNodeOptions, DominatorTreeOptions, EdgeChange, EdgeConfig, EdgeRouting, EdgeUpdate, EigenvectorCentralityOptions, EntitiesConfig, EntitiesUpdate, EntityRect, GirvanNewmanOptions, Graph, GraphConfig, GraphDiff, GraphEdge, GraphEntity, GraphFormatConverter, GraphInstance, GraphIssue, GraphMode, GraphNode, GraphPatch, GraphPath, GraphPort, GraphStep, HITSResult, IsomorphismOptions, IterativeCentralityOptions, KatzCentralityOptions, LAYOUT_KEYS, LabelPropagationOptions, LouvainOptions, MSTOptions, MaxFlowOptions, MaxFlowResult, MinCutOptions, MinCutResult, NodeChange, NodeConfig, NodeUpdate, PathOptions, Point, PortConfig, PortDirection, SinglePathOptions, TransitionOptions, TraversalOptions, VisualEdge, VisualGraph, VisualGraphConfig, VisualGraphEntity, VisualGraphFormatConverter, VisualNode, VisualPort, WalkContext, WalkOptions, WeightedWalkOptions, addEdge, addEntities, addNode, applyPatches, areEntitiesEqual, bfs, createCompleteGraph, createFormatConverter, createGraph, createGraphEdge, createGraphFromTransition, createGraphNode, createGraphPort, createGridGraph, createRandomGraph, createVisualGraph, deleteEdge, deleteEntities, deleteNode, dfs, flatten, genBFS, genCycles, genDFS, genGirvanNewmanCommunities, genPostorders, genPredefinedWalk, genPreorders, genQuickRandomWalk, genRandomWalk, genShortestPaths, genSimplePaths, genWalkSteps, genWalkUntilEdge, genWalkUntilEdgeCoverage, genWalkUntilNode, genWalkUntilNodeCoverage, genWeightedRandomWalk, getAStarPath, getAllPairsShortestPaths, getAncestors, getArticulationPoints, getBetweennessCentrality, getBiconnectedComponents, getBridges, getChildren, getClosenessCentrality, getConnectedComponents, getCoreNumbers, getCoverage, getCycles, getDegree, getDegreeCentrality, getDepth, getDescendants, getDiff, getDominatorTree, getEdge, getEdgeMode, getEdgesBetween, getEdgesByPort, getEdgesOf, getEigenvectorCentrality, getFlattenedGraph, getGirvanNewmanCommunities, getGraphIssues, getGreedyModularityCommunities, getHITS, getInDegree, getInDegreeCentrality, getInEdges, getInvertedDiff, getJoinedPath, getKCore, getKatzCentrality, getLCA, getLabelPropagationCommunities, getLouvainCommunities, getMaxFlow, getMaximumBipartiteMatching, getMinCut, getMinimumSpanningTree, getModularity, getNeighbors, getNode, getOutDegree, getOutDegreeCentrality, getOutEdges, getPageRank, getParent, getPatches, getPort, getPorts, getPostorder, getPostorders, getPredecessors, getPreorder, getPreorders, getRelativeDistance, getRelativeDistanceMap, getReversedGraph, getRoots, getShortestPath, getShortestPaths, getSiblings, getSimplePath, getSimplePaths, getSinks, getSources, getStronglyConnectedComponents, getSubgraph, getSuccessors, getTopologicalSort, getTransitiveReduction, hasEdge, hasNode, hasPath, invalidateIndex, invertDiff, isAcyclic, isBipartite, isCompound, isConnected, isEdgeDirected, isEmptyDiff, isIsomorphic, isLayoutEqual, isLeaf, isNonLayoutEqual, isTree, joinPaths, reverseGraph, takeSteps, takeUntilEdge, takeUntilEdgeCoverage, takeUntilNode, takeUntilNodeCoverage, toDiff, toPatches, updateEdge, updateEntities, updateGraphWithPatches, updateNode };