graphwise 1.8.0 → 1.9.0

package/dist/ops-upIi6JIi.js

@@ -0,0 +1,212 @@
+import { n as defaultYieldStrategy, t as collectAsyncIterable } from "./utils-BodeE2Mo.js";
+//#region src/async/runners.ts
+/**
+* Resolve a single GraphOp against a synchronous ReadableGraph.
+*
+* Returns a tagged GraphOpResponse so the receiving generator can narrow
+* the result type without type assertions.
+*
+* @param graph - The synchronous graph to query
+* @param op - The operation to resolve
+* @returns The tagged response
+*/
+function resolveSyncOp(graph, op) {
+	switch (op.tag) {
+		case "neighbours": return {
+			tag: "neighbours",
+			value: Array.from(graph.neighbours(op.id, op.direction))
+		};
+		case "degree": return {
+			tag: "degree",
+			value: graph.degree(op.id, op.direction)
+		};
+		case "getNode": return {
+			tag: "getNode",
+			value: graph.getNode(op.id)
+		};
+		case "getEdge": return {
+			tag: "getEdge",
+			value: graph.getEdge(op.source, op.target)
+		};
+		case "hasNode": return {
+			tag: "hasNode",
+			value: graph.hasNode(op.id)
+		};
+		case "yield": return { tag: "yield" };
+		case "progress": return { tag: "progress" };
+	}
+}
+/**
+* Drive a generator to completion using a synchronous graph.
+*
+* The generator yields GraphOp requests; each is resolved immediately
+* against the graph and the tagged response is fed back via gen.next().
+*
+* @param gen - The generator to drive
+* @param graph - The graph to resolve ops against
+* @returns The generator's return value
+*/
+function runSync(gen, graph) {
+	let step = gen.next();
+	while (step.done !== true) {
+		const response = resolveSyncOp(graph, step.value);
+		step = gen.next(response);
+	}
+	return step.value;
+}
+/**
+* Resolve a single GraphOp against an async ReadableGraph.
+*
+* AsyncIterables (neighbours) are collected into readonly arrays so the
+* generator receives the same value type as in sync mode. Returns a tagged
+* GraphOpResponse for type-safe narrowing without assertions.
+*
+* @param graph - The async graph to query
+* @param op - The operation to resolve
+* @returns A promise resolving to the tagged response
+*/
+async function resolveAsyncOp(graph, op) {
+	switch (op.tag) {
+		case "neighbours": return {
+			tag: "neighbours",
+			value: await collectAsyncIterable(graph.neighbours(op.id, op.direction))
+		};
+		case "degree": return {
+			tag: "degree",
+			value: await graph.degree(op.id, op.direction)
+		};
+		case "getNode": return {
+			tag: "getNode",
+			value: await graph.getNode(op.id)
+		};
+		case "getEdge": return {
+			tag: "getEdge",
+			value: await graph.getEdge(op.source, op.target)
+		};
+		case "hasNode": return {
+			tag: "hasNode",
+			value: await graph.hasNode(op.id)
+		};
+		case "yield": return { tag: "yield" };
+		case "progress": return { tag: "progress" };
+	}
+}
+/**
+* Drive a generator to completion using an async graph.
+*
+* Extends sync semantics with:
+* - Cancellation via AbortSignal (throws DOMException "AbortError")
+* - Cooperative yielding at `yield` ops (calls yieldStrategy)
+* - Progress callbacks at `progress` ops (may be async for backpressure)
+* - Error propagation: graph errors are forwarded via gen.throw(); if the
+*   generator does not handle them, they propagate to the caller
+*
+* @param gen - The generator to drive
+* @param graph - The async graph to resolve ops against
+* @param options - Runner configuration
+* @returns A promise resolving to the generator's return value
+*/
+async function runAsync(gen, graph, options) {
+	const signal = options?.signal;
+	const onProgress = options?.onProgress;
+	const yieldStrategy = options?.yieldStrategy ?? defaultYieldStrategy;
+	let step = gen.next();
+	while (step.done !== true) {
+		if (signal?.aborted === true) {
+			const abortError = new DOMException("Aborted", "AbortError");
+			try {
+				gen.throw(abortError);
+			} catch {
+				throw abortError;
+			}
+			throw abortError;
+		}
+		const op = step.value;
+		if (op.tag === "yield") {
+			await yieldStrategy();
+			step = gen.next({ tag: "yield" });
+			continue;
+		}
+		if (op.tag === "progress") {
+			if (onProgress !== void 0) {
+				const maybePromise = onProgress(op.stats);
+				if (maybePromise instanceof Promise) await maybePromise;
+			}
+			step = gen.next({ tag: "progress" });
+			continue;
+		}
+		let response;
+		try {
+			response = await resolveAsyncOp(graph, op);
+		} catch (error) {
+			step = gen.throw(error);
+			continue;
+		}
+		step = gen.next(response);
+	}
+	return step.value;
+}
+//#endregion
+//#region src/async/ops.ts
+function* opNeighbours(id, direction) {
+	const response = yield direction !== void 0 ? {
+		tag: "neighbours",
+		id,
+		direction
+	} : {
+		tag: "neighbours",
+		id
+	};
+	if (response.tag !== "neighbours") throw new TypeError(`Expected neighbours response, got ${response.tag}`);
+	return response.value;
+}
+function* opDegree(id, direction) {
+	const response = yield direction !== void 0 ? {
+		tag: "degree",
+		id,
+		direction
+	} : {
+		tag: "degree",
+		id
+	};
+	if (response.tag !== "degree") throw new TypeError(`Expected degree response, got ${response.tag}`);
+	return response.value;
+}
+function* opGetNode(id) {
+	const response = yield {
+		tag: "getNode",
+		id
+	};
+	if (response.tag !== "getNode") throw new TypeError(`Expected getNode response, got ${response.tag}`);
+	return response.value;
+}
+function* opGetEdge(source, target) {
+	const response = yield {
+		tag: "getEdge",
+		source,
+		target
+	};
+	if (response.tag !== "getEdge") throw new TypeError(`Expected getEdge response, got ${response.tag}`);
+	return response.value;
+}
+function* opHasNode(id) {
+	const response = yield {
+		tag: "hasNode",
+		id
+	};
+	if (response.tag !== "hasNode") throw new TypeError(`Expected hasNode response, got ${response.tag}`);
+	return response.value;
+}
+function* opYield() {
+	yield { tag: "yield" };
+}
+function* opProgress(stats) {
+	yield {
+		tag: "progress",
+		stats
+	};
+}
+//#endregion
+export { opNeighbours as a, resolveAsyncOp as c, runSync as d, opHasNode as i, resolveSyncOp as l, opGetEdge as n, opProgress as o, opGetNode as r, opYield as s, opDegree as t, runAsync as u };
+
+//# sourceMappingURL=ops-upIi6JIi.js.map

