@statelyai/graph 2.0.0 → 2.1.0

package/dist/formats/tgf/index.d.mts

@@ -1,4 +1,4 @@
-import { d as Graph, g as GraphFormatConverter } from "../../types-DNYdIU21.mjs";
+import { _ as GraphFormatConverter, f as Graph } from "../../types-BAEQTwK_.mjs";
 
 //#region src/formats/tgf/index.d.ts
 
@@ -8,7 +8,7 @@ import { d as Graph, g as GraphFormatConverter } from "../../types-DNYdIU21.mjs"
  * @example
  * ```ts
  * import { createGraph } from '@statelyai/graph';
- * import { toTGF } from '@statelyai/graph/formats/tgf';
+ * import { toTGF } from '@statelyai/graph/tgf';
  *
  * const graph = createGraph({
  *   nodes: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }],
@@ -25,7 +25,7 @@ declare function toTGF(graph: Graph): string;
  *
  * @example
  * ```ts
- * import { fromTGF } from '@statelyai/graph/formats/tgf';
+ * import { fromTGF } from '@statelyai/graph/tgf';
  *
  * const graph = fromTGF('a A\nb B\n#\na b go');
  * // graph.nodes = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }]
@@ -38,7 +38,7 @@ declare function fromTGF(tgf: string): Graph;
  * @example
  * ```ts
  * import { createGraph } from '@statelyai/graph';
- * import { tgfConverter } from '@statelyai/graph/formats/tgf';
+ * import { tgfConverter } from '@statelyai/graph/tgf';
  *
  * const graph = createGraph({
  *   nodes: [{ id: 'a' }, { id: 'b' }],

package/dist/formats/tgf/index.mjs

@@ -1,4 +1,4 @@
-import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
+import { n as createFormatConverter } from "../../converter-DB6Rg6Vd.mjs";
 
 //#region src/formats/tgf/index.ts
 /**
@@ -7,7 +7,7 @@ import { n as createFormatConverter } from "../../converter-DyCJJfTe.mjs";
 * @example
 * ```ts
 * import { createGraph } from '@statelyai/graph';
-* import { toTGF } from '@statelyai/graph/formats/tgf';
+* import { toTGF } from '@statelyai/graph/tgf';
 *
 * const graph = createGraph({
 *   nodes: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }],
