graphwise 1.1.1 → 1.2.0

package/dist/structures-CJ_S_7fs.cjs

@@ -1,138 +0,0 @@
-//#region src/structures/priority-queue.ts
-/**
-* Min-heap priority queue implementation using an array-based binary heap.
-* Lower priority values have higher precedence (extracted first).
-*/
-var PriorityQueue = class {
-	heap = [];
-	/**
-	* Returns the number of items in the queue.
-	*/
-	size() {
-		return this.heap.length;
-	}
-	/**
-	* Returns true if the queue is empty.
-	*/
-	isEmpty() {
-		return this.heap.length === 0;
-	}
-	/**
-	* Adds an item with the given priority to the queue.
-	*/
-	push(item, priority) {
-		const entry = {
-			item,
-			priority
-		};
-		this.heap.push(entry);
-		this.heapifyUp(this.heap.length - 1);
-	}
-	/**
-	* Removes and returns the highest precedence item (lowest priority value).
-	* Returns undefined if the queue is empty.
-	*/
-	pop() {
-		if (this.heap.length === 0) return;
-		const root = this.heap[0];
-		if (root === void 0) return;
-		const last = this.heap.pop();
-		if (last === void 0) return root;
-		if (this.heap.length > 0) {
-			this.heap[0] = last;
-			this.heapifyDown(0);
-		}
-		return root;
-	}
-	/**
-	* Returns the highest precedence item without removing it.
-	* Returns undefined if the queue is empty.
-	*/
-	peek() {
-		return this.heap[0];
-	}
-	/**
-	* Rebuilds the heap from the current array state.
-	* Useful when priorities have been modified externally (e.g., phase transitions).
-	*/
-	rebuild() {
-		const start = Math.floor(this.heap.length / 2) - 1;
-		for (let i = start; i >= 0; i--) this.heapifyDown(i);
-	}
-	/**
-	* Decreases the priority of an existing item in the queue.
-	* Returns true if the item was found and updated, false otherwise.
-	*
-	* @param item - The item to find
-	* @param newPriority - The new (lower) priority value
-	* @param equals - Function to compare items for equality
-	*/
-	decreaseKey(item, newPriority, equals) {
-		let foundIndex = -1;
-		for (let i = 0; i < this.heap.length; i++) {
-			const entry = this.heap[i];
-			if (entry !== void 0 && equals(entry.item, item)) {
-				foundIndex = i;
-				break;
-			}
-		}
-		if (foundIndex === -1) return false;
-		const entry = this.heap[foundIndex];
-		if (entry === void 0) return false;
-		if (newPriority >= entry.priority) return false;
-		entry.priority = newPriority;
-		this.heapifyUp(foundIndex);
-		return true;
-	}
-	/**
-	* Restores heap property by moving element up from given index.
-	*/
-	heapifyUp(index) {
-		let current = index;
-		while (current > 0) {
-			const parent = Math.floor((current - 1) / 2);
-			const currentEntry = this.heap[current];
-			const parentEntry = this.heap[parent];
-			if (currentEntry === void 0 || parentEntry === void 0) return;
-			if (currentEntry.priority >= parentEntry.priority) return;
-			this.heap[current] = parentEntry;
-			this.heap[parent] = currentEntry;
-			current = parent;
-		}
-	}
-	/**
-	* Restores heap property by moving element down from given index.
-	*/
-	heapifyDown(index) {
-		let current = index;
-		const length = this.heap.length;
-		while (current < length) {
-			const left = 2 * current + 1;
-			const right = 2 * current + 2;
-			let smallest = current;
-			const currentEntry = this.heap[current];
-			if (currentEntry === void 0) return;
-			const leftEntry = this.heap[left];
-			if (left < length && leftEntry !== void 0 && leftEntry.priority < currentEntry.priority) smallest = left;
-			const rightEntry = this.heap[right];
-			const currentSmallestEntry = this.heap[smallest];
-			if (right < length && rightEntry !== void 0 && currentSmallestEntry !== void 0 && rightEntry.priority < currentSmallestEntry.priority) smallest = right;
-			if (smallest === current) return;
-			const finalSmallestEntry = this.heap[smallest];
-			if (finalSmallestEntry !== void 0) {
-				this.heap[current] = finalSmallestEntry;
-				this.heap[smallest] = currentEntry;
-				current = smallest;
-			} else return;
-		}
-	}
-};
-//#endregion
-Object.defineProperty(exports, "PriorityQueue", {
-	enumerable: true,
-	get: function() {
-		return PriorityQueue;
-	}
-});
-
-//# sourceMappingURL=structures-CJ_S_7fs.cjs.map