package/dist/ops-upIi6JIi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops-upIi6JIi.js","names":[],"sources":["../src/async/runners.ts","../src/async/ops.ts"],"sourcesContent":["/**\n * Sync and async runners for generator-based graph algorithms.\n *\n * The runner drives a generator that yields GraphOp objects, resolves each op\n * against the graph, and feeds the result back via gen.next(response). This\n * allows algorithm logic to be written once as a generator and executed\n * synchronously or asynchronously depending on the graph backing.\n *\n * @module async/runners\n */\n\nimport type { NodeData, EdgeData, ReadableGraph } from \"../graph\";\nimport type { AsyncReadableGraph } from \"../graph/async-interfaces\";\nimport type { GraphOp, GraphOpResponse } from \"./protocol\";\nimport type { AsyncRunnerOptions } from \"./types\";\nimport { collectAsyncIterable, defaultYieldStrategy } from \"./utils\";\n\n// ---------------------------------------------------------------------------\n// Sync runner\n// ---------------------------------------------------------------------------\n\n/**\n * Resolve a single GraphOp against a synchronous ReadableGraph.\n *\n * Returns a tagged GraphOpResponse so the receiving generator can narrow\n * the result type without type assertions.\n *\n * @param graph - The synchronous graph to query\n * @param op - The operation to resolve\n * @returns The tagged response\n */\nexport function resolveSyncOp<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\top: GraphOp,\n): GraphOpResponse<N, E> {\n\tswitch (op.tag) {\n\t\tcase \"neighbours\":\n\t\t\treturn {\n\t\t\t\ttag: \"neighbours\",\n\t\t\t\tvalue: Array.from(graph.neighbours(op.id, op.direction)),\n\t\t\t};\n\t\tcase \"degree\":\n\t\t\treturn { tag: \"degree\", value: graph.degree(op.id, op.direction) };\n\t\tcase \"getNode\":\n\t\t\treturn { tag: \"getNode\", value: graph.getNode(op.id) };\n\t\tcase \"getEdge\":\n\t\t\treturn { tag: \"getEdge\", value: graph.getEdge(op.source, op.target) };\n\t\tcase \"hasNode\":\n\t\t\treturn { tag: \"hasNode\", value: graph.hasNode(op.id) };\n\t\tcase \"yield\":\n\t\t\treturn { tag: \"yield\" };\n\t\tcase \"progress\":\n\t\t\treturn { tag: \"progress\" };\n\t}\n}\n\n/**\n * Drive a generator to completion using a synchronous graph.\n *\n * The generator yields GraphOp requests; each is resolved immediately\n * against the graph and the tagged response is fed back via gen.next().\n *\n * @param gen - The generator to drive\n * @param graph - The graph to resolve ops against\n * @returns The generator's return value\n */\nexport function runSync<N extends NodeData, E extends EdgeData, R>(\n\tgen: Generator<GraphOp, R, GraphOpResponse<N, E>>,\n\tgraph: ReadableGraph<N, E>,\n): R {\n\tlet step = gen.next();\n\twhile (step.done !== true) {\n\t\tconst response = resolveSyncOp(graph, step.value);\n\t\tstep = gen.next(response);\n\t}\n\treturn step.value;\n}\n\n// ---------------------------------------------------------------------------\n// Async runner\n// ---------------------------------------------------------------------------\n\n/**\n * Resolve a single GraphOp against an async ReadableGraph.\n *\n * AsyncIterables (neighbours) are collected into readonly arrays so the\n * generator receives the same value type as in sync mode. Returns a tagged\n * GraphOpResponse for type-safe narrowing without assertions.\n *\n * @param graph - The async graph to query\n * @param op - The operation to resolve\n * @returns A promise resolving to the tagged response\n */\nexport async function resolveAsyncOp<N extends NodeData, E extends EdgeData>(\n\tgraph: AsyncReadableGraph<N, E>,\n\top: GraphOp,\n): Promise<GraphOpResponse<N, E>> {\n\tswitch (op.tag) {\n\t\tcase \"neighbours\":\n\t\t\treturn {\n\t\t\t\ttag: \"neighbours\",\n\t\t\t\tvalue: await collectAsyncIterable(\n\t\t\t\t\tgraph.neighbours(op.id, op.direction),\n\t\t\t\t),\n\t\t\t};\n\t\tcase \"degree\":\n\t\t\treturn { tag: \"degree\", value: await graph.degree(op.id, op.direction) };\n\t\tcase \"getNode\":\n\t\t\treturn { tag: \"getNode\", value: await graph.getNode(op.id) };\n\t\tcase \"getEdge\":\n\t\t\treturn {\n\t\t\t\ttag: \"getEdge\",\n\t\t\t\tvalue: await graph.getEdge(op.source, op.target),\n\t\t\t};\n\t\tcase \"hasNode\":\n\t\t\treturn { tag: \"hasNode\", value: await graph.hasNode(op.id) };\n\t\tcase \"yield\":\n\t\t\treturn { tag: \"yield\" };\n\t\tcase \"progress\":\n\t\t\treturn { tag: \"progress\" };\n\t}\n}\n\n/**\n * Drive a generator to completion using an async graph.\n *\n * Extends sync semantics with:\n * - Cancellation via AbortSignal (throws DOMException \"AbortError\")\n * - Cooperative yielding at `yield` ops (calls yieldStrategy)\n * - Progress callbacks at `progress` ops (may be async for backpressure)\n * - Error propagation: graph errors are forwarded via gen.throw(); if the\n *   generator does not handle them, they propagate to the caller\n *\n * @param gen - The generator to drive\n * @param graph - The async graph to resolve ops against\n * @param options - Runner configuration\n * @returns A promise resolving to the generator's return value\n */\nexport async function runAsync<N extends NodeData, E extends EdgeData, R>(\n\tgen: Generator<GraphOp, R, GraphOpResponse<N, E>>,\n\tgraph: AsyncReadableGraph<N, E>,\n\toptions?: AsyncRunnerOptions,\n): Promise<R> {\n\tconst signal = options?.signal;\n\tconst onProgress = options?.onProgress;\n\tconst yieldStrategy = options?.yieldStrategy ?? defaultYieldStrategy;\n\n\tlet step = gen.next();\n\n\twhile (step.done !== true) {\n\t\t// Check for cancellation before processing each op. Throw the error\n\t\t// into the generator so that any finally blocks in the algorithm run\n\t\t// before the error propagates to the caller.\n\t\tif (signal?.aborted === true) {\n\t\t\tconst abortError = new DOMException(\"Aborted\", \"AbortError\");\n\t\t\ttry {\n\t\t\t\tgen.throw(abortError);\n\t\t\t} catch {\n\t\t\t\t// Generator did not handle the error — propagate it\n\t\t\t\tthrow abortError;\n\t\t\t}\n\t\t\t// Generator handled the error but we still honour cancellation\n\t\t\tthrow abortError;\n\t\t}\n\n\t\tconst op = step.value;\n\n\t\t// Handle cooperative yield ops without hitting the graph\n\t\tif (op.tag === \"yield\") {\n\t\t\tawait yieldStrategy();\n\t\t\tstep = gen.next({ tag: \"yield\" });\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Handle progress ops: call the callback (awaiting if async)\n\t\tif (op.tag === \"progress\") {\n\t\t\tif (onProgress !== undefined) {\n\t\t\t\tconst maybePromise = onProgress(op.stats);\n\t\t\t\tif (maybePromise instanceof Promise) {\n\t\t\t\t\tawait maybePromise;\n\t\t\t\t}\n\t\t\t}\n\t\t\tstep = gen.next({ tag: \"progress\" });\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Resolve graph ops, forwarding any errors into the generator\n\t\tlet response: GraphOpResponse<N, E>;\n\t\ttry {\n\t\t\tresponse = await resolveAsyncOp(graph, op);\n\t\t} catch (error) {\n\t\t\t// Forward the error into the generator; if unhandled, it propagates\n\t\t\tstep = gen.throw(error);\n\t\t\tcontinue;\n\t\t}\n\n\t\tstep = gen.next(response);\n\t}\n\n\treturn step.value;\n}\n","/**\n * Type-safe yield helpers for graph operations.\n *\n * Each function is a sub-generator that yields one GraphOp and returns\n * the correctly-typed result. Narrowing is done via the tagged discriminated\n * union in GraphOpResponse — no type assertions needed.\n *\n * Use with `yield*` inside algorithm generators.\n *\n * @module async/ops\n */\n\nimport type { NodeId, NodeData, EdgeData, Direction } from \"../graph\";\nimport type { GraphOp, GraphOpResponse, ProgressStats } from \"./protocol\";\n\nexport function* opNeighbours<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(\n\tid: NodeId,\n\tdirection?: Direction,\n): Generator<GraphOp, readonly NodeId[], GraphOpResponse<N, E>> {\n\tconst op: GraphOp =\n\t\tdirection !== undefined\n\t\t\t? { tag: \"neighbours\", id, direction }\n\t\t\t: { tag: \"neighbours\", id };\n\tconst response: GraphOpResponse<N, E> = yield op;\n\tif (response.tag !== \"neighbours\") {\n\t\tthrow new TypeError(`Expected neighbours response, got ${response.tag}`);\n\t}\n\treturn response.value;\n}\n\nexport function* opDegree<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(\n\tid: NodeId,\n\tdirection?: Direction,\n): Generator<GraphOp, number, GraphOpResponse<N, E>> {\n\tconst op: GraphOp =\n\t\tdirection !== undefined\n\t\t\t? { tag: \"degree\", id, direction }\n\t\t\t: { tag: \"degree\", id };\n\tconst response: GraphOpResponse<N, E> = yield op;\n\tif (response.tag !== \"degree\") {\n\t\tthrow new TypeError(`Expected degree response, got ${response.tag}`);\n\t}\n\treturn response.value;\n}\n\nexport function* opGetNode<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(id: NodeId): Generator<GraphOp, N | undefined, GraphOpResponse<N, E>> {\n\tconst response: GraphOpResponse<N, E> = yield { tag: \"getNode\", id };\n\tif (response.tag !== \"getNode\") {\n\t\tthrow new TypeError(`Expected getNode response, got ${response.tag}`);\n\t}\n\treturn response.value;\n}\n\nexport function* opGetEdge<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(\n\tsource: NodeId,\n\ttarget: NodeId,\n): Generator<GraphOp, E | undefined, GraphOpResponse<N, E>> {\n\tconst response: GraphOpResponse<N, E> = yield {\n\t\ttag: \"getEdge\",\n\t\tsource,\n\t\ttarget,\n\t};\n\tif (response.tag !== \"getEdge\") {\n\t\tthrow new TypeError(`Expected getEdge response, got ${response.tag}`);\n\t}\n\treturn response.value;\n}\n\nexport function* opHasNode<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(id: NodeId): Generator<GraphOp, boolean, GraphOpResponse<N, E>> {\n\tconst response: GraphOpResponse<N, E> = yield { tag: \"hasNode\", id };\n\tif (response.tag !== \"hasNode\") {\n\t\tthrow new TypeError(`Expected hasNode response, got ${response.tag}`);\n\t}\n\treturn response.value;\n}\n\nexport function* opYield<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(): Generator<GraphOp, void, GraphOpResponse<N, E>> {\n\tyield { tag: \"yield\" };\n}\n\nexport function* opProgress<\n\tN extends NodeData = NodeData,\n\tE extends EdgeData = EdgeData,\n>(stats: ProgressStats): Generator<GraphOp, void, GraphOpResponse<N, E>> {\n\tyield { tag: \"progress\", stats };\n}\n"],"mappings":"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"}

