@statelyai/graph 1.0.0 → 2.1.0

package/dist/algorithms-Ba7o7niK.mjs

@@ -1,2394 +0,0 @@
-import { a as indexUpdateEdgeEndpoints, i as indexReparentNode, n as indexAddEdge, o as invalidateIndex, r as indexAddNode, t as getIndex } from "./indexing-DR8M1vBy.mjs";
-import { t as getEdgeMode } from "./mode-D8OnHFBk.mjs";
-
-//#region src/graph.ts
-/**
-* Create a resolved graph port from a config. Fills in defaults.
-*
-* @example
-* ```ts
-* const port = createGraphPort({ name: 'output', direction: 'out' });
-* // { name: 'output', direction: 'out', data: null }
-* ```
-*/
-function createGraphPort(config) {
-	if (!config.name) throw new Error("Port name must be a non-empty string");
-	const port = {
-		name: config.name,
-		direction: config.direction ?? "inout",
-		data: config.data ?? null
-	};
-	if (config.label !== void 0) port.label = config.label;
-	if (config.x !== void 0) port.x = config.x;
-	if (config.y !== void 0) port.y = config.y;
-	if (config.width !== void 0) port.width = config.width;
-	if (config.height !== void 0) port.height = config.height;
-	if (config.style !== void 0) port.style = config.style;
-	return port;
-}
-function validatePortNames(ports) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const port of ports) {
-		if (seen.has(port.name)) throw new Error(`Duplicate port name "${port.name}" on node`);
-		seen.add(port.name);
-	}
-}
-/**
-* Create a resolved graph node from a config. Fills in defaults.
-*
-* @example
-* ```ts
-* const node = createGraphNode({ id: 'a', data: { label: 'hi' } });
-* // { type: 'node', id: 'a', label: '', data: { label: 'hi' } }
-* ```
-*/
-function createGraphNode(config) {
-	if (!config.id) throw new Error("Node id must be a non-empty string");
-	if (config.parentId === "") throw new Error("Node parentId must be a non-empty string");
-	const node = {
-		type: "node",
-		id: config.id,
-		...config.parentId !== void 0 && { parentId: config.parentId ?? null },
-		...config.initialNodeId !== void 0 && { initialNodeId: config.initialNodeId ?? null },
-		label: config.label ?? null,
-		data: config.data ?? null
-	};
-	if (config.ports !== void 0 && config.ports.length > 0) {
-		validatePortNames(config.ports);
-		node.ports = config.ports.map(createGraphPort);
-	}
-	if (config.x !== void 0) node.x = config.x;
-	if (config.y !== void 0) node.y = config.y;
-	if (config.width !== void 0) node.width = config.width;
-	if (config.height !== void 0) node.height = config.height;
-	if (config.shape !== void 0) node.shape = config.shape;
-	if (config.color !== void 0) node.color = config.color;
-	if (config.style !== void 0) node.style = config.style;
-	return node;
-}
-/**
-* Create a resolved graph edge from a config. Fills in defaults.
-*
-* @example
-* ```ts
-* const edge = createGraphEdge({ id: 'e1', sourceId: 'a', targetId: 'b' });
-* // { type: 'edge', id: 'e1', sourceId: 'a', targetId: 'b', label: null, data: null }
-* ```
-*/
-function createGraphEdge(config) {
-	if (!config.id) throw new Error("Edge id must be a non-empty string");
-	if (!config.sourceId) throw new Error("Edge sourceId must be a non-empty string");
-	if (!config.targetId) throw new Error("Edge targetId must be a non-empty string");
-	const edge = {
-		type: "edge",
-		id: config.id,
-		sourceId: config.sourceId,
-		targetId: config.targetId,
-		label: config.label ?? null,
-		data: config.data ?? null
-	};
-	if (config.sourcePort !== void 0) edge.sourcePort = config.sourcePort;
-	if (config.targetPort !== void 0) edge.targetPort = config.targetPort;
-	if (config.mode !== void 0) edge.mode = config.mode;
-	if (config.weight !== void 0) edge.weight = config.weight;
-	if (config.x !== void 0) edge.x = config.x;
-	if (config.y !== void 0) edge.y = config.y;
-	if (config.width !== void 0) edge.width = config.width;
-	if (config.height !== void 0) edge.height = config.height;
-	if (config.color !== void 0) edge.color = config.color;
-	if (config.style !== void 0) edge.style = config.style;
-	return edge;
-}
-/**
-* Create a graph from a config. Resolves defaults for all fields.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* ```
-*/
-function createGraph(config) {
-	const graph = {
-		id: config?.id ?? "",
-		mode: config?.mode ?? "directed",
-		initialNodeId: config?.initialNodeId ?? null,
-		nodes: (config?.nodes ?? []).map(createGraphNode),
-		edges: (config?.edges ?? []).map(createGraphEdge),
-		data: config?.data ?? null
-	};
-	if (config?.direction !== void 0) graph.direction = config.direction;
-	if (config?.style !== void 0) graph.style = config.style;
-	return graph;
-}
-/**
-* Create a visual graph with required position/size on all nodes and edges.
-*
-* @example
-* ```ts
-* const graph = createVisualGraph({
-*   nodes: [{ id: 'a', x: 0, y: 0, width: 100, height: 50 }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'a', x: 0, y: 0, width: 0, height: 0 }],
-* });
-* // graph.nodes[0].x === 0
-* ```
-*/
-function createVisualGraph(config) {
-	const base = createGraph(config);
-	return {
-		...base,
-		direction: config?.direction ?? "down",
-		nodes: base.nodes.map((n) => {
-			const { ports, ...rest } = n;
-			return {
-				...rest,
-				x: n.x ?? 0,
-				y: n.y ?? 0,
-				width: n.width ?? 0,
-				height: n.height ?? 0,
-				...n.shape !== void 0 && { shape: n.shape },
-				...ports !== void 0 && { ports: ports.map((p) => ({
-					...p,
-					x: p.x ?? 0,
-					y: p.y ?? 0,
-					width: p.width ?? 0,
-					height: p.height ?? 0
-				})) }
-			};
-		}),
-		edges: base.edges.map((e) => ({
-			...e,
-			x: e.x ?? 0,
-			y: e.y ?? 0,
-			width: e.width ?? 0,
-			height: e.height ?? 0
-		}))
-	};
-}
-/**
-* Create a graph by BFS exploration of a transition function.
-* Each unique state becomes a node; each (state, event) -> nextState becomes an edge.
-*
-* - Node IDs are determined by `serializeState` (default: `JSON.stringify`).
-* - Edge IDs use the format `sourceId|serializedEvent|targetId` for uniqueness
-*   and debuggability. Edge labels are just the serialized event string.
-*
-* @example
-* ```ts
-* const graph = createGraphFromTransition(
-*   (state, event) => {
-*     if (state === 'green' && event === 'TIMER') return 'yellow';
-*     if (state === 'yellow' && event === 'TIMER') return 'red';
-*     if (state === 'red' && event === 'TIMER') return 'green';
-*     return state;
-*   },
-*   {
-*     initialState: 'green',
-*     events: ['TIMER'],
-*     serializeState: (s) => s,
-*     serializeEvent: (e) => e,
-*   },
-* );
-* // graph.nodes.length === 3
-* ```
-*/
-function createGraphFromTransition(transition, options) {
-	const serializeState = options.serializeState ?? JSON.stringify;
-	const serializeEvent = options.serializeEvent ?? JSON.stringify;
-	const limit = options.limit ?? Infinity;
-	const getEvents = typeof options.events === "function" ? options.events : () => options.events;
-	const nodes = [];
-	const edges = [];
-	const visited = /* @__PURE__ */ new Set();
-	const edgeSet = /* @__PURE__ */ new Set();
-	const queue = [options.initialState];
-	const initialStateId = serializeState(options.initialState);
-	visited.add(initialStateId);
-	nodes.push({
-		id: initialStateId,
-		label: initialStateId,
-		data: options.initialState
-	});
-	let iterations = 0;
-	while (queue.length > 0) {
-		const state = queue.shift();
-		const stateId = serializeState(state);
-		if (++iterations > limit) throw new Error("Traversal limit exceeded");
-		if (options.stopWhen?.(state)) continue;
-		const events = getEvents(state);
-		for (const event of events) {
-			const nextState = transition(state, event);
-			const nextStateId = serializeState(nextState);
-			const eventStr = serializeEvent(event);
-			if (!visited.has(nextStateId)) {
-				visited.add(nextStateId);
-				nodes.push({
-					id: nextStateId,
-					label: nextStateId,
-					data: nextState
-				});
-				queue.push(nextState);
-			}
-			const edgeKey = `${stateId}|${eventStr}|${nextStateId}`;
-			if (!edgeSet.has(edgeKey)) {
-				edgeSet.add(edgeKey);
-				edges.push({
-					id: edgeKey,
-					sourceId: stateId,
-					targetId: nextStateId,
-					label: eventStr,
-					data: event
-				});
-			}
-		}
-	}
-	return createGraph({
-		id: options.id ?? "",
-		mode: "directed",
-		initialNodeId: initialStateId,
-		nodes,
-		edges
-	});
-}
-/**
-* Get a node by id, or `undefined` if not found.
-*
-* @example
-* ```ts
-* const graph = createGraph({ nodes: [{ id: 'a' }] });
-* const node = getNode(graph, 'a'); // GraphNode
-* const missing = getNode(graph, 'z'); // undefined
-* ```
-*/
-function getNode(graph, id) {
-	const arrayIdx = getIndex(graph).nodeById.get(id);
-	return arrayIdx !== void 0 ? graph.nodes[arrayIdx] : void 0;
-}
-/**
-* Get an edge by id, or `undefined` if not found.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* const edge = getEdge(graph, 'e1'); // GraphEdge
-* const missing = getEdge(graph, 'z'); // undefined
-* ```
-*/
-function getEdge(graph, id) {
-	const arrayIdx = getIndex(graph).edgeById.get(id);
-	return arrayIdx !== void 0 ? graph.edges[arrayIdx] : void 0;
-}
-/**
-* Check if a node exists in the graph.
-*
-* @example
-* ```ts
-* const graph = createGraph({ nodes: [{ id: 'a' }] });
-* hasNode(graph, 'a'); // true
-* hasNode(graph, 'z'); // false
-* ```
-*/
-function hasNode(graph, id) {
-	return getIndex(graph).nodeById.has(id);
-}
-/**
-* Check if an edge exists in the graph.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* hasEdge(graph, 'e1'); // true
-* hasEdge(graph, 'z'); // false
-* ```
-*/
-function hasEdge(graph, id) {
-	return getIndex(graph).edgeById.has(id);
-}
-/**
-* **Mutable.** Add a node to the graph. Mutates `graph.nodes` in place.
-* @returns The resolved node that was added.
-*
-* @example
-* ```ts
-* const graph = createGraph();
-* const node = addNode(graph, { id: 'a', label: 'Node A' });
-* // graph.nodes.length === 1
-* ```
-*/
-function addNode(graph, config) {
-	const node = createGraphNode(config);
-	const idx = getIndex(graph);
-	if (idx.nodeById.has(config.id)) throw new Error(`Node "${config.id}" already exists`);
-	if (config.parentId && !idx.nodeById.has(config.parentId)) throw new Error(`Parent node "${config.parentId}" does not exist`);
-	indexAddNode(idx, node, graph.nodes.push(node) - 1);
-	return node;
-}
-/**
-* **Mutable.** Add an edge to the graph. Mutates `graph.edges` in place.
-* @returns The resolved edge that was added.
-*
-* @example
-* ```ts
-* const graph = createGraph({ nodes: [{ id: 'a' }, { id: 'b' }] });
-* const edge = addEdge(graph, { id: 'e1', sourceId: 'a', targetId: 'b' });
-* // graph.edges.length === 1
-* ```
-*/
-function addEdge(graph, config) {
-	const edge = createGraphEdge(config);
-	const idx = getIndex(graph);
-	if (idx.edgeById.has(config.id)) throw new Error(`Edge "${config.id}" already exists`);
-	if (!idx.nodeById.has(config.sourceId)) throw new Error(`Source node "${config.sourceId}" does not exist`);
-	if (!idx.nodeById.has(config.targetId)) throw new Error(`Target node "${config.targetId}" does not exist`);
-	if (config.sourcePort !== void 0) {
-		if (!graph.nodes[idx.nodeById.get(config.sourceId)].ports?.some((p) => p.name === config.sourcePort)) throw new Error(`Port "${config.sourcePort}" does not exist on source node "${config.sourceId}"`);
-	}
-	if (config.targetPort !== void 0) {
-		if (!graph.nodes[idx.nodeById.get(config.targetId)].ports?.some((p) => p.name === config.targetPort)) throw new Error(`Port "${config.targetPort}" does not exist on target node "${config.targetId}"`);
-	}
-	indexAddEdge(idx, edge, graph.edges.push(edge) - 1);
-	return edge;
-}
-/**
-* **Mutable.** Delete a node and its connected edges. Mutates `graph.nodes`
-* and `graph.edges` in place.
-*
-* By default, children are deleted recursively.
-* With `{ reparent: true }`, children are re-parented to the deleted node's parent.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* deleteNode(graph, 'a');
-* // graph.nodes.length === 1, edge e1 also removed
-* ```
-*/
-function deleteNode(graph, id, opts) {
-	const node = getNode(graph, id);
-	if (!node) throw new Error(`Node "${id}" does not exist`);
-	if (opts?.reparent) {
-		for (const n of graph.nodes) if (n.parentId === id) n.parentId = node.parentId;
-		graph.nodes = graph.nodes.filter((n) => n.id !== id);
-		graph.edges = graph.edges.filter((e) => e.sourceId !== id && e.targetId !== id);
-	} else {
-		const toDelete = collectDescendants(graph, id);
-		graph.nodes = graph.nodes.filter((n) => !toDelete.has(n.id));
-		graph.edges = graph.edges.filter((e) => !toDelete.has(e.sourceId) && !toDelete.has(e.targetId));
-	}
-	invalidateIndex(graph);
-}
-/**
-* **Mutable.** Delete an edge. Mutates `graph.edges` in place.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* deleteEdge(graph, 'e1');
-* // graph.edges.length === 0
-* ```
-*/
-function deleteEdge(graph, id) {
-	if (!hasEdge(graph, id)) throw new Error(`Edge "${id}" does not exist`);
-	graph.edges = graph.edges.filter((e) => e.id !== id);
-	invalidateIndex(graph);
-}
-/**
-* **Mutable.** Update a node in place.
-* @returns The updated node.
-*
-* @example
-* ```ts
-* const graph = createGraph({ nodes: [{ id: 'a', label: 'old' }] });
-* const updated = updateNode(graph, 'a', { label: 'new' });
-* // updated.label === 'new'
-* ```
-*/
-function updateNode(graph, id, update) {
-	const idx = getIndex(graph);
-	const arrayIdx = idx.nodeById.get(id);
-	if (arrayIdx === void 0) throw new Error(`Node "${id}" does not exist`);
-	if (update.parentId !== void 0 && update.parentId !== null) {
-		if (!idx.nodeById.has(update.parentId)) throw new Error(`Parent node "${update.parentId}" does not exist`);
-	}
-	if (update.ports !== void 0 && update.ports.length > 0) validatePortNames(update.ports);
-	const node = graph.nodes[arrayIdx];
-	const oldParentId = node.parentId;
-	const updated = {
-		...node,
-		...update.parentId !== void 0 && { parentId: update.parentId ?? null },
-		...update.initialNodeId !== void 0 && { initialNodeId: update.initialNodeId ?? null },
-		...update.label !== void 0 && { label: update.label },
-		...update.data !== void 0 && { data: update.data },
-		...update.ports !== void 0 && { ports: update.ports.map(createGraphPort) }
-	};
-	graph.nodes[arrayIdx] = updated;
-	if (update.parentId !== void 0 && updated.parentId !== oldParentId) indexReparentNode(idx, id, oldParentId, updated.parentId);
-	return updated;
-}
-/**
-* **Mutable.** Update an edge in place.
-* @returns The updated edge.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b', label: 'old' }],
-* });
-* const updated = updateEdge(graph, 'e1', { label: 'new' });
-* // updated.label === 'new'
-* ```
-*/
-function updateEdge(graph, id, update) {
-	const idx = getIndex(graph);
-	const arrayIdx = idx.edgeById.get(id);
-	if (arrayIdx === void 0) throw new Error(`Edge "${id}" does not exist`);
-	if (update.sourceId !== void 0 && !idx.nodeById.has(update.sourceId)) throw new Error(`Source node "${update.sourceId}" does not exist`);
-	if (update.targetId !== void 0 && !idx.nodeById.has(update.targetId)) throw new Error(`Target node "${update.targetId}" does not exist`);
-	const edge = graph.edges[arrayIdx];
-	const oldSourceId = edge.sourceId;
-	const oldTargetId = edge.targetId;
-	const effectiveSourceId = update.sourceId ?? edge.sourceId;
-	const effectiveTargetId = update.targetId ?? edge.targetId;
-	if (update.sourcePort !== void 0) {
-		if (!graph.nodes[idx.nodeById.get(effectiveSourceId)].ports?.some((p) => p.name === update.sourcePort)) throw new Error(`Port "${update.sourcePort}" does not exist on source node "${effectiveSourceId}"`);
-	}
-	if (update.targetPort !== void 0) {
-		if (!graph.nodes[idx.nodeById.get(effectiveTargetId)].ports?.some((p) => p.name === update.targetPort)) throw new Error(`Port "${update.targetPort}" does not exist on target node "${effectiveTargetId}"`);
-	}
-	const updated = {
-		...edge,
-		...update.sourceId !== void 0 && { sourceId: update.sourceId },
-		...update.targetId !== void 0 && { targetId: update.targetId },
-		...update.label !== void 0 && { label: update.label },
-		...update.data !== void 0 && { data: update.data },
-		...update.sourcePort !== void 0 && { sourcePort: update.sourcePort },
-		...update.targetPort !== void 0 && { targetPort: update.targetPort }
-	};
-	graph.edges[arrayIdx] = updated;
-	if (updated.sourceId !== oldSourceId || updated.targetId !== oldTargetId) indexUpdateEdgeEndpoints(idx, id, oldSourceId, oldTargetId, updated.sourceId, updated.targetId);
-	return updated;
-}
-/**
-* **Mutable.** Add multiple nodes and edges to the graph.
-* Nodes are added first, then edges (so edges can reference new nodes).
-*
-* @example
-* ```ts
-* const graph = createGraph();
-* addEntities(graph, {
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* // graph.nodes.length === 2, graph.edges.length === 1
-* ```
-*/
-function addEntities(graph, entities) {
-	for (const nodeConfig of entities.nodes ?? []) addNode(graph, nodeConfig);
-	for (const edgeConfig of entities.edges ?? []) addEdge(graph, edgeConfig);
-}
-/**
-* **Mutable.** Delete entities by id(s). Automatically detects whether each id
-* is a node or edge. Node deletions cascade to children and connected edges.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* deleteEntities(graph, ['a', 'e1']);
-* // graph.nodes.length === 1, graph.edges.length === 0
-* ```
-*/
-function deleteEntities(graph, ids, opts) {
-	const idArray = Array.isArray(ids) ? ids : [ids];
-	for (const id of idArray) if (hasNode(graph, id)) deleteNode(graph, id, opts);
-	else if (hasEdge(graph, id)) deleteEdge(graph, id);
-}
-/**
-* **Mutable.** Update multiple nodes and edges in place.
-* Each entry must include an `id` to identify which entity to update.
-*
-* @example
-* ```ts
-* const graph = createGraph({
-*   nodes: [{ id: 'a', label: 'old' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'a', label: 'old' }],
-* });
-* updateEntities(graph, {
-*   nodes: [{ id: 'a', label: 'new' }],
-*   edges: [{ id: 'e1', label: 'new' }],
-* });
-* ```
-*/
-function updateEntities(graph, updates) {
-	for (const nodeUpdate of updates.nodes ?? []) {
-		const { id, ...patch } = nodeUpdate;
-		updateNode(graph, id, patch);
-	}
-	for (const edgeUpdate of updates.edges ?? []) {
-		const { id, ...patch } = edgeUpdate;
-		updateEdge(graph, id, patch);
-	}
-}
-/**
-* OOP wrapper around a plain `Graph` object.
-* Delegates to the standalone mutable functions.
-*
-* @example
-* ```ts
-* const instance = new GraphInstance({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
-* });
-* instance.addNode({ id: 'c' });
-* instance.hasNode('c'); // true
-* instance.toJSON(); // plain Graph object
-* ```
-*/
-var GraphInstance = class GraphInstance {
-	graph;
-	constructor(config) {
-		this.graph = createGraph(config);
-	}
-	/**
-	* Wrap an existing plain graph object.
-	*
-	* @example
-	* ```ts
-	* const graph = createGraph({ nodes: [{ id: 'a' }] });
-	* const instance = GraphInstance.from(graph);
-	* instance.hasNode('a'); // true
-	* ```
-	*/
-	static from(graph) {
-		const instance = Object.create(GraphInstance.prototype);
-		instance.graph = graph;
-		return instance;
-	}
-	get id() {
-		return this.graph.id;
-	}
-	/** Default directedness for all edges. */
-	get mode() {
-		return this.graph.mode;
-	}
-	get nodes() {
-		return this.graph.nodes;
-	}
-	get edges() {
-		return this.graph.edges;
-	}
-	get data() {
-		return this.graph.data;
-	}
-	getNode(id) {
-		return getNode(this.graph, id);
-	}
-	getEdge(id) {
-		return getEdge(this.graph, id);
-	}
-	hasNode(id) {
-		return hasNode(this.graph, id);
-	}
-	hasEdge(id) {
-		return hasEdge(this.graph, id);
-	}
-	addNode(config) {
-		return addNode(this.graph, config);
-	}
-	addEdge(config) {
-		return addEdge(this.graph, config);
-	}
-	deleteNode(id, opts) {
-		return deleteNode(this.graph, id, opts);
-	}
-	deleteEdge(id) {
-		return deleteEdge(this.graph, id);
-	}
-	updateNode(id, update) {
-		return updateNode(this.graph, id, update);
-	}
-	updateEdge(id, update) {
-		return updateEdge(this.graph, id, update);
-	}
-	addEntities(entities) {
-		return addEntities(this.graph, entities);
-	}
-	deleteEntities(ids, opts) {
-		return deleteEntities(this.graph, ids, opts);
-	}
-	updateEntities(updates) {
-		return updateEntities(this.graph, updates);
-	}
-	toJSON() {
-		return this.graph;
-	}
-};
-function collectDescendants(graph, id) {
-	const idx = getIndex(graph);
-	const toDelete = /* @__PURE__ */ new Set();
-	const walk = (nodeId) => {
-		toDelete.add(nodeId);
-		const childIds = idx.childNodes.get(nodeId) ?? [];
-		for (const childId of childIds) if (!toDelete.has(childId)) walk(childId);
-	};
-	walk(id);
-	return toDelete;
-}
-
-//#endregion
-//#region src/algorithms/shared.ts
-var MinPriorityQueue = class {
-	items = [];
-	constructor(compare) {
-		this.compare = compare;
-	}
-	get size() {
-		return this.items.length;
-	}
-	push(item) {
-		this.items.push(item);
-		this.bubbleUp(this.items.length - 1);
-	}
-	pop() {
-		if (this.items.length === 0) return void 0;
-		const first = this.items[0];
-		const last = this.items.pop();
-		if (this.items.length > 0) {
-			this.items[0] = last;
-			this.bubbleDown(0);
-		}
-		return first;
-	}
-	bubbleUp(index) {
-		let current = index;
-		while (current > 0) {
-			const parent = Math.floor((current - 1) / 2);
-			if (this.compare(this.items[current], this.items[parent]) >= 0) break;
-			[this.items[current], this.items[parent]] = [this.items[parent], this.items[current]];
-			current = parent;
-		}
-	}
-	bubbleDown(index) {
-		let current = index;
-		while (true) {
-			const left = current * 2 + 1;
-			const right = left + 1;
-			let smallest = current;
-			if (left < this.items.length && this.compare(this.items[left], this.items[smallest]) < 0) smallest = left;
-			if (right < this.items.length && this.compare(this.items[right], this.items[smallest]) < 0) smallest = right;
-			if (smallest === current) break;
-			[this.items[current], this.items[smallest]] = [this.items[smallest], this.items[current]];
-			current = smallest;
-		}
-	}
-};
-function getNeighborIds$1(graph, nodeId) {
-	const idx = getIndex(graph);
-	const ids = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) ids.push(graph.edges[ai].targetId);
-	}
-	for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai === void 0) continue;
-		const edge = graph.edges[ai];
-		if (getEdgeMode(graph, edge) !== "directed") ids.push(edge.sourceId);
-	}
-	return ids;
-}
-function getSuccessorIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)].targetId);
-}
-function resolveFrom(graph, opts) {
-	if (opts?.from) return opts.from;
-	if (graph.initialNodeId) return graph.initialNodeId;
-	const inDeg = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes) inDeg.set(node.id, 0);
-	for (const edge of graph.edges) inDeg.set(edge.targetId, (inDeg.get(edge.targetId) ?? 0) + 1);
-	const roots = [...inDeg.entries()].filter(([, degree]) => degree === 0).map(([id]) => id);
-	if (roots.length === 1) return roots[0];
-	throw new Error("Cannot determine start node — provide opts.from or set graph.initialNodeId");
-}
-function getNeighborEdges(graph, nodeId) {
-	const idx = getIndex(graph);
-	const result = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const edge = graph.edges[ai];
-			result.push({
-				neighborId: edge.targetId,
-				edge
-			});
-		}
-	}
-	for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const edge = graph.edges[ai];
-			if (getEdgeMode(graph, edge) !== "directed") result.push({
-				neighborId: edge.sourceId,
-				edge
-			});
-		}
-	}
-	return result;
-}
-function getNeighborEdgesAll(graph, nodeId) {
-	const idx = getIndex(graph);
-	const result = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const edge = graph.edges[ai];
-			result.push({
-				neighborId: edge.targetId,
-				edge
-			});
-		}
-	}
-	for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const edge = graph.edges[ai];
-			result.push({
-				neighborId: edge.sourceId,
-				edge
-			});
-		}
-	}
-	return result;
-}
-
-//#endregion
-//#region src/algorithms/paths.ts
-function computeShortestDistances(graph, sourceId, getWeight, algorithm) {
-	if (algorithm === "bellman-ford") return bellmanFord(graph, sourceId, getWeight);
-	const dist = /* @__PURE__ */ new Map();
-	const prev = /* @__PURE__ */ new Map();
-	dist.set(sourceId, 0);
-	prev.set(sourceId, []);
-	if (!getWeight && !graph.edges.some((edge) => edge.weight !== void 0)) {
-		const queue = [sourceId];
-		while (queue.length > 0) {
-			const id = queue.shift();
-			const distance = dist.get(id);
-			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
-				const nextDistance = distance + 1;
-				const existing = dist.get(neighborId);
-				if (existing === void 0) {
-					dist.set(neighborId, nextDistance);
-					prev.set(neighborId, [{
-						from: id,
-						edge
-					}]);
-					queue.push(neighborId);
-				} else if (existing === nextDistance) prev.get(neighborId).push({
-					from: id,
-					edge
-				});
-			}
-		}
-	} else {
-		const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
-		const visited = /* @__PURE__ */ new Set();
-		const pq = new MinPriorityQueue((a, b) => a.dist - b.dist);
-		pq.push({
-			id: sourceId,
-			dist: 0
-		});
-		while (pq.size > 0) {
-			const { id, dist: distance } = pq.pop();
-			if (visited.has(id) || distance !== dist.get(id)) continue;
-			visited.add(id);
-			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
-				const nextDistance = distance + effectiveWeight(edge);
-				const existing = dist.get(neighborId);
-				if (existing === void 0 || nextDistance < existing) {
-					dist.set(neighborId, nextDistance);
-					prev.set(neighborId, [{
-						from: id,
-						edge
-					}]);
-					pq.push({
-						id: neighborId,
-						dist: nextDistance
-					});
-				} else if (existing === nextDistance) prev.get(neighborId).push({
-					from: id,
-					edge
-				});
-			}
-		}
-	}
-	return {
-		dist,
-		prev
-	};
-}
-function bellmanFord(graph, sourceId, getWeight) {
-	const dist = /* @__PURE__ */ new Map();
-	const prev = /* @__PURE__ */ new Map();
-	const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
-	for (const node of graph.nodes) {
-		dist.set(node.id, Infinity);
-		prev.set(node.id, []);
-	}
-	dist.set(sourceId, 0);
-	const directedEdges = [];
-	for (const edge of graph.edges) {
-		directedEdges.push({
-			fromId: edge.sourceId,
-			toId: edge.targetId,
-			edge
-		});
-		if (getEdgeMode(graph, edge) !== "directed") directedEdges.push({
-			fromId: edge.targetId,
-			toId: edge.sourceId,
-			edge
-		});
-	}
-	for (let i = 0; i < graph.nodes.length - 1; i++) {
-		let changed = false;
-		for (const { fromId, toId, edge } of directedEdges) {
-			const distance = dist.get(fromId);
-			if (distance === Infinity) continue;
-			const nextDistance = distance + effectiveWeight(edge);
-			const existing = dist.get(toId);
-			if (nextDistance < existing) {
-				dist.set(toId, nextDistance);
-				prev.set(toId, [{
-					from: fromId,
-					edge
-				}]);
-				changed = true;
-			} else if (nextDistance === existing && existing !== Infinity) {
-				const predecessors = prev.get(toId);
-				if (!predecessors.some((entry) => entry.from === fromId && entry.edge === edge)) predecessors.push({
-					from: fromId,
-					edge
-				});
-			}
-		}
-		if (!changed) break;
-	}
-	for (const { fromId, toId, edge } of directedEdges) {
-		const distance = dist.get(fromId);
-		if (distance === Infinity) continue;
-		if (distance + effectiveWeight(edge) < dist.get(toId)) throw new Error("Graph contains a negative-weight cycle reachable from the source node");
-	}
-	for (const [id, distance] of dist) if (distance === Infinity) {
-		dist.delete(id);
-		prev.delete(id);
-	}
-	return {
-		dist,
-		prev
-	};
-}
-function* reconstructPaths(graph, prev, sourceNode, targetId) {
-	if (targetId === sourceNode.id) {
-		yield {
-			source: sourceNode,
-			steps: []
-		};
-		return;
-	}
-	const predecessors = prev.get(targetId);
-	if (!predecessors || predecessors.length === 0) return;
-	const targetNi = getIndex(graph).nodeById.get(targetId);
-	const targetNode = targetNi !== void 0 ? graph.nodes[targetNi] : graph.nodes.find((node) => node.id === targetId);
-	for (const { from, edge } of predecessors) for (const prefix of reconstructPaths(graph, prev, sourceNode, from)) yield {
-		source: sourceNode,
-		steps: [...prefix.steps, {
-			edge,
-			node: targetNode
-		}]
-	};
-}
-function* genShortestPaths(graph, opts) {
-	const idx = getIndex(graph);
-	const sourceId = resolveFrom(graph, opts);
-	const { dist, prev } = computeShortestDistances(graph, sourceId, opts?.getWeight, opts?.algorithm);
-	const targets = opts?.to ? [opts.to].filter((id) => dist.has(id)) : [...dist.keys()].filter((id) => id !== sourceId);
-	const sourceNi = idx.nodeById.get(sourceId);
-	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((node) => node.id === sourceId);
-	for (const targetId of targets) yield* reconstructPaths(graph, prev, sourceNode, targetId);
-}
-function getShortestPaths(graph, opts) {
-	return [...genShortestPaths(graph, opts)];
-}
-function getShortestPath(graph, opts) {
-	for (const path of genShortestPaths(graph, opts)) return path;
-}
-function getSimplePaths(graph, opts) {
-	return [...genSimplePaths(graph, opts)];
-}
-function* genSimplePaths(graph, opts) {
-	const idx = getIndex(graph);
-	const sourceId = resolveFrom(graph, opts);
-	const sourceNi = idx.nodeById.get(sourceId);
-	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((node) => node.id === sourceId);
-	const targetId = opts?.to;
-	const visited = /* @__PURE__ */ new Set();
-	const currentSteps = [];
-	function* dfsCollect(nodeId) {
-		visited.add(nodeId);
-		if (targetId !== void 0) {
-			if (nodeId === targetId) {
-				yield {
-					source: sourceNode,
-					steps: [...currentSteps]
-				};
-				visited.delete(nodeId);
-				return;
-			}
-		} else if (currentSteps.length > 0) yield {
-			source: sourceNode,
-			steps: [...currentSteps]
-		};
-		for (const { neighborId, edge } of getNeighborEdges(graph, nodeId)) if (!visited.has(neighborId)) {
-			const neighborNi = idx.nodeById.get(neighborId);
-			const neighborNode = neighborNi !== void 0 ? graph.nodes[neighborNi] : graph.nodes.find((node) => node.id === neighborId);
-			currentSteps.push({
-				edge,
-				node: neighborNode
-			});
-			yield* dfsCollect(neighborId);
-			currentSteps.pop();
-		}
-		visited.delete(nodeId);
-	}
-	yield* dfsCollect(sourceId);
-}
-function getSimplePath(graph, opts) {
-	for (const path of genSimplePaths(graph, opts)) return path;
-}
-function getStronglyConnectedComponents(graph) {
-	const idx = getIndex(graph);
-	let indexCounter = 0;
-	const nodeIndex = /* @__PURE__ */ new Map();
-	const lowlink = /* @__PURE__ */ new Map();
-	const onStack = /* @__PURE__ */ new Set();
-	const stack = [];
-	const result = [];
-	function strongconnect(id) {
-		nodeIndex.set(id, indexCounter);
-		lowlink.set(id, indexCounter);
-		indexCounter++;
-		stack.push(id);
-		onStack.add(id);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].targetId;
-			if (!nodeIndex.has(neighborId)) {
-				strongconnect(neighborId);
-				lowlink.set(id, Math.min(lowlink.get(id), lowlink.get(neighborId)));
-			} else if (onStack.has(neighborId)) lowlink.set(id, Math.min(lowlink.get(id), nodeIndex.get(neighborId)));
-		}
-		if (lowlink.get(id) === nodeIndex.get(id)) {
-			const component = [];
-			let neighborId;
-			do {
-				neighborId = stack.pop();
-				onStack.delete(neighborId);
-				const ni = idx.nodeById.get(neighborId);
-				if (ni !== void 0) component.push(graph.nodes[ni]);
-			} while (neighborId !== id);
-			result.push(component);
-		}
-	}
-	for (const node of graph.nodes) if (!nodeIndex.has(node.id)) strongconnect(node.id);
-	return result;
-}
-function getCycles(graph) {
-	return [...genCycles(graph)];
-}
-function* genCycles(graph) {
-	if (graph.mode !== "directed") yield* genCyclesUndirected(graph);
-	else yield* genCyclesDirected(graph);
-}
-function* genCyclesDirected(graph) {
-	const idx = getIndex(graph);
-	const sortedIds = graph.nodes.map((node) => node.id).sort();
-	for (let startIndex = 0; startIndex < sortedIds.length; startIndex++) {
-		const startId = sortedIds[startIndex];
-		const allowed = new Set(sortedIds.slice(startIndex));
-		const visited = /* @__PURE__ */ new Set();
-		const steps = [];
-		const startNi = idx.nodeById.get(startId);
-		const startNode = graph.nodes[startNi];
-		const found = [];
-		function dfsFind(currentId) {
-			visited.add(currentId);
-			for (const eid of idx.outEdges.get(currentId) ?? []) {
-				const ai = idx.edgeById.get(eid);
-				if (ai === void 0) continue;
-				const edge = graph.edges[ai];
-				const neighborId = edge.targetId;
-				if (neighborId === startId && (steps.length > 0 || currentId === startId)) found.push({
-					source: startNode,
-					steps: [...steps, {
-						edge,
-						node: startNode
-					}]
-				});
-				else if (allowed.has(neighborId) && !visited.has(neighborId)) {
-					const ni = idx.nodeById.get(neighborId);
-					steps.push({
-						edge,
-						node: graph.nodes[ni]
-					});
-					dfsFind(neighborId);
-					steps.pop();
-				}
-			}
-			visited.delete(currentId);
-		}
-		dfsFind(startId);
-		yield* found;
-	}
-}
-function* genCyclesUndirected(graph) {
-	const idx = getIndex(graph);
-	const sortedIds = graph.nodes.map((node) => node.id).sort();
-	const seen = /* @__PURE__ */ new Set();
-	for (let startIndex = 0; startIndex < sortedIds.length; startIndex++) {
-		const startId = sortedIds[startIndex];
-		const allowed = new Set(sortedIds.slice(startIndex));
-		const visited = /* @__PURE__ */ new Set();
-		const steps = [];
-		const startNi = idx.nodeById.get(startId);
-		const startNode = graph.nodes[startNi];
-		const found = [];
-		function dfsFind(currentId, parentId) {
-			visited.add(currentId);
-			for (const { neighborId, edge } of getNeighborEdgesAll(graph, currentId)) {
-				if (neighborId === parentId) {
-					parentId = null;
-					continue;
-				}
-				if (neighborId === startId && steps.length >= 2) {
-					const innerIds = steps.map((step) => step.node.id).sort().join(",");
-					if (!seen.has(innerIds)) {
-						seen.add(innerIds);
-						found.push({
-							source: startNode,
-							steps: [...steps, {
-								edge,
-								node: startNode
-							}]
-						});
-					}
-				} else if (allowed.has(neighborId) && !visited.has(neighborId)) {
-					const ni = idx.nodeById.get(neighborId);
-					steps.push({
-						edge,
-						node: graph.nodes[ni]
-					});
-					dfsFind(neighborId, currentId);
-					steps.pop();
-				}
-			}
-			visited.delete(currentId);
-		}
-		dfsFind(startId, null);
-		yield* found;
-	}
-}
-function getAllPairsShortestPaths(graph, opts) {
-	const algorithm = opts?.algorithm ?? "dijkstra";
-	if (algorithm === "floyd-warshall") return floydWarshallAllPaths(graph, opts?.getWeight);
-	if (algorithm === "bellman-ford") return bellmanFordAllPaths(graph, opts?.getWeight);
-	return dijkstraAllPaths(graph, opts?.getWeight);
-}
-function bellmanFordAllPaths(graph, getWeight) {
-	const results = [];
-	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
-		from: node.id,
-		getWeight,
-		algorithm: "bellman-ford"
-	}));
-	return results;
-}
-function dijkstraAllPaths(graph, getWeight) {
-	const results = [];
-	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
-		from: node.id,
-		getWeight
-	}));
-	return results;
-}
-function floydWarshallAllPaths(graph, getWeight) {
-	const idx = getIndex(graph);
-	const weight = getWeight ?? ((edge) => edge.weight ?? 1);
-	const nodeIds = graph.nodes.map((node) => node.id);
-	const nodeCount = nodeIds.length;
-	const indexOf = /* @__PURE__ */ new Map();
-	for (let i = 0; i < nodeCount; i++) indexOf.set(nodeIds[i], i);
-	const INF = Infinity;
-	const dist = Array.from({ length: nodeCount }, () => Array(nodeCount).fill(INF));
-	const prev = Array.from({ length: nodeCount }, () => Array.from({ length: nodeCount }, () => []));
-	for (let i = 0; i < nodeCount; i++) dist[i][i] = 0;
-	for (const edge of graph.edges) {
-		const source = indexOf.get(edge.sourceId);
-		const target = indexOf.get(edge.targetId);
-		const edgeWeight = weight(edge);
-		if (edgeWeight < dist[source][target]) {
-			dist[source][target] = edgeWeight;
-			prev[source][target] = [{
-				from: source,
-				edge
-			}];
-		} else if (edgeWeight === dist[source][target] && edgeWeight < INF) prev[source][target].push({
-			from: source,
-			edge
-		});
-		if (getEdgeMode(graph, edge) !== "directed") {
-			if (edgeWeight < dist[target][source]) {
-				dist[target][source] = edgeWeight;
-				prev[target][source] = [{
-					from: target,
-					edge
-				}];
-			} else if (edgeWeight === dist[target][source] && edgeWeight < INF) prev[target][source].push({
-				from: target,
-				edge
-			});
-		}
-	}
-	for (let k = 0; k < nodeCount; k++) for (let i = 0; i < nodeCount; i++) for (let j = 0; j < nodeCount; j++) {
-		if (dist[i][k] === INF || dist[k][j] === INF) continue;
-		const nextDistance = dist[i][k] + dist[k][j];
-		if (nextDistance < dist[i][j]) {
-			dist[i][j] = nextDistance;
-			prev[i][j] = prev[k][j].map((entry) => ({ ...entry }));
-		} else if (nextDistance === dist[i][j] && nextDistance < INF) {
-			for (const entry of prev[k][j]) if (!prev[i][j].some((existing) => existing.edge.id === entry.edge.id)) prev[i][j].push({ ...entry });
-		}
-	}
-	const results = [];
-	for (let i = 0; i < nodeCount; i++) {
-		const sourceNi = idx.nodeById.get(nodeIds[i]);
-		if (sourceNi === void 0) continue;
-		const sourceNode = graph.nodes[sourceNi];
-		for (let j = 0; j < nodeCount; j++) {
-			if (i === j || dist[i][j] === INF) continue;
-			results.push(...fwReconstruct(graph, prev, nodeIds, sourceNode, i, j));
-		}
-	}
-	return results;
-}
-function fwReconstruct(graph, prev, nodeIds, sourceNode, sourceIdx, targetIdx) {
-	if (sourceIdx === targetIdx) return [{
-		source: sourceNode,
-		steps: []
-	}];
-	const predecessors = prev[sourceIdx][targetIdx];
-	if (predecessors.length === 0) return [];
-	const targetNi = getIndex(graph).nodeById.get(nodeIds[targetIdx]);
-	if (targetNi === void 0) return [];
-	const targetNode = graph.nodes[targetNi];
-	const results = [];
-	for (const { from, edge } of predecessors) {
-		const prefixPaths = fwReconstruct(graph, prev, nodeIds, sourceNode, sourceIdx, from);
-		for (const prefix of prefixPaths) results.push({
-			source: sourceNode,
-			steps: [...prefix.steps, {
-				edge,
-				node: targetNode
-			}]
-		});
-	}
-	return results;
-}
-function getAStarPath(graph, opts) {
-	const idx = getIndex(graph);
-	const { from: sourceId, to: targetId, heuristic } = opts;
-	const getWeight = opts.getWeight ?? ((edge) => edge.weight ?? 1);
-	const sourceNi = idx.nodeById.get(sourceId);
-	if (sourceNi === void 0) return void 0;
-	if (!idx.nodeById.has(targetId)) return void 0;
-	if (sourceId === targetId) return {
-		source: graph.nodes[sourceNi],
-		steps: []
-	};
-	const gScore = /* @__PURE__ */ new Map();
-	const cameFrom = /* @__PURE__ */ new Map();
-	const closedSet = /* @__PURE__ */ new Set();
-	const openSet = new MinPriorityQueue((a, b) => a.f - b.f);
-	gScore.set(sourceId, 0);
-	openSet.push({
-		id: sourceId,
-		f: heuristic(sourceId)
-	});
-	while (openSet.size > 0) {
-		const { id: currentId } = openSet.pop();
-		if (closedSet.has(currentId)) continue;
-		if (currentId === targetId) {
-			const steps = [];
-			let current = targetId;
-			while (current !== sourceId) {
-				const previous = cameFrom.get(current);
-				const ni = idx.nodeById.get(current);
-				steps.unshift({
-					edge: previous.edge,
-					node: graph.nodes[ni]
-				});
-				current = previous.from;
-			}
-			return {
-				source: graph.nodes[sourceNi],
-				steps
-			};
-		}
-		closedSet.add(currentId);
-		for (const { neighborId, edge } of getNeighborEdges(graph, currentId)) {
-			if (closedSet.has(neighborId)) continue;
-			const tentativeScore = (gScore.get(currentId) ?? Infinity) + getWeight(edge);
-			if (tentativeScore < (gScore.get(neighborId) ?? Infinity)) {
-				cameFrom.set(neighborId, {
-					from: currentId,
-					edge
-				});
-				gScore.set(neighborId, tentativeScore);
-				openSet.push({
-					id: neighborId,
-					f: tentativeScore + heuristic(neighborId)
-				});
-			}
-		}
-	}
-}
-function joinPaths(headPath, tailPath) {
-	const headEnd = headPath.steps.length > 0 ? headPath.steps[headPath.steps.length - 1].node : headPath.source;
-	if (headEnd.id !== tailPath.source.id) throw new Error(`Paths cannot be joined: head path ends at "${headEnd.id}" but tail path starts at "${tailPath.source.id}"`);
-	return {
-		source: headPath.source,
-		steps: [...headPath.steps, ...tailPath.steps]
-	};
-}
-
-//#endregion
-//#region src/algorithms/traversal.ts
-function* bfs(graph, startId) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [startId];
-	visited.add(startId);
-	while (queue.length > 0) {
-		const id = queue.shift();
-		const ni = idx.nodeById.get(id);
-		if (ni === void 0) continue;
-		yield graph.nodes[ni];
-		for (const neighborId of getNeighborIds$1(graph, id)) if (!visited.has(neighborId)) {
-			visited.add(neighborId);
-			queue.push(neighborId);
-		}
-	}
-}
-function* dfs(graph, startId) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [startId];
-	while (stack.length > 0) {
-		const id = stack.pop();
-		if (visited.has(id)) continue;
-		visited.add(id);
-		const ni = idx.nodeById.get(id);
-		if (ni === void 0) continue;
-		yield graph.nodes[ni];
-		for (const neighborId of getNeighborIds$1(graph, id)) if (!visited.has(neighborId)) stack.push(neighborId);
-	}
-}
-function isAcyclic(graph) {
-	if (graph.mode !== "directed") return isAcyclicUndirected(graph);
-	const WHITE = 0;
-	const GRAY = 1;
-	const BLACK = 2;
-	const color = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes) color.set(node.id, WHITE);
-	const hasCycle = (id) => {
-		color.set(id, GRAY);
-		for (const neighborId of getSuccessorIds(graph, id)) {
-			const current = color.get(neighborId);
-			if (current === GRAY) return true;
-			if (current === WHITE && hasCycle(neighborId)) return true;
-		}
-		color.set(id, BLACK);
-		return false;
-	};
-	for (const node of graph.nodes) if (color.get(node.id) === WHITE && hasCycle(node.id)) return false;
-	return true;
-}
-function isAcyclicUndirected(graph) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const hasCycle = (id, parentId) => {
-		visited.add(id);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].targetId;
-			if (!visited.has(neighborId)) {
-				if (hasCycle(neighborId, id)) return true;
-			} else if (neighborId !== parentId) return true;
-		}
-		for (const eid of idx.inEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].sourceId;
-			if (!visited.has(neighborId)) {
-				if (hasCycle(neighborId, id)) return true;
-			} else if (neighborId !== parentId) return true;
-		}
-		return false;
-	};
-	for (const node of graph.nodes) if (!visited.has(node.id) && hasCycle(node.id, null)) return false;
-	return true;
-}
-function getConnectedComponents(graph) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const components = [];
-	for (const node of graph.nodes) {
-		if (visited.has(node.id)) continue;
-		const component = [];
-		const queue = [node.id];
-		visited.add(node.id);
-		while (queue.length > 0) {
-			const id = queue.shift();
-			const ni = idx.nodeById.get(id);
-			if (ni !== void 0) component.push(graph.nodes[ni]);
-			for (const eid of idx.outEdges.get(id) ?? []) {
-				const ai = idx.edgeById.get(eid);
-				if (ai === void 0) continue;
-				const neighborId = graph.edges[ai].targetId;
-				if (!visited.has(neighborId)) {
-					visited.add(neighborId);
-					queue.push(neighborId);
-				}
-			}
-			for (const eid of idx.inEdges.get(id) ?? []) {
-				const ai = idx.edgeById.get(eid);
-				if (ai === void 0) continue;
-				const neighborId = graph.edges[ai].sourceId;
-				if (!visited.has(neighborId)) {
-					visited.add(neighborId);
-					queue.push(neighborId);
-				}
-			}
-		}
-		components.push(component);
-	}
-	return components;
-}
-function getTopologicalSort(graph) {
-	const idx = getIndex(graph);
-	const inDegree = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes) inDegree.set(node.id, 0);
-	for (const edge of graph.edges) inDegree.set(edge.targetId, (inDegree.get(edge.targetId) ?? 0) + 1);
-	const queue = [];
-	for (const [id, degree] of inDegree) if (degree === 0) queue.push(id);
-	const result = [];
-	while (queue.length > 0) {
-		const id = queue.shift();
-		const ni = idx.nodeById.get(id);
-		if (ni !== void 0) result.push(graph.nodes[ni]);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const targetId = graph.edges[ai].targetId;
-			const nextDegree = (inDegree.get(targetId) ?? 1) - 1;
-			inDegree.set(targetId, nextDegree);
-			if (nextDegree === 0) queue.push(targetId);
-		}
-	}
-	if (result.length !== graph.nodes.length) return null;
-	return result;
-}
-function hasPath(graph, sourceId, targetId) {
-	return getShortestPaths(graph, {
-		from: sourceId,
-		to: targetId
-	}).length > 0;
-}
-function isConnected(graph) {
-	if (graph.nodes.length === 0) return true;
-	return getConnectedComponents(graph).length <= 1;
-}
-function isTree(graph) {
-	return isConnected(graph) && isAcyclic(graph);
-}
-
-//#endregion
-//#region src/algorithms/ordering.ts
-function getPreorder(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	const startNi = idx.nodeById.get(startId);
-	if (startNi === void 0) return [];
-	const visited = new Set([startId]);
-	const result = [graph.nodes[startNi]];
-	const stack = [startId];
-	while (stack.length > 0) {
-		const top = stack[stack.length - 1];
-		const next = getNeighborIds$1(graph, top).find((id) => !visited.has(id));
-		if (next === void 0) {
-			stack.pop();
-			continue;
-		}
-		visited.add(next);
-		stack.push(next);
-		const ni = idx.nodeById.get(next);
-		if (ni !== void 0) result.push(graph.nodes[ni]);
-	}
-	return result;
-}
-function getPostorder(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	if (idx.nodeById.get(startId) === void 0) return [];
-	const visited = new Set([startId]);
-	const result = [];
-	const stack = [startId];
-	while (stack.length > 0) {
-		const top = stack[stack.length - 1];
-		const next = getNeighborIds$1(graph, top).find((id) => !visited.has(id));
-		if (next === void 0) {
-			stack.pop();
-			const ni = idx.nodeById.get(top);
-			if (ni !== void 0) result.push(graph.nodes[ni]);
-			continue;
-		}
-		visited.add(next);
-		stack.push(next);
-	}
-	return result;
-}
-function getPreorders(graph, opts) {
-	return [...genPreorders(graph, opts)];
-}
-function getPostorders(graph, opts) {
-	return [...genPostorders(graph, opts)];
-}
-function* genPreorders(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	const startNi = idx.nodeById.get(startId);
-	const startNode = startNi !== void 0 ? graph.nodes[startNi] : void 0;
-	if (!startNode) return;
-	const queue = [{
-		visited: new Set([startId]),
-		preorder: [startNode],
-		dfsStack: [startId]
-	}];
-	while (queue.length > 0) {
-		const frame = queue.pop();
-		const { visited, dfsStack } = frame;
-		let { preorder } = frame;
-		let branched = false;
-		while (dfsStack.length > 0) {
-			const top = dfsStack[dfsStack.length - 1];
-			const unvisited = getNeighborIds$1(graph, top).filter((id) => !visited.has(id));
-			if (unvisited.length === 0) {
-				dfsStack.pop();
-				continue;
-			}
-			for (const nextId of unvisited) {
-				const ni = idx.nodeById.get(nextId);
-				if (ni === void 0) continue;
-				const newVisited = new Set(visited);
-				newVisited.add(nextId);
-				queue.push({
-					visited: newVisited,
-					preorder: [...preorder, graph.nodes[ni]],
-					dfsStack: [...dfsStack, nextId]
-				});
-			}
-			branched = true;
-			break;
-		}
-		if (!branched) yield preorder;
-	}
-}
-function* genPostorders(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	if (idx.nodeById.get(startId) === void 0) return;
-	const queue = [{
-		visited: new Set([startId]),
-		postorder: [],
-		dfsStack: [startId]
-	}];
-	while (queue.length > 0) {
-		const frame = queue.pop();
-		const { visited, dfsStack } = frame;
-		let { postorder } = frame;
-		let branched = false;
-		while (dfsStack.length > 0) {
-			const top = dfsStack[dfsStack.length - 1];
-			const unvisited = getNeighborIds$1(graph, top).filter((id) => !visited.has(id));
-			if (unvisited.length === 0) {
-				dfsStack.pop();
-				const ni = idx.nodeById.get(top);
-				if (ni !== void 0) postorder = [...postorder, graph.nodes[ni]];
-				continue;
-			}
-			for (const nextId of unvisited) {
-				if (idx.nodeById.get(nextId) === void 0) continue;
-				const newVisited = new Set(visited);
-				newVisited.add(nextId);
-				queue.push({
-					visited: newVisited,
-					postorder: [...postorder],
-					dfsStack: [...dfsStack, nextId]
-				});
-			}
-			branched = true;
-			break;
-		}
-		if (!branched) yield postorder;
-	}
-}
-
-//#endregion
-//#region src/algorithms/spanning-tree.ts
-function getMinimumSpanningTree(graph, opts) {
-	const algorithm = opts?.algorithm ?? "prim";
-	const getWeight = opts?.getWeight ?? ((edge) => edge.weight ?? 1);
-	const mstEdges = algorithm === "kruskal" ? kruskalMST(graph, getWeight) : primMST(graph, getWeight);
-	return createGraph({
-		id: graph.id,
-		mode: graph.mode,
-		initialNodeId: graph.initialNodeId ?? void 0,
-		nodes: graph.nodes.map((node) => ({
-			id: node.id,
-			parentId: node.parentId ?? void 0,
-			initialNodeId: node.initialNodeId ?? void 0,
-			label: node.label,
-			data: node.data
-		})),
-		edges: mstEdges.map((edge) => ({
-			id: edge.id,
-			sourceId: edge.sourceId,
-			targetId: edge.targetId,
-			label: edge.label,
-			data: edge.data,
-			...edge.weight !== void 0 && { weight: edge.weight }
-		}))
-	});
-}
-function primMST(graph, getWeight) {
-	if (graph.nodes.length === 0) return [];
-	const idx = getIndex(graph);
-	const inMST = /* @__PURE__ */ new Set();
-	const mstEdges = [];
-	const candidates = new MinPriorityQueue((a, b) => a.weight - b.weight);
-	function addEdgesOf(nodeId) {
-		for (const eid of idx.outEdges.get(nodeId) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const edge = graph.edges[ai];
-			if (!inMST.has(edge.targetId)) candidates.push({
-				weight: getWeight(edge),
-				edge
-			});
-		}
-		if (graph.mode !== "directed") for (const eid of idx.inEdges.get(nodeId) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const edge = graph.edges[ai];
-			if (!inMST.has(edge.sourceId)) candidates.push({
-				weight: getWeight(edge),
-				edge
-			});
-		}
-	}
-	const startId = graph.nodes[0].id;
-	inMST.add(startId);
-	addEdgesOf(startId);
-	while (candidates.size > 0 && inMST.size < graph.nodes.length) {
-		const { edge } = candidates.pop();
-		const targetId = graph.mode !== "directed" && inMST.has(edge.targetId) ? edge.sourceId : edge.targetId;
-		if (inMST.has(targetId)) continue;
-		inMST.add(targetId);
-		mstEdges.push(edge);
-		addEdgesOf(targetId);
-	}
-	return mstEdges;
-}
-function kruskalMST(graph, getWeight) {
-	const sorted = [...graph.edges].sort((a, b) => getWeight(a) - getWeight(b));
-	const parent = /* @__PURE__ */ new Map();
-	const rank = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes) {
-		parent.set(node.id, node.id);
-		rank.set(node.id, 0);
-	}
-	function find(id) {
-		if (parent.get(id) !== id) parent.set(id, find(parent.get(id)));
-		return parent.get(id);
-	}
-	function union(a, b) {
-		const rootA = find(a);
-		const rootB = find(b);
-		if (rootA === rootB) return false;
-		if (rank.get(rootA) < rank.get(rootB)) parent.set(rootA, rootB);
-		else if (rank.get(rootA) > rank.get(rootB)) parent.set(rootB, rootA);
-		else {
-			parent.set(rootB, rootA);
-			rank.set(rootA, rank.get(rootA) + 1);
-		}
-		return true;
-	}
-	const mstEdges = [];
-	for (const edge of sorted) if (union(edge.sourceId, edge.targetId)) mstEdges.push(edge);
-	return mstEdges;
-}
-
-//#endregion
-//#region src/algorithms/centrality.ts
-function getNodeIds(graph) {
-	return graph.nodes.map((node) => node.id);
-}
-function getNeighborIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].targetId);
-	}
-	if (graph.mode !== "directed") for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].sourceId);
-	}
-	return neighbors;
-}
-function getIncomingIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	const incoming = [];
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].sourceId);
-	}
-	if (graph.mode !== "directed") for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].targetId);
-	}
-	return incoming;
-}
-function createEmptyScoreMap(graph) {
-	return Object.fromEntries(graph.nodes.map((node) => [node.id, 0]));
-}
-function normalizeVector(scores) {
-	const magnitude = Math.sqrt(Object.values(scores).reduce((sum, value) => sum + value * value, 0));
-	if (magnitude === 0) return scores;
-	for (const key of Object.keys(scores)) scores[key] /= magnitude;
-	return scores;
-}
-function maxDiff(previous, next) {
-	let diff = 0;
-	for (const key of Object.keys(next)) diff = Math.max(diff, Math.abs((previous[key] ?? 0) - next[key]));
-	return diff;
-}
-function getReachableDistances(graph, startId) {
-	const distances = /* @__PURE__ */ new Map();
-	const queue = [startId];
-	distances.set(startId, 0);
-	while (queue.length > 0) {
-		const currentId = queue.shift();
-		const currentDistance = distances.get(currentId);
-		for (const neighborId of getNeighborIds(graph, currentId)) {
-			if (distances.has(neighborId)) continue;
-			distances.set(neighborId, currentDistance + 1);
-			queue.push(neighborId);
-		}
-	}
-	return distances;
-}
-/**
-* Returns degree centrality scores for all nodes.
-*
-* Degree centrality is the node degree normalized by `n - 1`.
-*
-* @example
-* ```ts
-* const scores = getDegreeCentrality(graph);
-* console.log(scores.a); // 0.5
-* ```
-*/
-function getDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
-	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) {
-		const outDegree = idx.outEdges.get(node.id)?.length ?? 0;
-		const inDegree = idx.inEdges.get(node.id)?.length ?? 0;
-		const degree = graph.mode !== "directed" ? new Set([...idx.outEdges.get(node.id) ?? [], ...idx.inEdges.get(node.id) ?? []]).size : outDegree + inDegree;
-		scores[node.id] = degree * scale;
-	}
-	return scores;
-}
-/**
-* Returns in-degree centrality scores for all nodes.
-*
-* In-degree centrality is the incoming degree normalized by `n - 1`.
-*/
-function getInDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
-	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) scores[node.id] = (idx.inEdges.get(node.id)?.length ?? 0) * scale;
-	return scores;
-}
-/**
-* Returns out-degree centrality scores for all nodes.
-*
-* Out-degree centrality is the outgoing degree normalized by `n - 1`.
-*/
-function getOutDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
-	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) scores[node.id] = (idx.outEdges.get(node.id)?.length ?? 0) * scale;
-	return scores;
-}
-/**
-* Returns closeness centrality scores for all nodes.
-*
-* Distances are computed over unweighted shortest paths using the graph's
-* existing directed or undirected edge semantics.
-*/
-function getClosenessCentrality(graph) {
-	const scores = createEmptyScoreMap(graph);
-	const order = graph.nodes.length;
-	for (const node of graph.nodes) {
-		const distances = getReachableDistances(graph, node.id);
-		distances.delete(node.id);
-		if (distances.size === 0) continue;
-		const totalDistance = [...distances.values()].reduce((sum, distance) => sum + distance, 0);
-		if (totalDistance === 0) continue;
-		const reachable = distances.size;
-		const closeness = reachable / totalDistance;
-		scores[node.id] = order > 1 ? closeness * (reachable / (order - 1)) : closeness;
-	}
-	return scores;
-}
-/**
-* Returns betweenness centrality scores for all nodes.
-*
-* Uses Brandes' algorithm over unweighted shortest paths and returns
-* normalized scores.
-*/
-function getBetweennessCentrality(graph) {
-	const scores = createEmptyScoreMap(graph);
-	for (const source of graph.nodes) {
-		const stack = [];
-		const predecessors = /* @__PURE__ */ new Map();
-		const sigma = /* @__PURE__ */ new Map();
-		const distance = /* @__PURE__ */ new Map();
-		const queue = [source.id];
-		for (const node of graph.nodes) {
-			predecessors.set(node.id, []);
-			sigma.set(node.id, 0);
-			distance.set(node.id, -1);
-		}
-		sigma.set(source.id, 1);
-		distance.set(source.id, 0);
-		while (queue.length > 0) {
-			const currentId = queue.shift();
-			stack.push(currentId);
-			for (const neighborId of getNeighborIds(graph, currentId)) {
-				if (distance.get(neighborId) === -1) {
-					queue.push(neighborId);
-					distance.set(neighborId, distance.get(currentId) + 1);
-				}
-				if (distance.get(neighborId) === distance.get(currentId) + 1) {
-					sigma.set(neighborId, sigma.get(neighborId) + sigma.get(currentId));
-					predecessors.get(neighborId).push(currentId);
-				}
-			}
-		}
-		const delta = /* @__PURE__ */ new Map();
-		for (const node of graph.nodes) delta.set(node.id, 0);
-		while (stack.length > 0) {
-			const nodeId = stack.pop();
-			const sigmaNode = sigma.get(nodeId);
-			if (sigmaNode === 0) continue;
-			for (const predecessorId of predecessors.get(nodeId)) {
-				const contribution = sigma.get(predecessorId) / sigmaNode * (1 + delta.get(nodeId));
-				delta.set(predecessorId, delta.get(predecessorId) + contribution);
-			}
-			if (nodeId !== source.id) scores[nodeId] += delta.get(nodeId);
-		}
-	}
-	const order = graph.nodes.length;
-	if (order <= 2) return scores;
-	const scale = graph.mode !== "directed" ? 1 / ((order - 1) * (order - 2) / 2) : 1 / ((order - 1) * (order - 2));
-	for (const nodeId of Object.keys(scores)) {
-		if (graph.mode !== "directed") scores[nodeId] /= 2;
-		scores[nodeId] *= scale;
-	}
-	return scores;
-}
-/**
-* Returns PageRank scores for all nodes.
-*
-* Uses power iteration with damping factor `alpha`.
-*/
-function getPageRank(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {};
-	const alpha = options?.alpha ?? .85;
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1 / nodeIds.length]));
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextScores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, (1 - alpha) / nodeIds.length]));
-		let danglingMass = 0;
-		for (const nodeId of nodeIds) {
-			const neighbors = getNeighborIds(graph, nodeId);
-			if (neighbors.length === 0) {
-				danglingMass += scores[nodeId];
-				continue;
-			}
-			const share = scores[nodeId] / neighbors.length;
-			for (const neighborId of neighbors) nextScores[neighborId] += alpha * share;
-		}
-		if (danglingMass > 0) {
-			const share = alpha * danglingMass / nodeIds.length;
-			for (const nodeId of nodeIds) nextScores[nodeId] += share;
-		}
-		if (maxDiff(scores, nextScores) <= tolerance) {
-			scores = nextScores;
-			break;
-		}
-		scores = nextScores;
-	}
-	const total = Object.values(scores).reduce((sum, value) => sum + value, 0);
-	if (total !== 0) for (const nodeId of nodeIds) scores[nodeId] /= total;
-	return scores;
-}
-/**
-* Returns HITS hub and authority scores for all nodes.
-*
-* Uses power iteration and L2 normalization per iteration.
-*/
-function getHITS(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {
-		hubs: {},
-		authorities: {}
-	};
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let hubs = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
-	let authorities = createEmptyScoreMap(graph);
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextAuthorities = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextAuthorities[nodeId] += hubs[predecessorId];
-		normalizeVector(nextAuthorities);
-		const nextHubs = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const neighborId of getNeighborIds(graph, nodeId)) nextHubs[nodeId] += nextAuthorities[neighborId];
-		normalizeVector(nextHubs);
-		const hubDiff = maxDiff(hubs, nextHubs);
-		const authorityDiff = maxDiff(authorities, nextAuthorities);
-		hubs = nextHubs;
-		authorities = nextAuthorities;
-		if (Math.max(hubDiff, authorityDiff) <= tolerance) break;
-	}
-	return {
-		hubs,
-		authorities
-	};
-}
-/**
-* Returns eigenvector centrality scores for all nodes.
-*
-* Uses power iteration over incoming neighbors for directed graphs and
-* undirected adjacency for undirected graphs.
-*/
-function getEigenvectorCentrality(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {};
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
-	normalizeVector(scores);
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextScores = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextScores[nodeId] += scores[predecessorId];
-		normalizeVector(nextScores);
-		const diff = maxDiff(scores, nextScores);
-		scores = nextScores;
-		if (diff <= tolerance) break;
-	}
-	return scores;
-}
-
-//#endregion
-//#region src/algorithms/community.ts
-function getUndirectedNeighbors$1(graph, nodeId) {
-	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].targetId,
-			edgeId
-		});
-	}
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].sourceId,
-			edgeId
-		});
-	}
-	return neighbors;
-}
-function getUndirectedConnectedComponents(graph) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const communities = [];
-	for (const node of graph.nodes) {
-		if (visited.has(node.id)) continue;
-		const community = [];
-		const queue = [node.id];
-		visited.add(node.id);
-		while (queue.length > 0) {
-			const currentId = queue.shift();
-			const nodeIndex = idx.nodeById.get(currentId);
-			if (nodeIndex !== void 0) community.push(graph.nodes[nodeIndex]);
-			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
-				if (visited.has(neighbor.nodeId)) continue;
-				visited.add(neighbor.nodeId);
-				queue.push(neighbor.nodeId);
-			}
-		}
-		communities.push(community.sort((a, b) => a.id.localeCompare(b.id)));
-	}
-	return communities.sort((a, b) => a[0].id.localeCompare(b[0].id));
-}
-function getNodeMap(graph) {
-	return new Map(graph.nodes.map((node) => [node.id, node]));
-}
-function normalizeCommunities(graph, labels) {
-	const nodeMap = getNodeMap(graph);
-	const grouped = /* @__PURE__ */ new Map();
-	for (const [nodeId, label] of Object.entries(labels)) {
-		if (!grouped.has(label)) grouped.set(label, []);
-		const node = nodeMap.get(nodeId);
-		if (node) grouped.get(label).push(node);
-	}
-	return [...grouped.values()].map((community) => community.sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
-}
-function getEdgeBetweenness(graph) {
-	const scores = Object.fromEntries(graph.edges.map((edge) => [edge.id, 0]));
-	for (const source of graph.nodes) {
-		const stack = [];
-		const predecessors = /* @__PURE__ */ new Map();
-		const sigma = /* @__PURE__ */ new Map();
-		const distance = /* @__PURE__ */ new Map();
-		const queue = [source.id];
-		for (const node of graph.nodes) {
-			predecessors.set(node.id, []);
-			sigma.set(node.id, 0);
-			distance.set(node.id, -1);
-		}
-		sigma.set(source.id, 1);
-		distance.set(source.id, 0);
-		while (queue.length > 0) {
-			const currentId = queue.shift();
-			stack.push(currentId);
-			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
-				if (distance.get(neighbor.nodeId) === -1) {
-					queue.push(neighbor.nodeId);
-					distance.set(neighbor.nodeId, distance.get(currentId) + 1);
-				}
-				if (distance.get(neighbor.nodeId) === distance.get(currentId) + 1) {
-					sigma.set(neighbor.nodeId, sigma.get(neighbor.nodeId) + sigma.get(currentId));
-					predecessors.get(neighbor.nodeId).push({
-						nodeId: currentId,
-						edgeId: neighbor.edgeId
-					});
-				}
-			}
-		}
-		const delta = /* @__PURE__ */ new Map();
-		for (const node of graph.nodes) delta.set(node.id, 0);
-		while (stack.length > 0) {
-			const nodeId = stack.pop();
-			const sigmaNode = sigma.get(nodeId);
-			if (sigmaNode === 0) continue;
-			for (const predecessor of predecessors.get(nodeId)) {
-				const contribution = sigma.get(predecessor.nodeId) / sigmaNode * (1 + delta.get(nodeId));
-				scores[predecessor.edgeId] += contribution;
-				delta.set(predecessor.nodeId, delta.get(predecessor.nodeId) + contribution);
-			}
-		}
-	}
-	for (const edgeId of Object.keys(scores)) scores[edgeId] /= 2;
-	return scores;
-}
-function cloneWithEdges(graph, edges) {
-	return {
-		...graph,
-		nodes: [...graph.nodes],
-		edges
-	};
-}
-function toCommunityIds(communities) {
-	return communities.map((community) => new Set(community.map((node) => node.id)));
-}
-/**
-* Returns label-propagation communities for the graph.
-*
-* The implementation is deterministic: ties are broken by lexicographic label
-* order so test results remain stable.
-*/
-function getLabelPropagationCommunities(graph, options) {
-	if (graph.nodes.length === 0) return [];
-	const maxIterations = options?.maxIterations ?? 50;
-	let labels = Object.fromEntries(graph.nodes.map((node) => [node.id, node.id]));
-	const nodeIds = graph.nodes.map((node) => node.id).sort();
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextLabels = { ...labels };
-		let changed = false;
-		for (const nodeId of nodeIds) {
-			const counts = /* @__PURE__ */ new Map();
-			for (const neighbor of getUndirectedNeighbors$1(graph, nodeId)) {
-				const label = labels[neighbor.nodeId];
-				counts.set(label, (counts.get(label) ?? 0) + 1);
-			}
-			if (counts.size === 0) continue;
-			const bestLabel = [...counts.entries()].sort((a, b) => {
-				if (b[1] !== a[1]) return b[1] - a[1];
-				return a[0].localeCompare(b[0]);
-			})[0][0];
-			if (bestLabel !== labels[nodeId]) {
-				nextLabels[nodeId] = bestLabel;
-				changed = true;
-			}
-		}
-		labels = nextLabels;
-		if (!changed) break;
-	}
-	return normalizeCommunities(graph, labels);
-}
-/**
-* Lazily yields Girvan-Newman community splits as edge betweenness removes
-* bridge-like edges from the graph.
-*/
-function* genGirvanNewmanCommunities(graph, options) {
-	if (graph.nodes.length === 0 || graph.edges.length === 0) return;
-	const maxLevels = options?.maxLevels ?? Number.POSITIVE_INFINITY;
-	let yielded = 0;
-	let edges = [...graph.edges];
-	let previousCount = getUndirectedConnectedComponents(graph).length;
-	while (edges.length > 0 && yielded < maxLevels) {
-		const betweenness = getEdgeBetweenness(cloneWithEdges(graph, edges));
-		const maxScore = Math.max(...Object.values(betweenness));
-		edges = edges.filter((edge) => betweenness[edge.id] < maxScore - 1e-12);
-		const components = getUndirectedConnectedComponents(cloneWithEdges(graph, edges));
-		if (components.length > previousCount) {
-			yield components;
-			yielded++;
-			previousCount = components.length;
-		}
-	}
-}
-/**
-* Returns the requested Girvan-Newman split level eagerly.
-*
-* `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
-*/
-function getGirvanNewmanCommunities(graph, options) {
-	if (graph.nodes.length === 0) return [];
-	const targetLevel = options?.level ?? 1;
-	if (targetLevel <= 0) return getUndirectedConnectedComponents(graph);
-	let last = getUndirectedConnectedComponents(graph);
-	let level = 0;
-	for (const partition of genGirvanNewmanCommunities(graph, { maxLevels: targetLevel })) {
-		last = partition;
-		level++;
-		if (level >= targetLevel) break;
-	}
-	return last;
-}
-/**
-* Returns the modularity score for a partition of communities.
-*
-* Community algorithms in this module treat the graph as undirected.
-*/
-function getModularity(graph, communities) {
-	if (graph.edges.length === 0 || communities.length === 0) return 0;
-	const nodeIds = graph.nodes.map((node) => node.id);
-	const adjacency = /* @__PURE__ */ new Map();
-	const degree = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 0]));
-	for (const nodeId of nodeIds) adjacency.set(nodeId, /* @__PURE__ */ new Map());
-	for (const edge of graph.edges) {
-		adjacency.get(edge.sourceId).set(edge.targetId, (adjacency.get(edge.sourceId).get(edge.targetId) ?? 0) + 1);
-		adjacency.get(edge.targetId).set(edge.sourceId, (adjacency.get(edge.targetId).get(edge.sourceId) ?? 0) + 1);
-		degree[edge.sourceId]++;
-		degree[edge.targetId]++;
-	}
-	const m2 = graph.edges.length * 2;
-	let modularity = 0;
-	for (const community of toCommunityIds(communities)) {
-		const ids = [...community];
-		for (const i of ids) for (const j of ids) {
-			const aij = adjacency.get(i).get(j) ?? 0;
-			modularity += aij - degree[i] * degree[j] / m2;
-		}
-	}
-	return modularity / m2;
-}
-/**
-* Returns communities found by greedily merging partitions that improve
-* modularity the most at each step.
-*/
-function getGreedyModularityCommunities(graph) {
-	if (graph.nodes.length === 0) return [];
-	let communities = graph.nodes.map((node) => [node]);
-	let currentScore = getModularity(graph, communities);
-	while (communities.length > 1) {
-		let bestScore = currentScore;
-		let bestMerge;
-		for (let i = 0; i < communities.length; i++) for (let j = i + 1; j < communities.length; j++) {
-			const merged = communities.filter((_, index) => index !== i && index !== j);
-			merged.push([...communities[i], ...communities[j]].sort((a, b) => a.id.localeCompare(b.id)));
-			const score = getModularity(graph, merged);
-			if (score > bestScore + 1e-12) {
-				bestScore = score;
-				bestMerge = merged;
-			}
-		}
-		if (!bestMerge) break;
-		communities = bestMerge.sort((a, b) => a[0].id.localeCompare(b[0].id));
-		currentScore = bestScore;
-	}
-	return communities;
-}
-
-//#endregion
-//#region src/algorithms/connectivity.ts
-function getUndirectedNeighbors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].targetId,
-			edgeId
-		});
-	}
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].sourceId,
-			edgeId
-		});
-	}
-	return neighbors;
-}
-function popComponentUntil(state, stopEdgeId) {
-	const nodeIds = /* @__PURE__ */ new Set();
-	while (state.edgeStack.length > 0) {
-		const edgeId = state.edgeStack.pop();
-		const edge = state.edgeById.get(edgeId);
-		if (edge) {
-			nodeIds.add(edge.sourceId);
-			nodeIds.add(edge.targetId);
-		}
-		if (edgeId === stopEdgeId) break;
-	}
-	if (nodeIds.size > 0) state.components.push(nodeIds);
-}
-function finalizeRemainingComponent(state) {
-	if (state.edgeStack.length === 0) return;
-	const nodeIds = /* @__PURE__ */ new Set();
-	while (state.edgeStack.length > 0) {
-		const edge = state.edgeById.get(state.edgeStack.pop());
-		if (edge) {
-			nodeIds.add(edge.sourceId);
-			nodeIds.add(edge.targetId);
-		}
-	}
-	if (nodeIds.size > 0) state.components.push(nodeIds);
-}
-function traverseConnectivity(graph, nodeId, parentEdgeId, state) {
-	state.time += 1;
-	state.disc.set(nodeId, state.time);
-	state.low.set(nodeId, state.time);
-	let childCount = 0;
-	for (const neighbor of getUndirectedNeighbors(graph, nodeId)) {
-		if (neighbor.edgeId === parentEdgeId) continue;
-		if (!state.disc.has(neighbor.nodeId)) {
-			childCount += 1;
-			state.edgeStack.push(neighbor.edgeId);
-			traverseConnectivity(graph, neighbor.nodeId, neighbor.edgeId, state);
-			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.low.get(neighbor.nodeId)));
-			if (state.low.get(neighbor.nodeId) > state.disc.get(nodeId)) state.bridges.add(neighbor.edgeId);
-			if (parentEdgeId !== null && state.low.get(neighbor.nodeId) >= state.disc.get(nodeId)) {
-				state.articulationPoints.add(nodeId);
-				popComponentUntil(state, neighbor.edgeId);
-			}
-		} else if (state.disc.get(neighbor.nodeId) < state.disc.get(nodeId)) {
-			state.edgeStack.push(neighbor.edgeId);
-			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.disc.get(neighbor.nodeId)));
-		}
-	}
-	if (parentEdgeId === null && childCount > 1) state.articulationPoints.add(nodeId);
-}
-function analyzeConnectivity(graph) {
-	const state = {
-		time: 0,
-		disc: /* @__PURE__ */ new Map(),
-		low: /* @__PURE__ */ new Map(),
-		edgeStack: [],
-		bridges: /* @__PURE__ */ new Set(),
-		articulationPoints: /* @__PURE__ */ new Set(),
-		components: [],
-		nodeById: new Map(graph.nodes.map((node) => [node.id, node])),
-		edgeById: new Map(graph.edges.map((edge) => [edge.id, edge]))
-	};
-	for (const node of graph.nodes) {
-		if (state.disc.has(node.id)) continue;
-		traverseConnectivity(graph, node.id, null, state);
-		finalizeRemainingComponent(state);
-	}
-	return state;
-}
-/**
-* Returns bridge edges whose removal disconnects the graph.
-*
-* Connectivity algorithms in this module treat the graph as undirected.
-*/
-function getBridges(graph) {
-	if (graph.edges.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return [...state.bridges].map((edgeId) => state.edgeById.get(edgeId)).sort((a, b) => a.id.localeCompare(b.id));
-}
-/**
-* Returns articulation points (cut vertices) for the graph.
-*
-* Connectivity algorithms in this module treat the graph as undirected.
-*/
-function getArticulationPoints(graph) {
-	if (graph.nodes.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return [...state.articulationPoints].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id));
-}
-/**
-* Returns biconnected components as arrays of nodes.
-*
-* Articulation points may appear in multiple returned components.
-*/
-function getBiconnectedComponents(graph) {
-	if (graph.edges.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return state.components.map((component) => [...component].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
-}
-
-//#endregion
-//#region src/algorithms/isomorphism.ts
-function getDegreeSignature(graph, nodeId) {
-	const idx = getIndex(graph);
-	const outDegree = idx.outEdges.get(nodeId)?.length ?? 0;
-	const inDegree = idx.inEdges.get(nodeId)?.length ?? 0;
-	if (graph.mode !== "directed") return `u:${new Set([...idx.outEdges.get(nodeId) ?? [], ...idx.inEdges.get(nodeId) ?? []]).size}`;
-	return `d:${inDegree}:${outDegree}`;
-}
-function getEdgesBetween(graph, sourceId, targetId) {
-	if (graph.mode !== "directed") return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId || edge.sourceId === targetId && edge.targetId === sourceId);
-	return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId);
-}
-function edgesAreCompatible(edgesA, edgesB, edgeMatch) {
-	if (edgesA.length !== edgesB.length) return false;
-	if (!edgeMatch || edgesA.length === 0) return true;
-	const remaining = [...edgesB];
-	for (const edgeA of edgesA) {
-		const matchIndex = remaining.findIndex((edgeB) => edgeMatch(edgeA, edgeB));
-		if (matchIndex === -1) return false;
-		remaining.splice(matchIndex, 1);
-	}
-	return true;
-}
-/**
-* Returns whether two graphs are structurally isomorphic.
-*
-* Optional `nodeMatch` and `edgeMatch` predicates can refine the match using
-* node and edge payloads.
-*/
-function isIsomorphic(graphA, graphB, options) {
-	if (graphA.mode !== graphB.mode) return false;
-	if (graphA.nodes.length !== graphB.nodes.length) return false;
-	if (graphA.edges.length !== graphB.edges.length) return false;
-	const nodeMatch = options?.nodeMatch;
-	const edgeMatch = options?.edgeMatch;
-	const nodesA = [...graphA.nodes].sort((a, b) => {
-		const sigDiff = getDegreeSignature(graphA, b.id).localeCompare(getDegreeSignature(graphA, a.id));
-		if (sigDiff !== 0) return sigDiff;
-		return a.id.localeCompare(b.id);
-	});
-	const nodesB = [...graphB.nodes];
-	const signaturesA = nodesA.map((node) => getDegreeSignature(graphA, node.id)).sort();
-	const signaturesB = nodesB.map((node) => getDegreeSignature(graphB, node.id)).sort();
-	if (signaturesA.join("|") !== signaturesB.join("|")) return false;
-	const mapping = /* @__PURE__ */ new Map();
-	const usedB = /* @__PURE__ */ new Set();
-	const backtrack = (index) => {
-		if (index >= nodesA.length) return true;
-		const nodeA = nodesA[index];
-		const signatureA = getDegreeSignature(graphA, nodeA.id);
-		for (const nodeB of nodesB) {
-			if (usedB.has(nodeB.id)) continue;
-			if (getDegreeSignature(graphB, nodeB.id) !== signatureA) continue;
-			if (nodeMatch && !nodeMatch(nodeA, nodeB)) continue;
-			let compatible = true;
-			for (const [mappedAId, mappedBId] of mapping.entries()) {
-				if (!edgesAreCompatible(getEdgesBetween(graphA, nodeA.id, mappedAId), getEdgesBetween(graphB, nodeB.id, mappedBId), edgeMatch)) {
-					compatible = false;
-					break;
-				}
-				if (!edgesAreCompatible(getEdgesBetween(graphA, mappedAId, nodeA.id), getEdgesBetween(graphB, mappedBId, nodeB.id), edgeMatch)) {
-					compatible = false;
-					break;
-				}
-			}
-			if (!compatible) continue;
-			mapping.set(nodeA.id, nodeB.id);
-			usedB.add(nodeB.id);
-			if (backtrack(index + 1)) return true;
-			mapping.delete(nodeA.id);
-			usedB.delete(nodeB.id);
-		}
-		return false;
-	};
-	return backtrack(0);
-}
-
-//#endregion
-export { createGraphPort as $, isAcyclic as A, getShortestPaths as B, getPreorder as C, getConnectedComponents as D, dfs as E, genSimplePaths as F, GraphInstance as G, getSimplePaths as H, getAStarPath as I, addNode as J, addEdge as K, getAllPairsShortestPaths as L, isTree as M, genCycles as N, getTopologicalSort as O, genShortestPaths as P, createGraphNode as Q, getCycles as R, getPostorders as S, bfs as T, getStronglyConnectedComponents as U, getSimplePath as V, joinPaths as W, createGraphEdge as X, createGraph as Y, createGraphFromTransition as Z, getPageRank as _, genGirvanNewmanCommunities as a, getNode as at, genPreorders as b, getLabelPropagationCommunities as c, updateEdge as ct, getClosenessCentrality as d, createVisualGraph as et, getDegreeCentrality as f, getOutDegreeCentrality as g, getInDegreeCentrality as h, getBridges as i, getEdge as it, isConnected as j, hasPath as k, getModularity as l, updateEntities as lt, getHITS as m, getArticulationPoints as n, deleteEntities as nt, getGirvanNewmanCommunities as o, hasEdge as ot, getEigenvectorCentrality as p, addEntities as q, getBiconnectedComponents as r, deleteNode as rt, getGreedyModularityCommunities as s, hasNode as st, isIsomorphic as t, deleteEdge as tt, getBetweennessCentrality as u, updateNode as ut, getMinimumSpanningTree as v, getPreorders as w, getPostorder as x, genPostorders as y, getShortestPath as z };