package/dist/structures-CJ_S_7fs.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"structures-CJ_S_7fs.cjs","names":[],"sources":["../src/structures/priority-queue.ts"],"sourcesContent":["/**\n * Priority queue entry containing an item and its priority.\n */\nexport interface PriorityEntry<T> {\n\titem: T;\n\tpriority: number;\n}\n\n/**\n * Min-heap priority queue implementation using an array-based binary heap.\n * Lower priority values have higher precedence (extracted first).\n */\nexport class PriorityQueue<T> {\n\tprivate heap: PriorityEntry<T>[] = [];\n\n\t/**\n\t * Returns the number of items in the queue.\n\t */\n\tpublic size(): number {\n\t\treturn this.heap.length;\n\t}\n\n\t/**\n\t * Returns true if the queue is empty.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn this.heap.length === 0;\n\t}\n\n\t/**\n\t * Adds an item with the given priority to the queue.\n\t */\n\tpublic push(item: T, priority: number): void {\n\t\tconst entry: PriorityEntry<T> = { item, priority };\n\t\tthis.heap.push(entry);\n\t\tthis.heapifyUp(this.heap.length - 1);\n\t}\n\n\t/**\n\t * Removes and returns the highest precedence item (lowest priority value).\n\t * Returns undefined if the queue is empty.\n\t */\n\tpublic pop(): PriorityEntry<T> | undefined {\n\t\tif (this.heap.length === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst root = this.heap[0];\n\t\tif (root === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst last = this.heap.pop();\n\t\tif (last === undefined) {\n\t\t\treturn root;\n\t\t}\n\n\t\tif (this.heap.length > 0) {\n\t\t\tthis.heap[0] = last;\n\t\t\tthis.heapifyDown(0);\n\t\t}\n\n\t\treturn root;\n\t}\n\n\t/**\n\t * Returns the highest precedence item without removing it.\n\t * Returns undefined if the queue is empty.\n\t */\n\tpublic peek(): PriorityEntry<T> | undefined {\n\t\treturn this.heap[0];\n\t}\n\n\t/**\n\t * Rebuilds the heap from the current array state.\n\t * Useful when priorities have been modified externally (e.g., phase transitions).\n\t */\n\tpublic rebuild(): void {\n\t\t// Floyd's algorithm: heapify down from last non-leaf to root\n\t\tconst start = Math.floor(this.heap.length / 2) - 1;\n\t\tfor (let i = start; i >= 0; i--) {\n\t\t\tthis.heapifyDown(i);\n\t\t}\n\t}\n\n\t/**\n\t * Decreases the priority of an existing item in the queue.\n\t * Returns true if the item was found and updated, false otherwise.\n\t *\n\t * @param item - The item to find\n\t * @param newPriority - The new (lower) priority value\n\t * @param equals - Function to compare items for equality\n\t */\n\tpublic decreaseKey(\n\t\titem: T,\n\t\tnewPriority: number,\n\t\tequals: (a: T, b: T) => boolean,\n\t): boolean {\n\t\tlet foundIndex = -1;\n\n\t\tfor (let i = 0; i < this.heap.length; i++) {\n\t\t\tconst entry = this.heap[i];\n\t\t\tif (entry !== undefined && equals(entry.item, item)) {\n\t\t\t\tfoundIndex = i;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (foundIndex === -1) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst entry = this.heap[foundIndex];\n\t\tif (entry === undefined) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Only update if new priority is lower (higher precedence)\n\t\tif (newPriority >= entry.priority) {\n\t\t\treturn false;\n\t\t}\n\n\t\tentry.priority = newPriority;\n\t\tthis.heapifyUp(foundIndex);\n\t\treturn true;\n\t}\n\n\t/**\n\t * Restores heap property by moving element up from given index.\n\t */\n\tprivate heapifyUp(index: number): void {\n\t\tlet current = index;\n\n\t\twhile (current > 0) {\n\t\t\tconst parent = Math.floor((current - 1) / 2);\n\t\t\tconst currentEntry = this.heap[current];\n\t\t\tconst parentEntry = this.heap[parent];\n\n\t\t\tif (currentEntry === undefined || parentEntry === undefined) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (currentEntry.priority >= parentEntry.priority) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Swap current and parent\n\t\t\tthis.heap[current] = parentEntry;\n\t\t\tthis.heap[parent] = currentEntry;\n\t\t\tcurrent = parent;\n\t\t}\n\t}\n\n\t/**\n\t * Restores heap property by moving element down from given index.\n\t */\n\tprivate heapifyDown(index: number): void {\n\t\tlet current = index;\n\t\tconst length = this.heap.length;\n\n\t\twhile (current < length) {\n\t\t\tconst left = 2 * current + 1;\n\t\t\tconst right = 2 * current + 2;\n\t\t\tlet smallest = current;\n\n\t\t\tconst currentEntry = this.heap[current];\n\t\t\tif (currentEntry === undefined) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Compare with left child\n\t\t\tconst leftEntry = this.heap[left];\n\t\t\tif (\n\t\t\t\tleft < length &&\n\t\t\t\tleftEntry !== undefined &&\n\t\t\t\tleftEntry.priority < currentEntry.priority\n\t\t\t) {\n\t\t\t\tsmallest = left;\n\t\t\t}\n\n\t\t\t// Compare with right child (need to re-fetch smallest after potential update)\n\t\t\tconst rightEntry = this.heap[right];\n\t\t\tconst currentSmallestEntry = this.heap[smallest];\n\t\t\tif (\n\t\t\t\tright < length &&\n\t\t\t\trightEntry !== undefined &&\n\t\t\t\tcurrentSmallestEntry !== undefined &&\n\t\t\t\trightEntry.priority < currentSmallestEntry.priority\n\t\t\t) {\n\t\t\t\tsmallest = right;\n\t\t\t}\n\n\t\t\tif (smallest === current) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Get the final smallest entry (after determining final smallest index)\n\t\t\tconst finalSmallestEntry = this.heap[smallest];\n\t\t\tif (finalSmallestEntry !== undefined) {\n\t\t\t\tthis.heap[current] = finalSmallestEntry;\n\t\t\t\tthis.heap[smallest] = currentEntry;\n\t\t\t\tcurrent = smallest;\n\t\t\t} else {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;;AAYA,IAAa,gBAAb,MAA8B;CAC7B,OAAmC,EAAE;;;;CAKrC,OAAsB;AACrB,SAAO,KAAK,KAAK;;;;;CAMlB,UAA0B;AACzB,SAAO,KAAK,KAAK,WAAW;;;;;CAM7B,KAAY,MAAS,UAAwB;EAC5C,MAAM,QAA0B;GAAE;GAAM;GAAU;AAClD,OAAK,KAAK,KAAK,MAAM;AACrB,OAAK,UAAU,KAAK,KAAK,SAAS,EAAE;;;;;;CAOrC,MAA2C;AAC1C,MAAI,KAAK,KAAK,WAAW,EACxB;EAGD,MAAM,OAAO,KAAK,KAAK;AACvB,MAAI,SAAS,KAAA,EACZ;EAGD,MAAM,OAAO,KAAK,KAAK,KAAK;AAC5B,MAAI,SAAS,KAAA,EACZ,QAAO;AAGR,MAAI,KAAK,KAAK,SAAS,GAAG;AACzB,QAAK,KAAK,KAAK;AACf,QAAK,YAAY,EAAE;;AAGpB,SAAO;;;;;;CAOR,OAA4C;AAC3C,SAAO,KAAK,KAAK;;;;;;CAOlB,UAAuB;EAEtB,MAAM,QAAQ,KAAK,MAAM,KAAK,KAAK,SAAS,EAAE,GAAG;AACjD,OAAK,IAAI,IAAI,OAAO,KAAK,GAAG,IAC3B,MAAK,YAAY,EAAE;;;;;;;;;;CAYrB,YACC,MACA,aACA,QACU;EACV,IAAI,aAAa;AAEjB,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,QAAQ,KAAK;GAC1C,MAAM,QAAQ,KAAK,KAAK;AACxB,OAAI,UAAU,KAAA,KAAa,OAAO,MAAM,MAAM,KAAK,EAAE;AACpD,iBAAa;AACb;;;AAIF,MAAI,eAAe,GAClB,QAAO;EAGR,MAAM,QAAQ,KAAK,KAAK;AACxB,MAAI,UAAU,KAAA,EACb,QAAO;AAIR,MAAI,eAAe,MAAM,SACxB,QAAO;AAGR,QAAM,WAAW;AACjB,OAAK,UAAU,WAAW;AAC1B,SAAO;;;;;CAMR,UAAkB,OAAqB;EACtC,IAAI,UAAU;AAEd,SAAO,UAAU,GAAG;GACnB,MAAM,SAAS,KAAK,OAAO,UAAU,KAAK,EAAE;GAC5C,MAAM,eAAe,KAAK,KAAK;GAC/B,MAAM,cAAc,KAAK,KAAK;AAE9B,OAAI,iBAAiB,KAAA,KAAa,gBAAgB,KAAA,EACjD;AAGD,OAAI,aAAa,YAAY,YAAY,SACxC;AAID,QAAK,KAAK,WAAW;AACrB,QAAK,KAAK,UAAU;AACpB,aAAU;;;;;;CAOZ,YAAoB,OAAqB;EACxC,IAAI,UAAU;EACd,MAAM,SAAS,KAAK,KAAK;AAEzB,SAAO,UAAU,QAAQ;GACxB,MAAM,OAAO,IAAI,UAAU;GAC3B,MAAM,QAAQ,IAAI,UAAU;GAC5B,IAAI,WAAW;GAEf,MAAM,eAAe,KAAK,KAAK;AAC/B,OAAI,iBAAiB,KAAA,EACpB;GAID,MAAM,YAAY,KAAK,KAAK;AAC5B,OACC,OAAO,UACP,cAAc,KAAA,KACd,UAAU,WAAW,aAAa,SAElC,YAAW;GAIZ,MAAM,aAAa,KAAK,KAAK;GAC7B,MAAM,uBAAuB,KAAK,KAAK;AACvC,OACC,QAAQ,UACR,eAAe,KAAA,KACf,yBAAyB,KAAA,KACzB,WAAW,WAAW,qBAAqB,SAE3C,YAAW;AAGZ,OAAI,aAAa,QAChB;GAID,MAAM,qBAAqB,KAAK,KAAK;AACrC,OAAI,uBAAuB,KAAA,GAAW;AACrC,SAAK,KAAK,WAAW;AACrB,SAAK,KAAK,YAAY;AACtB,cAAU;SAEV"}