package/dist/priority-queue-BIiD1L0k.cjs

@@ -0,0 +1,148 @@
+//#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 = [];
+	indexMap = /* @__PURE__ */ new Map();
+	/**
+	* 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.indexMap.set(item, this.heap.length - 1);
+		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;
+		this.indexMap.delete(root.item);
+		const last = this.heap.pop();
+		if (last === void 0) return root;
+		if (this.heap.length > 0) {
+			this.heap[0] = last;
+			this.indexMap.set(last.item, 0);
+			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. If provided, uses linear search;
+	*                 otherwise uses O(1) reference-based lookup.
+	*/
+	decreaseKey(item, newPriority, equals) {
+		let foundIndex = -1;
+		if (equals !== void 0) 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;
+			}
+		}
+		else foundIndex = this.indexMap.get(item) ?? -1;
+		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;
+			this.indexMap.set(parentEntry.item, current);
+			this.indexMap.set(currentEntry.item, parent);
+			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;
+				this.indexMap.set(finalSmallestEntry.item, current);
+				this.indexMap.set(currentEntry.item, smallest);
+				current = smallest;
+			} else return;
+		}
+	}
+};
+//#endregion
+Object.defineProperty(exports, "PriorityQueue", {
+	enumerable: true,
+	get: function() {
+		return PriorityQueue;
+	}
+});
+
+//# sourceMappingURL=priority-queue-BIiD1L0k.cjs.map

