graphwise 1.8.0 → 1.9.0

package/dist/extraction/index.cjs

@@ -0,0 +1,630 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_adjacency_map = require("../adjacency-map-JqBnMNkF.cjs");
+//#region src/extraction/ego-network.ts
+/**
+* Extract the ego-network (k-hop neighbourhood) of a centre node.
+*
+* The ego-network includes all nodes reachable within k hops from the
+* centre node, plus all edges between those nodes (induced subgraph).
+*
+* For directed graphs, the search follows outgoing edges by default.
+* To include incoming edges, use direction 'both' in the underlying traversal.
+*
+* @param graph - The source graph
+* @param centre - The centre node ID
+* @param options - Extraction options
+* @returns An induced subgraph of the k-hop neighbourhood
+* @throws Error if the centre node does not exist in the graph
+*
+* @example
+* ```typescript
+* // 2-hop neighbourhood
+* const ego = extractEgoNetwork(graph, 'A', { hops: 2 });
+* ```
+*/
+function extractEgoNetwork(graph, centre, options) {
+	const hops = options?.hops ?? 1;
+	if (!graph.hasNode(centre)) throw new Error(`Centre node '${centre}' does not exist in the graph`);
+	if (hops < 0) throw new Error(`Hops must be non-negative, got ${String(hops)}`);
+	const nodesInEgoNetwork = new Set([centre]);
+	if (hops > 0) {
+		const visited = new Set([centre]);
+		const queue = [[centre, 0]];
+		while (queue.length > 0) {
+			const entry = queue.shift();
+			if (entry === void 0) break;
+			const [current, distance] = entry;
+			if (distance < hops) {
+				for (const neighbour of graph.neighbours(current)) if (!visited.has(neighbour)) {
+					visited.add(neighbour);
+					nodesInEgoNetwork.add(neighbour);
+					queue.push([neighbour, distance + 1]);
+				}
+			}
+		}
+	}
+	const result = graph.directed ? require_adjacency_map.AdjacencyMapGraph.directed() : require_adjacency_map.AdjacencyMapGraph.undirected();
+	for (const nodeId of nodesInEgoNetwork) {
+		const nodeData = graph.getNode(nodeId);
+		if (nodeData !== void 0) result.addNode(nodeData);
+	}
+	for (const edge of graph.edges()) if (nodesInEgoNetwork.has(edge.source) && nodesInEgoNetwork.has(edge.target)) result.addEdge(edge);
+	return result;
+}
+//#endregion
+//#region src/extraction/k-core.ts
+/**
+* Extract the k-core of a graph.
+*
+* The k-core is the maximal connected subgraph where every node has
+* degree at least k. This is computed using a peeling algorithm that
+* iteratively removes nodes with degree less than k.
+*
+* For undirected graphs, degree counts all adjacent nodes.
+* For directed graphs, degree counts both in- and out-neighbours.
+*
+* @param graph - The source graph
+* @param k - The minimum degree threshold
+* @returns A new graph containing the k-core (may be empty)
+*
+* @example
+* ```typescript
+* // Extract the 3-core (nodes with at least 3 neighbours)
+* const core3 = extractKCore(graph, 3);
+* ```
+*/
+function extractKCore(graph, k) {
+	if (k < 0) throw new Error(`k must be non-negative, got ${String(k)}`);
+	const remaining = /* @__PURE__ */ new Set();
+	const degrees = /* @__PURE__ */ new Map();
+	for (const nodeId of graph.nodeIds()) {
+		remaining.add(nodeId);
+		const deg = graph.directed ? graph.degree(nodeId, "both") : graph.degree(nodeId);
+		degrees.set(nodeId, deg);
+	}
+	const toRemove = [];
+	for (const [nodeId, deg] of degrees) if (deg < k) toRemove.push(nodeId);
+	while (toRemove.length > 0) {
+		const nodeId = toRemove.shift();
+		if (nodeId === void 0) break;
+		if (!remaining.has(nodeId)) continue;
+		remaining.delete(nodeId);
+		const neighbours = graph.directed ? graph.neighbours(nodeId, "both") : graph.neighbours(nodeId);
+		for (const neighbour of neighbours) if (remaining.has(neighbour)) {
+			const newDeg = (degrees.get(neighbour) ?? 0) - 1;
+			degrees.set(neighbour, newDeg);
+			if (newDeg < k && newDeg === k - 1) toRemove.push(neighbour);
+		}
+	}
+	const result = graph.directed ? require_adjacency_map.AdjacencyMapGraph.directed() : require_adjacency_map.AdjacencyMapGraph.undirected();
+	for (const nodeId of remaining) {
+		const nodeData = graph.getNode(nodeId);
+		if (nodeData !== void 0) result.addNode(nodeData);
+	}
+	for (const edge of graph.edges()) if (remaining.has(edge.source) && remaining.has(edge.target)) result.addEdge(edge);
+	return result;
+}
+//#endregion
+//#region src/extraction/truss.ts
+/**
+* Count triangles involving a given edge.
+*
+* For an edge (u, v), count common neighbours of u and v.
+* Each common neighbour w forms a triangle u-v-w.
+*
+* @param graph - The graph
+* @param u - First endpoint
+* @param v - Second endpoint
+* @returns Number of triangles containing the edge (u, v)
+*/
+function countEdgeTriangles(graph, u, v) {
+	const uNeighbours = new Set(graph.neighbours(u));
+	let count = 0;
+	for (const w of graph.neighbours(v)) if (w !== u && uNeighbours.has(w)) count++;
+	return count;
+}
+/**
+* Extract the k-truss of a graph.
+*
+* The k-truss is the maximal subgraph where every edge participates in
+* at least k-2 triangles. This is computed by iteratively removing edges
+* with fewer than k-2 triangles, then removing isolated nodes.
+*
+* Note: K-truss is typically defined for undirected graphs. For directed
+* graphs, this treats the graph as undirected for triangle counting.
+*
+* @param graph - The source graph
+* @param k - The minimum triangle count threshold (edge must be in >= k-2 triangles)
+* @returns A new graph containing the k-truss (may be empty)
+*
+* @example
+* ```typescript
+* // Extract the 3-truss (edges in at least 1 triangle)
+* const truss3 = extractKTruss(graph, 3);
+* ```
+*/
+function extractKTruss(graph, k) {
+	if (k < 2) throw new Error(`k must be at least 2, got ${String(k)}`);
+	const minTriangles = k - 2;
+	const adjacency = /* @__PURE__ */ new Map();
+	const edgeData = /* @__PURE__ */ new Map();
+	const remainingEdges = /* @__PURE__ */ new Set();
+	for (const nodeId of graph.nodeIds()) adjacency.set(nodeId, /* @__PURE__ */ new Set());
+	for (const edge of graph.edges()) {
+		const { source, target } = edge;
+		adjacency.get(source)?.add(target);
+		adjacency.get(target)?.add(source);
+		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
+		edgeData.set(key, edge);
+		remainingEdges.add(key);
+	}
+	const triangleCounts = /* @__PURE__ */ new Map();
+	const edgesToRemove = [];
+	for (const key of remainingEdges) {
+		const edge = edgeData.get(key);
+		if (edge !== void 0) {
+			const count = countEdgeTriangles(graph, edge.source, edge.target);
+			triangleCounts.set(key, count);
+			if (count < minTriangles) edgesToRemove.push(key);
+		}
+	}
+	while (edgesToRemove.length > 0) {
+		const edgeKey = edgesToRemove.shift();
+		if (edgeKey === void 0) break;
+		if (!remainingEdges.has(edgeKey)) continue;
+		remainingEdges.delete(edgeKey);
+		const edge = edgeData.get(edgeKey);
+		if (edge === void 0) continue;
+		const { source, target } = edge;
+		adjacency.get(source)?.delete(target);
+		adjacency.get(target)?.delete(source);
+		const sourceNeighbours = adjacency.get(source);
+		if (sourceNeighbours !== void 0) {
+			for (const w of adjacency.get(target) ?? []) if (sourceNeighbours.has(w)) {
+				const keySw = source < w ? `${source}::${w}` : `${w}::${source}`;
+				const keyTw = target < w ? `${target}::${w}` : `${w}::${target}`;
+				for (const keyToUpdate of [keySw, keyTw]) if (remainingEdges.has(keyToUpdate)) {
+					const newCount = (triangleCounts.get(keyToUpdate) ?? 0) - 1;
+					triangleCounts.set(keyToUpdate, newCount);
+					if (newCount < minTriangles && newCount === minTriangles - 1) edgesToRemove.push(keyToUpdate);
+				}
+			}
+		}
+	}
+	const nodesWithEdges = /* @__PURE__ */ new Set();
+	for (const key of remainingEdges) {
+		const edge = edgeData.get(key);
+		if (edge !== void 0) {
+			nodesWithEdges.add(edge.source);
+			nodesWithEdges.add(edge.target);
+		}
+	}
+	const result = graph.directed ? require_adjacency_map.AdjacencyMapGraph.directed() : require_adjacency_map.AdjacencyMapGraph.undirected();
+	for (const nodeId of nodesWithEdges) {
+		const nodeData = graph.getNode(nodeId);
+		if (nodeData !== void 0) result.addNode(nodeData);
+	}
+	for (const key of remainingEdges) {
+		const edge = edgeData.get(key);
+		if (edge !== void 0 && result.hasNode(edge.source) && result.hasNode(edge.target)) result.addEdge(edge);
+	}
+	return result;
+}
+/**
+* Compute the truss number for each edge.
+*
+* The truss number of an edge is the largest k such that the edge
+* belongs to the k-truss.
+*
+* @param graph - The source graph
+* @returns Map from edge key (canonical "u::v") to truss number
+*
+* @example
+* ```typescript
+* const trussNumbers = computeTrussNumbers(graph);
+* const edgeKey = 'A::B'; // where A < B lexicographically
+* console.log(`Edge A-B is in the ${trussNumbers.get(edgeKey)}-truss`);
+* ```
+*/
+function computeTrussNumbers(graph) {
+	const adjacency = /* @__PURE__ */ new Map();
+	const edgeData = /* @__PURE__ */ new Map();
+	const remainingEdges = /* @__PURE__ */ new Set();
+	for (const nodeId of graph.nodeIds()) adjacency.set(nodeId, /* @__PURE__ */ new Set());
+	for (const edge of graph.edges()) {
+		const { source, target } = edge;
+		adjacency.get(source)?.add(target);
+		adjacency.get(target)?.add(source);
+		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
+		edgeData.set(key, edge);
+		remainingEdges.add(key);
+	}
+	const triangleCounts = /* @__PURE__ */ new Map();
+	for (const key of remainingEdges) {
+		const edge = edgeData.get(key);
+		if (edge !== void 0) triangleCounts.set(key, countEdgeTriangles(graph, edge.source, edge.target));
+	}
+	const trussNumbers = /* @__PURE__ */ new Map();
+	const edgesByTriangleCount = /* @__PURE__ */ new Map();
+	for (const [key, count] of triangleCounts) {
+		if (!edgesByTriangleCount.has(count)) edgesByTriangleCount.set(count, /* @__PURE__ */ new Set());
+		edgesByTriangleCount.get(count)?.add(key);
+	}
+	const sortedCounts = [...edgesByTriangleCount.keys()].sort((a, b) => a - b);
+	for (const currentCount of sortedCounts) {
+		const bucket = edgesByTriangleCount.get(currentCount);
+		if (bucket === void 0) continue;
+		while (bucket.size > 0) {
+			const edgeKey = bucket.values().next().value;
+			if (edgeKey === void 0) break;
+			bucket.delete(edgeKey);
+			if (!remainingEdges.has(edgeKey)) continue;
+			const trussNumber = currentCount + 2;
+			trussNumbers.set(edgeKey, trussNumber);
+			remainingEdges.delete(edgeKey);
+			const edge = edgeData.get(edgeKey);
+			if (edge === void 0) continue;
+			const { source, target } = edge;
+			adjacency.get(source)?.delete(target);
+			adjacency.get(target)?.delete(source);
+			const sourceNeighbours = adjacency.get(source);
+			if (sourceNeighbours !== void 0) {
+				for (const w of adjacency.get(target) ?? []) if (sourceNeighbours.has(w)) {
+					const keySw = source < w ? `${source}::${w}` : `${w}::${source}`;
+					const keyTw = target < w ? `${target}::${w}` : `${w}::${target}`;
+					for (const keyToUpdate of [keySw, keyTw]) if (remainingEdges.has(keyToUpdate)) {
+						const oldCount = triangleCounts.get(keyToUpdate) ?? 0;
+						const newCount = oldCount - 1;
+						triangleCounts.set(keyToUpdate, newCount);
+						edgesByTriangleCount.get(oldCount)?.delete(keyToUpdate);
+						if (!edgesByTriangleCount.has(newCount)) edgesByTriangleCount.set(newCount, /* @__PURE__ */ new Set());
+						edgesByTriangleCount.get(newCount)?.add(keyToUpdate);
+					}
+				}
+			}
+		}
+	}
+	return trussNumbers;
+}
+//#endregion
+//#region src/extraction/motif.ts
+/**
+* Canonicalise an edge pattern for hashing.
+*
+* Returns a canonical string representation of a small graph pattern.
+*/
+function canonicalisePattern(nodeCount, edges) {
+	const permutations = getPermutations(nodeCount);
+	let minPattern = null;
+	for (const perm of permutations) {
+		const transformedEdges = edges.map(([u, v]) => {
+			const pu = perm[u] ?? -1;
+			const pv = perm[v] ?? -1;
+			if (pu < 0 || pv < 0) return;
+			return pu < pv ? `${String(pu)}-${String(pv)}` : `${String(pv)}-${String(pu)}`;
+		}).filter((edge) => edge !== void 0).sort().join(",");
+		if (minPattern === null || transformedEdges < minPattern) minPattern = transformedEdges;
+	}
+	return minPattern ?? "";
+}
+/**
+* Generate all permutations of [0, n-1].
+*/
+function getPermutations(n) {
+	if (n === 0) return [[]];
+	if (n === 1) return [[0]];
+	const result = [];
+	const arr = Array.from({ length: n }, (_, i) => i);
+	function permute(start) {
+		if (start === n - 1) {
+			result.push([...arr]);
+			return;
+		}
+		for (let i = start; i < n; i++) {
+			const startVal = arr[start];
+			const iVal = arr[i];
+			if (startVal === void 0 || iVal === void 0) continue;
+			arr[start] = iVal;
+			arr[i] = startVal;
+			permute(start + 1);
+			arr[start] = startVal;
+			arr[i] = iVal;
+		}
+	}
+	permute(0);
+	return result;
+}
+/**
+* Enumerate all 3-node motifs in the graph.
+*
+* A 3-node motif (triad) can be one of 4 isomorphism classes for undirected graphs:
+* - Empty: no edges
+* - 1-edge: single edge
+* - 2-star: two edges sharing a node (path of length 2)
+* - Triangle: three edges (complete graph K3)
+*
+* For directed graphs, there are 16 isomorphism classes.
+*
+* @param graph - The source graph
+* @param includeInstances - Whether to include node instances in the result
+* @returns Motif census with counts and optionally instances
+*/
+function enumerate3NodeMotifs(graph, includeInstances) {
+	const counts = /* @__PURE__ */ new Map();
+	const instances = includeInstances ? /* @__PURE__ */ new Map() : void 0;
+	const nodeList = [...graph.nodeIds()];
+	const n = nodeList.length;
+	for (let i = 0; i < n; i++) {
+		const ni = nodeList[i];
+		if (ni === void 0) continue;
+		for (let j = i + 1; j < n; j++) {
+			const nj = nodeList[j];
+			if (nj === void 0) continue;
+			for (let k = j + 1; k < n; k++) {
+				const nk = nodeList[k];
+				if (nk === void 0) continue;
+				const nodes = [
+					ni,
+					nj,
+					nk
+				];
+				const edges = [];
+				for (const [u, v] of [
+					[0, 1],
+					[0, 2],
+					[1, 2]
+				]) {
+					const nu = nodes[u];
+					const nv = nodes[v];
+					if (nu === void 0 || nv === void 0) continue;
+					if (graph.getEdge(nu, nv) !== void 0) edges.push([u, v]);
+					else if (!graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([u, v]);
+					else if (graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([v, u]);
+				}
+				const pattern = canonicalisePattern(3, edges);
+				const count = counts.get(pattern) ?? 0;
+				counts.set(pattern, count + 1);
+				if (includeInstances && instances !== void 0) {
+					if (!instances.has(pattern)) instances.set(pattern, []);
+					const patternInstances = instances.get(pattern);
+					if (patternInstances !== void 0) patternInstances.push([
+						ni,
+						nj,
+						nk
+					]);
+				}
+			}
+		}
+	}
+	if (instances !== void 0) return {
+		counts,
+		instances
+	};
+	return { counts };
+}
+/**
+* Enumerate all 4-node motifs in the graph.
+*
+* A 4-node motif can be one of 11 isomorphism classes for undirected graphs
+* (ranging from empty to complete K4), or many more for directed graphs.
+*
+* @param graph - The source graph
+* @param includeInstances - Whether to include node instances in the result
+* @returns Motif census with counts and optionally instances
+*/
+function enumerate4NodeMotifs(graph, includeInstances) {
+	const counts = /* @__PURE__ */ new Map();
+	const instances = includeInstances ? /* @__PURE__ */ new Map() : void 0;
+	const nodeList = [...graph.nodeIds()];
+	const n = nodeList.length;
+	for (let i = 0; i < n; i++) {
+		const ni = nodeList[i];
+		if (ni === void 0) continue;
+		for (let j = i + 1; j < n; j++) {
+			const nj = nodeList[j];
+			if (nj === void 0) continue;
+			for (let k = j + 1; k < n; k++) {
+				const nk = nodeList[k];
+				if (nk === void 0) continue;
+				for (let l = k + 1; l < n; l++) {
+					const nl = nodeList[l];
+					if (nl === void 0) continue;
+					const nodes = [
+						ni,
+						nj,
+						nk,
+						nl
+					];
+					const edges = [];
+					for (const [u, v] of [
+						[0, 1],
+						[0, 2],
+						[0, 3],
+						[1, 2],
+						[1, 3],
+						[2, 3]
+					]) {
+						const nu = nodes[u];
+						const nv = nodes[v];
+						if (nu === void 0 || nv === void 0) continue;
+						if (graph.getEdge(nu, nv) !== void 0) edges.push([u, v]);
+						else if (!graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([u, v]);
+						else if (graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([v, u]);
+					}
+					const pattern = canonicalisePattern(4, edges);
+					const count = counts.get(pattern) ?? 0;
+					counts.set(pattern, count + 1);
+					if (includeInstances && instances !== void 0) {
+						if (!instances.has(pattern)) instances.set(pattern, []);
+						const patternInstances = instances.get(pattern);
+						if (patternInstances !== void 0) patternInstances.push([
+							ni,
+							nj,
+							nk,
+							nl
+						]);
+					}
+				}
+			}
+		}
+	}
+	if (instances !== void 0) return {
+		counts,
+		instances
+	};
+	return { counts };
+}
+/**
+* Human-readable names for common 3-node motifs.
+*/
+var MOTIF_3_NAMES = new Map([
+	["", "empty"],
+	["0-1", "1-edge"],
+	["0-1,0-2", "2-star"],
+	["0-1,1-2", "path-3"],
+	["0-1,0-2,1-2", "triangle"]
+]);
+/**
+* Human-readable names for common 4-node motifs.
+*/
+var MOTIF_4_NAMES = new Map([
+	["", "empty"],
+	["0-1", "1-edge"],
+	["0-1,0-2", "2-star"],
+	["0-1,0-2,0-3", "3-star"],
+	["0-1,0-2,1-2", "triangle"],
+	["0-1,0-2,1-2,2-3", "paw"],
+	["0-1,0-2,2-3", "path-4"],
+	["0-1,0-2,1-3,2-3", "4-cycle"],
+	["0-1,0-2,1-2,0-3,1-3", "diamond"],
+	["0-1,0-2,0-3,1-2,1-3,2-3", "K4"]
+]);
+/**
+* Enumerate motifs of a given size in the graph.
+*
+* This function counts all occurrences of each distinct motif type
+* (isomorphism class) in the graph. For graphs with many nodes,
+* 4-motif enumeration can be expensive (O(n^4) worst case).
+*
+* @param graph - The source graph
+* @param size - Motif size (3 or 4 nodes)
+* @returns Motif census with counts per motif type
+*
+* @example
+* ```typescript
+* // Count all triangles and other 3-node patterns
+* const census3 = enumerateMotifs(graph, 3);
+* console.log(`Triangles: ${census3.counts.get('0-1,0-2,1-2')}`);
+*
+* // Count 4-node patterns
+* const census4 = enumerateMotifs(graph, 4);
+* ```
+*/
+function enumerateMotifs(graph, size) {
+	return size === 3 ? enumerate3NodeMotifs(graph, false) : enumerate4NodeMotifs(graph, false);
+}
+/**
+* Enumerate motifs with optional instance tracking.
+*
+* @param graph - The source graph
+* @param size - Motif size (3 or 4 nodes)
+* @param includeInstances - Whether to include node instances
+* @returns Motif census with counts and optionally instances
+*/
+function enumerateMotifsWithInstances(graph, size, includeInstances) {
+	return size === 3 ? enumerate3NodeMotifs(graph, includeInstances) : enumerate4NodeMotifs(graph, includeInstances);
+}
+/**
+* Get a human-readable name for a motif pattern.
+*
+* @param pattern - The canonical pattern string
+* @param size - Motif size (3 or 4 nodes)
+* @returns A human-readable name, or the pattern itself if unknown
+*/
+function getMotifName(pattern, size) {
+	return (size === 3 ? MOTIF_3_NAMES : MOTIF_4_NAMES).get(pattern) ?? pattern;
+}
+//#endregion
+//#region src/extraction/induced-subgraph.ts
+/**
+* Extract the induced subgraph containing exactly the specified nodes.
+*
+* The induced subgraph includes all nodes from the input set that exist
+* in the original graph, plus all edges where both endpoints are in the set.
+*
+* @param graph - The source graph
+* @param nodes - Set of node IDs to include in the subgraph
+* @returns A new graph containing the induced subgraph
+*
+* @example
+* ```typescript
+* const subgraph = extractInducedSubgraph(graph, new Set(['A', 'B', 'C']));
+* ```
+*/
+function extractInducedSubgraph(graph, nodes) {
+	const result = graph.directed ? require_adjacency_map.AdjacencyMapGraph.directed() : require_adjacency_map.AdjacencyMapGraph.undirected();
+	for (const nodeId of nodes) {
+		const nodeData = graph.getNode(nodeId);
+		if (nodeData !== void 0) result.addNode(nodeData);
+	}
+	for (const edge of graph.edges()) if (result.hasNode(edge.source) && result.hasNode(edge.target)) result.addEdge(edge);
+	return result;
+}
+//#endregion
+//#region src/extraction/node-filter.ts
+/**
+* Extract a filtered subgraph based on node and edge predicates.
+*
+* Nodes are first filtered by the node predicate (if provided).
+* Edges are then filtered by the edge predicate (if provided), and only
+* retained if both endpoints pass the node predicate.
+*
+* @param graph - The source graph
+* @param options - Filter options specifying node/edge predicates
+* @returns A new graph containing only nodes and edges that pass the predicates
+*
+* @example
+* ```typescript
+* // Extract subgraph of high-weight nodes
+* const filtered = filterSubgraph(graph, {
+*   nodePredicate: (node) => (node.weight ?? 0) > 0.5,
+*   removeIsolated: true
+* });
+* ```
+*/
+function filterSubgraph(graph, options) {
+	const { nodePredicate, edgePredicate, removeIsolated = false } = options ?? {};
+	const result = graph.directed ? require_adjacency_map.AdjacencyMapGraph.directed() : require_adjacency_map.AdjacencyMapGraph.undirected();
+	const includedNodes = /* @__PURE__ */ new Set();
+	for (const nodeId of graph.nodeIds()) {
+		const nodeData = graph.getNode(nodeId);
+		if (nodeData !== void 0) {
+			if (nodePredicate === void 0 || nodePredicate(nodeData)) {
+				result.addNode(nodeData);
+				includedNodes.add(nodeId);
+			}
+		}
+	}
+	for (const edge of graph.edges()) {
+		if (!includedNodes.has(edge.source) || !includedNodes.has(edge.target)) continue;
+		if (edgePredicate === void 0 || edgePredicate(edge)) result.addEdge(edge);
+	}
+	if (removeIsolated) {
+		const isolatedNodes = [];
+		for (const nodeId of result.nodeIds()) if (result.degree(nodeId) === 0) isolatedNodes.push(nodeId);
+		for (const nodeId of isolatedNodes) result.removeNode(nodeId);
+	}
+	return result;
+}
+//#endregion
+exports.computeTrussNumbers = computeTrussNumbers;
+exports.enumerateMotifs = enumerateMotifs;
+exports.enumerateMotifsWithInstances = enumerateMotifsWithInstances;
+exports.extractEgoNetwork = extractEgoNetwork;
+exports.extractInducedSubgraph = extractInducedSubgraph;
+exports.extractKCore = extractKCore;
+exports.extractKTruss = extractKTruss;
+exports.filterSubgraph = filterSubgraph;
+exports.getMotifName = getMotifName;
+
+//# sourceMappingURL=index.cjs.map