package/dist/traversal-CQCjUwUJ.js

@@ -1,149 +0,0 @@
-//#region src/traversal/bfs.ts
-/**
-* Perform a breadth-first search traversal from a start node.
-*
-* This generator yields node IDs in BFS order. It uses lazy evaluation
-* via a generator, making it memory-efficient for large graphs.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Node IDs in BFS order
-*
-* @example
-* ```typescript
-* for (const nodeId of bfs(graph, "A")) {
-*   console.log(nodeId);
-* }
-* ```
-*/
-function* bfs(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = new Set([start]);
-	const queue = [start];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		yield current;
-		for (const neighbour of graph.neighbours(current)) if (!visited.has(neighbour)) {
-			visited.add(neighbour);
-			queue.push(neighbour);
-		}
-	}
-}
-/**
-* Perform a breadth-first search traversal with path information.
-*
-* This generator yields detailed information about each visited node,
-* including its depth from the start and parent in the BFS tree.
-* Useful for reconstructing shortest paths.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Objects containing node ID, depth, and parent
-*
-* @example
-* ```typescript
-* for (const entry of bfsWithPath(graph, "A")) {
-*   console.log(`${entry.node} at depth ${entry.depth}`);
-* }
-* ```
-*/
-function* bfsWithPath(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = new Set([start]);
-	const queue = [{
-		node: start,
-		depth: 0,
-		parent: void 0
-	}];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		yield current;
-		for (const neighbour of graph.neighbours(current.node)) if (!visited.has(neighbour)) {
-			visited.add(neighbour);
-			queue.push({
-				node: neighbour,
-				depth: current.depth + 1,
-				parent: current.node
-			});
-		}
-	}
-}
-//#endregion
-//#region src/traversal/dfs.ts
-/**
-* Perform a depth-first search traversal from a start node.
-*
-* This generator yields node IDs in DFS order (pre-order traversal).
-* It uses lazy evaluation via a generator, making it memory-efficient
-* for large graphs.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Node IDs in DFS order
-*
-* @example
-* ```typescript
-* for (const nodeId of dfs(graph, "A")) {
-*   console.log(nodeId);
-* }
-* ```
-*/
-function* dfs(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [start];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (current === void 0) break;
-		if (visited.has(current)) continue;
-		visited.add(current);
-		yield current;
-		const neighbours = [...graph.neighbours(current)].reverse();
-		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push(neighbour);
-	}
-}
-/**
-* Perform a depth-first search traversal with path information.
-*
-* This generator yields detailed information about each visited node,
-* including its depth from the start and parent in the DFS tree.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Objects containing node ID, depth, and parent
-*
-* @example
-* ```typescript
-* for (const entry of dfsWithPath(graph, "A")) {
-*   console.log(`${entry.node} at depth ${entry.depth}`);
-* }
-* ```
-*/
-function* dfsWithPath(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [{
-		node: start,
-		depth: 0,
-		parent: void 0
-	}];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (current === void 0) break;
-		if (visited.has(current.node)) continue;
-		visited.add(current.node);
-		yield current;
-		const neighbours = [...graph.neighbours(current.node)].reverse();
-		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push({
-			node: neighbour,
-			depth: current.depth + 1,
-			parent: current.node
-		});
-	}
-}
-//#endregion
-export { bfsWithPath as i, dfsWithPath as n, bfs as r, dfs as t };
-
-//# sourceMappingURL=traversal-CQCjUwUJ.js.map