package/dist/priority-queue-BIiD1L0k.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue-BIiD1L0k.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\tprivate indexMap = new Map<T, number>();\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.indexMap.set(item, this.heap.length - 1);\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\tthis.indexMap.delete(root.item);\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.indexMap.set(last.item, 0);\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. If provided, uses linear search;\n\t *                 otherwise uses O(1) reference-based lookup.\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\t// If equals function provided, use linear search for custom equality\n\t\tif (equals !== undefined) {\n\t\t\tfor (let i = 0; i < this.heap.length; i++) {\n\t\t\t\tconst entry = this.heap[i];\n\t\t\t\tif (entry !== undefined && equals(entry.item, item)) {\n\t\t\t\t\tfoundIndex = i;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// Use O(1) reference-based lookup via indexMap\n\t\t\tfoundIndex = this.indexMap.get(item) ?? -1;\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\t// Update indexMap after swap\n\t\t\tthis.indexMap.set(parentEntry.item, current);\n\t\t\tthis.indexMap.set(currentEntry.item, parent);\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\t// Update indexMap after swap\n\t\t\t\tthis.indexMap.set(finalSmallestEntry.item, current);\n\t\t\t\tthis.indexMap.set(currentEntry.item, smallest);\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":"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"}

package/dist/priority-queue-CFDd5cBg.js