@@ -34,7 +34,7 @@ function toTGF(graph) {
 *
 * @example
 * ```ts
-* import { fromTGF } from '@statelyai/graph/formats/tgf';
+* import { fromTGF } from '@statelyai/graph/tgf';
 *
 * const graph = fromTGF('a A\nb B\n#\na b go');
 * // graph.nodes = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }]
@@ -94,7 +94,7 @@ function fromTGF(tgf) {
 * @example
 * ```ts
 * import { createGraph } from '@statelyai/graph';
-* import { tgfConverter } from '@statelyai/graph/formats/tgf';
+* import { tgfConverter } from '@statelyai/graph/tgf';
 *
 * const graph = createGraph({
 *   nodes: [{ id: 'a' }, { id: 'b' }],

package/dist/formats/xyflow/index.d.mts

@@ -1,11 +1,17 @@
-import { L as VisualGraphFormatConverter, P as VisualGraph } from "../../types-DNYdIU21.mjs";
+import { I as VisualGraph, z as VisualGraphFormatConverter } from "../../types-BAEQTwK_.mjs";
 import { EdgeBase, NodeBase } from "@xyflow/system";
 
 //#region src/formats/xyflow/index.d.ts
 /** xyflow Node — re-exported from `@xyflow/system`. */
 type XYFlowNode<TNodeData extends Record<string, unknown> = Record<string, unknown>> = NodeBase<TNodeData>;
-/** xyflow Edge — re-exported from `@xyflow/system`. */
-type XYFlowEdge<TEdgeData extends Record<string, unknown> = Record<string, unknown>> = EdgeBase<TEdgeData>;
+/**
+ * xyflow Edge — `EdgeBase` from `@xyflow/system` plus the top-level `label`
+ * that React Flow / Svelte Flow actually render (it's a renderer prop, so
+ * `EdgeBase` itself doesn't declare it).
+ */
+type XYFlowEdge<TEdgeData extends Record<string, unknown> = Record<string, unknown>> = EdgeBase<TEdgeData> & {
+  label?: string;
+};
 interface XYFlow<TNodeData extends Record<string, unknown> = Record<string, unknown>, TEdgeData extends Record<string, unknown> = Record<string, unknown>> {
   nodes: XYFlowNode<TNodeData>[];
   edges: XYFlowEdge<TEdgeData>[];
@@ -17,7 +23,7 @@ interface XYFlow<TNodeData extends Record<string, unknown> = Record<string, unkn
  * @example
  * ```ts
  * import { createVisualGraph } from '@statelyai/graph';
- * import { toXYFlow } from '@statelyai/graph/formats/xyflow';
+ * import { toXYFlow } from '@statelyai/graph/xyflow';
  *
  * const graph = createVisualGraph({
  *   nodes: [
@@ -37,7 +43,7 @@ declare function toXYFlow(graph: VisualGraph): XYFlow;
  *
  * @example
  * ```ts
- * import { fromXYFlow } from '@statelyai/graph/formats/xyflow';
+ * import { fromXYFlow } from '@statelyai/graph/xyflow';
  *
  * const graph = fromXYFlow({
  *   nodes: [
@@ -55,7 +61,7 @@ declare function fromXYFlow(flow: XYFlow): VisualGraph;
  * @example
  * ```ts
  * import { createVisualGraph } from '@statelyai/graph';
- * import { xyflowConverter } from '@statelyai/graph/formats/xyflow';
+ * import { xyflowConverter } from '@statelyai/graph/xyflow';
  *
  * const graph = createVisualGraph({
  *   nodes: [

package/dist/formats/xyflow/index.mjs

@@ -53,7 +53,7 @@ function orderParentsFirst(nodes) {
 * @example
 * ```ts
 * import { createVisualGraph } from '@statelyai/graph';
-* import { toXYFlow } from '@statelyai/graph/formats/xyflow';
+* import { toXYFlow } from '@statelyai/graph/xyflow';
 *
 * const graph = createVisualGraph({
 *   nodes: [
@@ -93,6 +93,7 @@ function toXYFlow(graph) {
 				} })
 			};
 			if (n.parentId) node.parentId = n.parentId;
+			if (n.label) node.data.label = n.label;
 			if (n.shape) node.type = n.shape;
 			if (n.width !== void 0) node.width = n.width;
 			if (n.height !== void 0) node.height = n.height;
@@ -110,6 +111,8 @@ function toXYFlow(graph) {
 				label: e.label,
 				mode: e.mode,
 				weight: e.weight,
+				points: e.points,
+				routing: e.routing,
 				color: e.color,
 				style: e.style,
 				x: e.x,
@@ -117,7 +120,7 @@ function toXYFlow(graph) {
 				width: e.width,
 				height: e.height
 			} });
-			if (e.label) edge.data.label = e.label;
+			if (e.label) edge.label = e.label;
 			return edge;
 		})
 	};
@@ -127,7 +130,7 @@ function toXYFlow(graph) {
 *
 * @example
 * ```ts
-* import { fromXYFlow } from '@statelyai/graph/formats/xyflow';
+* import { fromXYFlow } from '@statelyai/graph/xyflow';
 *
 * const graph = fromXYFlow({
 *   nodes: [
@@ -157,7 +160,7 @@ function fromXYFlow(flow) {
 				id: n.id,
 				parentId: n.parentId ?? null,
 				initialNodeId: metadata && "initialNodeId" in metadata ? metadata.initialNodeId : null,
-				label: metadata && "label" in metadata ? metadata.label : "",
+				label: metadata && "label" in metadata ? metadata.label : n.data?.label?.toString() ?? "",
 				data: readUserData(n.data),
 				x: n.position.x,
 				y: n.position.y,
@@ -176,7 +179,7 @@ function fromXYFlow(flow) {
 				id: e.id ?? `e${i}`,
 				sourceId: e.source,
 				targetId: e.target,
-				label: metadata && "label" in metadata ? metadata.label : e.data?.label?.toString() ?? "",
+				label: metadata && "label" in metadata ? metadata.label : e.label ?? e.data?.label?.toString() ?? "",
 				...e.sourceHandle && { sourcePort: e.sourceHandle },
 				...e.targetHandle && { targetPort: e.targetHandle },
 				data: readUserData(e.data),
@@ -186,6 +189,8 @@ function fromXYFlow(flow) {
 				height: metadata?.height ?? 0,
 				...metadata?.mode !== void 0 && { mode: metadata.mode },
 				...metadata?.weight !== void 0 && { weight: metadata.weight },
+				...metadata?.points !== void 0 && { points: metadata.points },
+				...metadata?.routing !== void 0 && { routing: metadata.routing },
 				...metadata?.color !== void 0 && { color: metadata.color },
 				...metadata?.style !== void 0 && { style: metadata.style }
 			};
@@ -198,7 +203,7 @@ function fromXYFlow(flow) {
 * @example
 * ```ts
 * import { createVisualGraph } from '@statelyai/graph';
-* import { xyflowConverter } from '@statelyai/graph/formats/xyflow';
+* import { xyflowConverter } from '@statelyai/graph/xyflow';
 *
 * const graph = createVisualGraph({
 *   nodes: [

package/dist/{index-D51lJnt2.d.mts → index-BlbSWUvH.d.mts}

@@ -1,4 +1,4 @@
-import { d as Graph, g as GraphFormatConverter } from "./types-DNYdIU21.mjs";
+import { _ as GraphFormatConverter, f as Graph } from "./types-BAEQTwK_.mjs";
 
 //#region src/formats/converter/index.d.ts
 

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

@@ -1,4 +1,4 @@
-import { E as NodeUpdate, F as VisualGraphConfig, H as WeightedWalkOptions, O as PortConfig, P as VisualGraph, S as GraphStep, T as NodeConfig, V as WalkOptions, _ as GraphMode, c as EntitiesConfig, d as Graph, f as GraphConfig, i as DeleteNodeOptions, j as TransitionOptions, l as EntitiesUpdate, m as GraphEdge, o as EdgeConfig, p as GraphDiff, r as CoverageStats, s as EdgeUpdate, v as GraphNode, x as GraphPort, y as GraphPatch } from "./types-DNYdIU21.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
 
@@ -383,22 +383,52 @@ declare function getGraphIssues(graph: Graph): GraphIssue[];
  *
  * @example
  * ```ts
- * import { createGraph, invalidateIndex, getIndex } from '@statelyai/graph';
+ * import { createGraph, getSuccessors, invalidateIndex } from '@statelyai/graph';
  *
  * 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 getIndex()
+ * 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.
@@ -481,17 +511,21 @@ 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`.
@@ -516,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.
@@ -574,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: [
@@ -586,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
@@ -621,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' }],
@@ -631,13 +673,17 @@ 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
@@ -668,24 +714,46 @@ declare function genPredefinedWalk<N, E>(graph: Graph<N, E>, edgeIds: string[],
 /**
  * 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.
@@ -694,4 +762,4 @@ declare function getCoverage<N, E>(graph: Graph<N, E>, steps: GraphStep<N, E>[],
   from?: string;
 }): CoverageStats;
 //#endregion
-export { GraphInstance as A, deleteEdge as B, isLayoutEqual as C, getGraphIssues as D, GraphIssue as E, createGraphEdge as F, hasEdge as G, deleteNode as H, createGraphFromTransition as I, updateEntities as J, hasNode as K, createGraphNode as L, addEntities as M, addNode as N, getEdgeMode as O, createGraph as P, createGraphPort as R, areEntitiesEqual as S, invalidateIndex as T, getEdge as U, deleteEntities as V, getNode as W, updateNode as Y, 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, addEdge as j, isEdgeDirected as k, takeUntilNode as l, applyPatches as m, genQuickRandomWalk as n, takeSteps as o, reverseGraph as p, updateEdge 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, createVisualGraph 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 SinglePathOptions, B as WalkContext, C as MSTOptions, D as PathOptions, E as NodeUpdate, F as VisualGraphConfig, H as WeightedWalkOptions, I as VisualGraphEntity, L as VisualGraphFormatConverter, M as TraversalOptions, N as VisualEdge, O as PortConfig, P as VisualGraph, R as VisualNode, S as GraphStep, T as NodeConfig, V as WalkOptions, _ as GraphMode, a as EdgeChange, b as GraphPath, c as EntitiesConfig, d as Graph, f as GraphConfig, g as GraphFormatConverter, h as GraphEntity, i as DeleteNodeOptions, j as TransitionOptions, k as PortDirection, l as EntitiesUpdate, m as GraphEdge, n as AllPairsShortestPathsOptions, o as EdgeConfig, p as GraphDiff, r as CoverageStats, s as EdgeUpdate, t as AStarOptions, u as EntityRect, v as GraphNode, w as NodeChange, x as GraphPort, y as GraphPatch, z as VisualPort } from "./types-DNYdIU21.mjs";
-import { $ as getTopologicalSort, A as getPageRank, B as genSimplePaths, C as getBetweennessCentrality, D as getHITS, E as getEigenvectorCentrality, F as getPostorders, G as getShortestPaths, H as getAllPairsShortestPaths, I as getPreorder, J as getStronglyConnectedComponents, K as getSimplePath, L as getPreorders, M as genPostorders, N as genPreorders, O as getInDegreeCentrality, P as getPostorder, Q as getConnectedComponents, R as genCycles, S as IterativeCentralityOptions, T as getDegreeCentrality, U as getCycles, V as getAStarPath, W as getShortestPath, X as bfs, Y as joinPaths, Z as dfs, _ as getGirvanNewmanCommunities, a as MaxFlowResult, b as getModularity, c as getLouvainCommunities, d as getArticulationPoints, et as hasPath, f as getBiconnectedComponents, g as genGirvanNewmanCommunities, h as LabelPropagationOptions, i as MaxFlowOptions, j as getMinimumSpanningTree, k as getOutDegreeCentrality, l as IsomorphismOptions, m as GirvanNewmanOptions, n as DominatorTreeOptions, nt as isConnected, o as getMaxFlow, p as getBridges, q as getSimplePaths, r as getDominatorTree, rt as isTree, s as LouvainOptions, t as getTransitiveReduction, tt as isAcyclic, u as isIsomorphic, v as getGreedyModularityCommunities, w as getClosenessCentrality, x as HITSResult, y as getLabelPropagationCommunities, z as genShortestPaths } from "./algorithms-CsGNehct.mjs";
-import { n as createFormatConverter } from "./index-D51lJnt2.mjs";
-import { A as GraphInstance, B as deleteEdge, C as isLayoutEqual, D as getGraphIssues, E as GraphIssue, F as createGraphEdge, G as hasEdge, H as deleteNode, I as createGraphFromTransition, J as updateEntities, K as hasNode, L as createGraphNode, M as addEntities, N as addNode, O as getEdgeMode, P as createGraph, R as createGraphPort, S as areEntitiesEqual, T as invalidateIndex, U as getEdge, V as deleteEntities, W as getNode, Y as updateNode, _ 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 addEdge, k as isEdgeDirected, l as takeUntilNode, m as applyPatches, n as genQuickRandomWalk, o as takeSteps, p as reverseGraph, q as updateEdge, 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 createVisualGraph } from "./index-DWmo1mIp.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-BfXeTXRf.mjs";
-export { AStarOptions, AllPairsShortestPathsOptions, CoverageStats, DeleteNodeOptions, DominatorTreeOptions, EdgeChange, EdgeConfig, EdgeUpdate, EntitiesConfig, EntitiesUpdate, EntityRect, GirvanNewmanOptions, Graph, GraphConfig, GraphDiff, GraphEdge, GraphEntity, GraphFormatConverter, GraphInstance, GraphIssue, GraphMode, GraphNode, GraphPatch, GraphPath, GraphPort, GraphStep, HITSResult, IsomorphismOptions, IterativeCentralityOptions, LAYOUT_KEYS, LabelPropagationOptions, LouvainOptions, MSTOptions, MaxFlowOptions, MaxFlowResult, NodeChange, NodeConfig, NodeUpdate, 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, getDominatorTree, getEdge, getEdgeMode, getEdgesBetween, getEdgesByPort, getEdgesOf, getEigenvectorCentrality, getGirvanNewmanCommunities, getGraphIssues, getGreedyModularityCommunities, getHITS, getInDegree, getInDegreeCentrality, getInEdges, getLCA, getLabelPropagationCommunities, getLouvainCommunities, getMaxFlow, 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, getTransitiveReduction, 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 };