package/dist/traversal-CQCjUwUJ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traversal-CQCjUwUJ.js","names":[],"sources":["../src/traversal/bfs.ts","../src/traversal/dfs.ts"],"sourcesContent":["/**\n * Breadth-first search traversal algorithms.\n *\n * BFS explores nodes level by level, visiting all neighbours at the current\n * depth before moving to nodes at the next depth level. This guarantees\n * shortest path discovery in unweighted graphs.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during BFS traversal.\n */\nexport interface BfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the BFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a breadth-first search traversal from a start node.\n *\n * This generator yields node IDs in BFS order. It uses lazy evaluation\n * via a generator, making it memory-efficient for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in BFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of bfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* bfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: NodeId[] = [start];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a breadth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the BFS tree.\n * Useful for reconstructing shortest paths.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of bfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* bfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<BfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current.node)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n","/**\n * Depth-first search traversal algorithms.\n *\n * DFS explores as far as possible along each branch before backtracking.\n * This makes it useful for cycle detection, topological sorting, and\n * finding connected components.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during DFS traversal.\n */\nexport interface DfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the DFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a depth-first search traversal from a start node.\n *\n * This generator yields node IDs in DFS order (pre-order traversal).\n * It uses lazy evaluation via a generator, making it memory-efficient\n * for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in DFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of dfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* dfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: NodeId[] = [start];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a depth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the DFS tree.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of dfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* dfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<DfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current.node)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current.node);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current.node)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,CAChD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;AAwBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,KAAK,CACrD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK;IACV,MAAM;IACN,OAAO,QAAQ,QAAQ;IACvB,QAAQ,QAAQ;IAChB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AChEN,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,CACvB;AAGD,UAAQ,IAAI,QAAQ;AACpB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS;AAC3D,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;AAuBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,KAAK,CAC5B;AAGD,UAAQ,IAAI,QAAQ,KAAK;AACzB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,KAAK,CAAC,CAAC,SAAS;AAChE,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK;GACV,MAAM;GACN,OAAO,QAAQ,QAAQ;GACvB,QAAQ,QAAQ;GAChB,CAAC"}