@@ -0,0 +1,143 @@
+//#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 = [];
+	indexMap = /* @__PURE__ */ new Map();
+	/**
+	* 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.indexMap.set(item, this.heap.length - 1);
+		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;
+		this.indexMap.delete(root.item);
+		const last = this.heap.pop();
+		if (last === void 0) return root;
+		if (this.heap.length > 0) {
+			this.heap[0] = last;
+			this.indexMap.set(last.item, 0);
+			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. If provided, uses linear search;
+	*                 otherwise uses O(1) reference-based lookup.
+	*/
+	decreaseKey(item, newPriority, equals) {
+		let foundIndex = -1;
+		if (equals !== void 0) 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;
+			}
+		}
+		else foundIndex = this.indexMap.get(item) ?? -1;
+		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;
+			this.indexMap.set(parentEntry.item, current);
+			this.indexMap.set(currentEntry.item, parent);
+			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;
+				this.indexMap.set(finalSmallestEntry.item, current);
+				this.indexMap.set(currentEntry.item, smallest);
+				current = smallest;
+			} else return;
+		}
+	}
+};
+//#endregion
+export { PriorityQueue as t };
+
+//# sourceMappingURL=priority-queue-CFDd5cBg.js.map

package/dist/priority-queue-CFDd5cBg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue-CFDd5cBg.js","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\tprivate indexMap = new Map<T, number>();\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.indexMap.set(item, this.heap.length - 1);\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\tthis.indexMap.delete(root.item);\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.indexMap.set(last.item, 0);\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. If provided, uses linear search;\n\t *                 otherwise uses O(1) reference-based lookup.\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\t// If equals function provided, use linear search for custom equality\n\t\tif (equals !== undefined) {\n\t\t\tfor (let i = 0; i < this.heap.length; i++) {\n\t\t\t\tconst entry = this.heap[i];\n\t\t\t\tif (entry !== undefined && equals(entry.item, item)) {\n\t\t\t\t\tfoundIndex = i;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// Use O(1) reference-based lookup via indexMap\n\t\t\tfoundIndex = this.indexMap.get(item) ?? -1;\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\t// Update indexMap after swap\n\t\t\tthis.indexMap.set(parentEntry.item, current);\n\t\t\tthis.indexMap.set(currentEntry.item, parent);\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\t// Update indexMap after swap\n\t\t\t\tthis.indexMap.set(finalSmallestEntry.item, current);\n\t\t\t\tthis.indexMap.set(currentEntry.item, smallest);\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":"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"}