package/dist/traversal-QeHaNUWn.cjs

@@ -1,172 +0,0 @@
-//#region src/traversal/bfs.ts
-/**
-* Perform a breadth-first search traversal from a start node.
-*
-* This generator yields node IDs in BFS order. It uses lazy evaluation
-* via a generator, making it memory-efficient for large graphs.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Node IDs in BFS order
-*
-* @example
-* ```typescript
-* for (const nodeId of bfs(graph, "A")) {
-*   console.log(nodeId);
-* }
-* ```
-*/
-function* bfs(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = new Set([start]);
-	const queue = [start];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		yield current;
-		for (const neighbour of graph.neighbours(current)) if (!visited.has(neighbour)) {
-			visited.add(neighbour);
-			queue.push(neighbour);
-		}
-	}
-}
-/**
-* Perform a breadth-first search traversal with path information.
-*
-* This generator yields detailed information about each visited node,
-* including its depth from the start and parent in the BFS tree.
-* Useful for reconstructing shortest paths.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Objects containing node ID, depth, and parent
-*
-* @example
-* ```typescript
-* for (const entry of bfsWithPath(graph, "A")) {
-*   console.log(`${entry.node} at depth ${entry.depth}`);
-* }
-* ```
-*/
-function* bfsWithPath(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = new Set([start]);
-	const queue = [{
-		node: start,
-		depth: 0,
-		parent: void 0
-	}];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		yield current;
-		for (const neighbour of graph.neighbours(current.node)) if (!visited.has(neighbour)) {
-			visited.add(neighbour);
-			queue.push({
-				node: neighbour,
-				depth: current.depth + 1,
-				parent: current.node
-			});
-		}
-	}
-}
-//#endregion
-//#region src/traversal/dfs.ts
-/**
-* Perform a depth-first search traversal from a start node.
-*
-* This generator yields node IDs in DFS order (pre-order traversal).
-* It uses lazy evaluation via a generator, making it memory-efficient
-* for large graphs.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Node IDs in DFS order
-*
-* @example
-* ```typescript
-* for (const nodeId of dfs(graph, "A")) {
-*   console.log(nodeId);
-* }
-* ```
-*/
-function* dfs(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [start];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (current === void 0) break;
-		if (visited.has(current)) continue;
-		visited.add(current);
-		yield current;
-		const neighbours = [...graph.neighbours(current)].reverse();
-		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push(neighbour);
-	}
-}
-/**
-* Perform a depth-first search traversal with path information.
-*
-* This generator yields detailed information about each visited node,
-* including its depth from the start and parent in the DFS tree.
-*
-* @param graph - The graph to traverse
-* @param start - The starting node ID
-* @yields Objects containing node ID, depth, and parent
-*
-* @example
-* ```typescript
-* for (const entry of dfsWithPath(graph, "A")) {
-*   console.log(`${entry.node} at depth ${entry.depth}`);
-* }
-* ```
-*/
-function* dfsWithPath(graph, start) {
-	if (!graph.hasNode(start)) return;
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [{
-		node: start,
-		depth: 0,
-		parent: void 0
-	}];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (current === void 0) break;
-		if (visited.has(current.node)) continue;
-		visited.add(current.node);
-		yield current;
-		const neighbours = [...graph.neighbours(current.node)].reverse();
-		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push({
-			node: neighbour,
-			depth: current.depth + 1,
-			parent: current.node
-		});
-	}
-}
-//#endregion
-Object.defineProperty(exports, "bfs", {
-	enumerable: true,
-	get: function() {
-		return bfs;
-	}
-});
-Object.defineProperty(exports, "bfsWithPath", {
-	enumerable: true,
-	get: function() {
-		return bfsWithPath;
-	}
-});
-Object.defineProperty(exports, "dfs", {
-	enumerable: true,
-	get: function() {
-		return dfs;
-	}
-});
-Object.defineProperty(exports, "dfsWithPath", {
-	enumerable: true,
-	get: function() {
-		return dfsWithPath;
-	}
-});
-
-//# sourceMappingURL=traversal-QeHaNUWn.cjs.map

package/dist/traversal-QeHaNUWn.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"traversal-QeHaNUWn.cjs","names":[],"sources":["../src/traversal/bfs.ts","../src/traversal/dfs.ts"],"sourcesContent":["/**\n * Breadth-first search traversal algorithms.\n *\n * BFS explores nodes level by level, visiting all neighbours at the current\n * depth before moving to nodes at the next depth level. This guarantees\n * shortest path discovery in unweighted graphs.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during BFS traversal.\n */\nexport interface BfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the BFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a breadth-first search traversal from a start node.\n *\n * This generator yields node IDs in BFS order. It uses lazy evaluation\n * via a generator, making it memory-efficient for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in BFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of bfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* bfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: NodeId[] = [start];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a breadth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the BFS tree.\n * Useful for reconstructing shortest paths.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of bfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* bfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<BfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current.node)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n","/**\n * Depth-first search traversal algorithms.\n *\n * DFS explores as far as possible along each branch before backtracking.\n * This makes it useful for cycle detection, topological sorting, and\n * finding connected components.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during DFS traversal.\n */\nexport interface DfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the DFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a depth-first search traversal from a start node.\n *\n * This generator yields node IDs in DFS order (pre-order traversal).\n * It uses lazy evaluation via a generator, making it memory-efficient\n * for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in DFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of dfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* dfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: NodeId[] = [start];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a depth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the DFS tree.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of dfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* dfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<DfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current.node)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current.node);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current.node)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,CAChD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;AAwBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,KAAK,CACrD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK;IACV,MAAM;IACN,OAAO,QAAQ,QAAQ;IACvB,QAAQ,QAAQ;IAChB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AChEN,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,CACvB;AAGD,UAAQ,IAAI,QAAQ;AACpB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS;AAC3D,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;AAuBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,KAAK,CAC5B;AAGD,UAAQ,IAAI,QAAQ,KAAK;AACzB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,KAAK,CAAC,CAAC,SAAS;AAChE,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK;GACV,MAAM;GACN,OAAO,QAAQ,QAAQ;GACvB,QAAQ,QAAQ;GAChB,CAAC"}