package/dist/ranking/index.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_jaccard = require("../jaccard-Bys9_dGW.cjs");
+const require_ranking = require("../ranking-DVvajgUZ.cjs");
+const require_ranking_mi = require("./mi/index.cjs");
+exports.adamicAdar = require_ranking_mi.adamicAdar;
+exports.adamicAdarAsync = require_ranking_mi.adamicAdarAsync;
+exports.adaptive = require_ranking_mi.adaptive;
+exports.adaptiveAsync = require_ranking_mi.adaptiveAsync;
+exports.betweenness = require_ranking.betweenness;
+exports.communicability = require_ranking.communicability;
+exports.cosine = require_ranking_mi.cosine;
+exports.cosineAsync = require_ranking_mi.cosineAsync;
+exports.degreeSum = require_ranking.degreeSum;
+exports.etch = require_ranking_mi.etch;
+exports.etchAsync = require_ranking_mi.etchAsync;
+exports.hittingTime = require_ranking.hittingTime;
+exports.hubPromoted = require_ranking_mi.hubPromoted;
+exports.hubPromotedAsync = require_ranking_mi.hubPromotedAsync;
+exports.jaccard = require_jaccard.jaccard;
+exports.jaccardArithmetic = require_ranking.jaccardArithmetic;
+exports.jaccardAsync = require_jaccard.jaccardAsync;
+exports.katz = require_ranking.katz;
+exports.notch = require_ranking_mi.notch;
+exports.notchAsync = require_ranking_mi.notchAsync;
+exports.overlapCoefficient = require_ranking_mi.overlapCoefficient;
+exports.overlapCoefficientAsync = require_ranking_mi.overlapCoefficientAsync;
+exports.pagerank = require_ranking.pagerank;
+exports.parse = require_ranking.parse;
+exports.parseAsync = require_ranking.parseAsync;
+exports.randomRanking = require_ranking.randomRanking;
+exports.resistanceDistance = require_ranking.resistanceDistance;
+exports.resourceAllocation = require_ranking_mi.resourceAllocation;
+exports.resourceAllocationAsync = require_ranking_mi.resourceAllocationAsync;
+exports.scale = require_ranking_mi.scale;
+exports.scaleAsync = require_ranking_mi.scaleAsync;
+exports.shortest = require_ranking.shortest;
+exports.skew = require_ranking_mi.skew;
+exports.skewAsync = require_ranking_mi.skewAsync;
+exports.sorensen = require_ranking_mi.sorensen;
+exports.sorensenAsync = require_ranking_mi.sorensenAsync;
+exports.span = require_ranking_mi.span;
+exports.spanAsync = require_ranking_mi.spanAsync;
+exports.widestPath = require_ranking.widestPath;

package/dist/ranking/index.js

@@ -0,0 +1,4 @@
+import { n as jaccardAsync, t as jaccard } from "../jaccard-3rCdilwm.js";
+import { a as katz, c as jaccardArithmetic, d as shortest, f as parse, i as communicability, l as widestPath, n as randomRanking, o as betweenness, p as parseAsync, r as resistanceDistance, s as pagerank, t as hittingTime, u as degreeSum } from "../ranking-3ez5m67U.js";
+import { adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, cosine, cosineAsync, etch, etchAsync, hubPromoted, hubPromotedAsync, notch, notchAsync, overlapCoefficient, overlapCoefficientAsync, resourceAllocation, resourceAllocationAsync, scale, scaleAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync } from "./mi/index.js";
+export { adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, betweenness, communicability, cosine, cosineAsync, degreeSum, etch, etchAsync, hittingTime, hubPromoted, hubPromotedAsync, jaccard, jaccardArithmetic, jaccardAsync, katz, notch, notchAsync, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, randomRanking, resistanceDistance, resourceAllocation, resourceAllocationAsync, scale, scaleAsync, shortest, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, widestPath };