package/dist/utils-Q_akvlMn.js

@@ -1,164 +0,0 @@
-//#region src/utils/clustering-coefficient.ts
-/**
-* Compute the local clustering coefficient for a single node.
-*
-* The clustering coefficient is defined as:
-*   CC(v) = (triangles through v) / (possible triangles)
-*   CC(v) = 2 * |{(u,w) : u,w in N(v), (u,w) in E}| / (deg(v) * (deg(v) - 1))
-*
-* For nodes with degree < 2, the clustering coefficient is 0.
-*
-* @param graph - The graph to compute on
-* @param nodeId - The node to compute clustering coefficient for
-* @returns The clustering coefficient in [0, 1], or 0 if undefined
-*/
-function localClusteringCoefficient(graph, nodeId) {
-	const neighbours = [...graph.neighbours(nodeId, "both")];
-	const degree = neighbours.length;
-	if (degree < 2) return 0;
-	let triangleCount = 0;
-	for (let i = 0; i < neighbours.length; i++) {
-		const u = neighbours[i];
-		if (u === void 0) continue;
-		for (let j = i + 1; j < neighbours.length; j++) {
-			const w = neighbours[j];
-			if (w === void 0) continue;
-			if (graph.getEdge(u, w) !== void 0 || graph.getEdge(w, u) !== void 0) triangleCount++;
-		}
-	}
-	const possibleTriangles = degree * (degree - 1) / 2;
-	return triangleCount / possibleTriangles;
-}
-/**
-* Compute approximate local clustering coefficient using sampling.
-*
-* For nodes with many neighbours, this samples neighbour pairs rather than
-* checking all pairs. Useful for large graphs where exact computation is expensive.
-*
-* @param graph - The graph to compute on
-* @param nodeId - The node to compute clustering coefficient for
-* @param sampleSize - Maximum number of neighbour pairs to check (default: 100)
-* @returns The approximate clustering coefficient in [0, 1]
-*/
-function approximateClusteringCoefficient(graph, nodeId, sampleSize = 100) {
-	const neighbours = [...graph.neighbours(nodeId, "both")];
-	const degree = neighbours.length;
-	if (degree < 2) return 0;
-	const possibleTriangles = degree * (degree - 1) / 2;
-	if (possibleTriangles <= sampleSize) return localClusteringCoefficient(graph, nodeId);
-	let triangleCount = 0;
-	let sampled = 0;
-	for (let i = 0; i < neighbours.length && sampled < sampleSize; i++) {
-		const u = neighbours[i];
-		if (u === void 0) continue;
-		for (let j = i + 1; j < neighbours.length && sampled < sampleSize; j++) {
-			const w = neighbours[j];
-			if (w === void 0) continue;
-			sampled++;
-			if (graph.getEdge(u, w) !== void 0 || graph.getEdge(w, u) !== void 0) triangleCount++;
-		}
-	}
-	return triangleCount / sampled * (possibleTriangles / possibleTriangles);
-}
-/**
-* Compute clustering coefficients for multiple nodes efficiently.
-*
-* Reuses neighbour sets to avoid repeated iteration.
-*
-* @param graph - The graph to compute on
-* @param nodeIds - The nodes to compute clustering coefficients for
-* @returns Map from nodeId to clustering coefficient
-*/
-function batchClusteringCoefficients(graph, nodeIds) {
-	const results = /* @__PURE__ */ new Map();
-	for (const nodeId of nodeIds) results.set(nodeId, localClusteringCoefficient(graph, nodeId));
-	return results;
-}
-//#endregion
-//#region src/utils/entropy.ts
-/**
-* Entropy computation utilities for graph analysis.
-*
-* Shannon entropy measures uncertainty or randomness in a distribution.
-* Used in EDGE and HAE algorithms for heterogeneity-aware expansion.
-*
-* @packageDocumentation
-*/
-/**
-* Compute Shannon entropy of a probability distribution.
-*
-* Shannon entropy is defined as:
-*   H(X) = -Σ p(x) × log₂(p(x))
-*
-* A uniform distribution has maximum entropy.
-* A deterministic distribution (all probability on one value) has zero entropy.
-*
-* @param probabilities - Array of probabilities (should sum to 1)
-* @returns Entropy in bits (log base 2), or 0 if probabilities are invalid
-*/
-function shannonEntropy(probabilities) {
-	if (probabilities.length === 0) return 0;
-	let entropy = 0;
-	for (const p of probabilities) if (p > 0) entropy -= p * Math.log2(p);
-	return entropy;
-}
-/**
-* Compute normalised entropy (entropy divided by maximum possible entropy).
-*
-* Normalised entropy is in [0, 1], where:
-* - 0 means the distribution is deterministic (all mass on one value)
-* - 1 means the distribution is uniform (maximum uncertainty)
-*
-* This is useful for comparing entropy across distributions with different
-* numbers of possible values.
-*
-* @param probabilities - Array of probabilities (should sum to 1)
-* @returns Normalised entropy in [0, 1], or 0 if only one category
-*/
-function normalisedEntropy(probabilities) {
-	if (probabilities.length <= 1) return 0;
-	const H = shannonEntropy(probabilities);
-	const Hmax = Math.log2(probabilities.length);
-	if (Hmax === 0) return 0;
-	return H / Hmax;
-}
-/**
-* Compute entropy from a frequency count.
-*
-* Converts counts to probabilities and then computes entropy.
-* This is a convenience function when you have raw counts rather than
-* normalised probabilities.
-*
-* @param counts - Array of frequency counts
-* @returns Entropy in bits
-*/
-function entropyFromCounts(counts) {
-	if (counts.length === 0) return 0;
-	const total = counts.reduce((sum, c) => sum + c, 0);
-	if (total === 0) return 0;
-	return shannonEntropy(counts.map((c) => c / total));
-}
-/**
-* Compute local type entropy for a node's neighbours.
-*
-* This measures the diversity of types among a node's neighbours.
-* High entropy = heterogeneous neighbourhood (diverse types).
-* Low entropy = homogeneous neighbourhood (similar types).
-*
-* @param neighbourTypes - Array of type labels for neighbours
-* @returns Normalised entropy in [0, 1]
-*/
-function localTypeEntropy(neighbourTypes) {
-	if (neighbourTypes.length <= 1) return 0;
-	const typeCounts = /* @__PURE__ */ new Map();
-	for (const t of neighbourTypes) typeCounts.set(t, (typeCounts.get(t) ?? 0) + 1);
-	if (typeCounts.size === 1) return 0;
-	const probabilities = [];
-	const total = neighbourTypes.length;
-	for (const count of typeCounts.values()) probabilities.push(count / total);
-	return normalisedEntropy(probabilities);
-}
-//#endregion
-export { approximateClusteringCoefficient as a, shannonEntropy as i, localTypeEntropy as n, batchClusteringCoefficients as o, normalisedEntropy as r, localClusteringCoefficient as s, entropyFromCounts as t };
-
-//# sourceMappingURL=utils-Q_akvlMn.js.map