@graphty/algorithms 1.1.0 → 1.3.1

package/dist/src/algorithms/traversal/bfs.js

@@ -3,187 +3,10 @@
  *
  * Explores graph level by level from a starting node. Guarantees shortest path
  * in unweighted graphs and can be used for various graph analysis tasks.
+ *
+ * Automatically uses optimized implementations for large graphs (>10k nodes)
+ * to provide the best performance without requiring manual configuration.
  */
-/**
- * Perform breadth-first search starting from a given node
- */
-export function breadthFirstSearch(graph, startNode, options = {}) {
-    if (!graph.hasNode(startNode)) {
-        throw new Error(`Start node ${String(startNode)} not found in graph`);
-    }
-    const visited = new Set();
-    const queue = [];
-    const order = [];
-    const tree = new Map();
-    // Initialize with start node
-    queue.push({ node: startNode, level: 0 });
-    visited.add(startNode);
-    tree.set(startNode, null);
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current) {
-            break;
-        }
-        order.push(current.node);
-        // Call visitor callback if provided
-        if (options.visitCallback) {
-            options.visitCallback(current.node, current.level);
-        }
-        // Early termination if target found
-        if (options.targetNode && current.node === options.targetNode) {
-            break;
-        }
-        // Explore neighbors
-        for (const neighbor of graph.neighbors(current.node)) {
-            if (!visited.has(neighbor)) {
-                visited.add(neighbor);
-                tree.set(neighbor, current.node);
-                queue.push({ node: neighbor, level: current.level + 1 });
-            }
-        }
-    }
-    return { visited, order, tree };
-}
-/**
- * Find shortest path between two nodes in an unweighted graph using BFS
- */
-export function shortestPathBFS(graph, source, target) {
-    if (!graph.hasNode(source)) {
-        throw new Error(`Source node ${String(source)} not found in graph`);
-    }
-    if (!graph.hasNode(target)) {
-        throw new Error(`Target node ${String(target)} not found in graph`);
-    }
-    // Special case: source equals target
-    if (source === target) {
-        return {
-            distance: 0,
-            path: [source],
-            predecessor: new Map([[source, null]]),
-        };
-    }
-    const visited = new Set();
-    const queue = [];
-    const predecessor = new Map();
-    // Initialize BFS
-    queue.push({ node: source, distance: 0 });
-    visited.add(source);
-    predecessor.set(source, null);
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current) {
-            break;
-        }
-        // Target found
-        if (current.node === target) {
-            const path = reconstructPath(target, predecessor);
-            return {
-                distance: current.distance,
-                path,
-                predecessor,
-            };
-        }
-        // Explore neighbors
-        for (const neighbor of graph.neighbors(current.node)) {
-            if (!visited.has(neighbor)) {
-                visited.add(neighbor);
-                predecessor.set(neighbor, current.node);
-                queue.push({ node: neighbor, distance: current.distance + 1 });
-            }
-        }
-    }
-    // No path found
-    return null;
-}
-/**
- * Find shortest paths from source to all reachable nodes using BFS
- */
-export function singleSourceShortestPathBFS(graph, source) {
-    if (!graph.hasNode(source)) {
-        throw new Error(`Source node ${String(source)} not found in graph`);
-    }
-    const results = new Map();
-    const visited = new Set();
-    const queue = [];
-    const predecessor = new Map();
-    // Initialize BFS
-    queue.push({ node: source, distance: 0 });
-    visited.add(source);
-    predecessor.set(source, null);
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current) {
-            break;
-        }
-        // Store result for current node
-        const path = reconstructPath(current.node, predecessor);
-        results.set(current.node, {
-            distance: current.distance,
-            path,
-            predecessor: new Map(predecessor),
-        });
-        // Explore neighbors
-        for (const neighbor of graph.neighbors(current.node)) {
-            if (!visited.has(neighbor)) {
-                visited.add(neighbor);
-                predecessor.set(neighbor, current.node);
-                queue.push({ node: neighbor, distance: current.distance + 1 });
-            }
-        }
-    }
-    return results;
-}
-/**
- * Check if the graph is bipartite using BFS coloring
- */
-export function isBipartite(graph) {
-    if (graph.isDirected) {
-        throw new Error("Bipartite test requires an undirected graph");
-    }
-    const color = new Map();
-    const visited = new Set();
-    // Check each connected component
-    for (const node of Array.from(graph.nodes())) {
-        if (!visited.has(node.id)) {
-            const queue = [node.id];
-            color.set(node.id, 0);
-            visited.add(node.id);
-            while (queue.length > 0) {
-                const current = queue.shift();
-                if (!current) {
-                    break;
-                }
-                const currentColor = color.get(current);
-                if (currentColor === undefined) {
-                    continue;
-                }
-                for (const neighbor of Array.from(graph.neighbors(current))) {
-                    if (!visited.has(neighbor)) {
-                        // Color with opposite color
-                        color.set(neighbor, currentColor === 0 ? 1 : 0);
-                        visited.add(neighbor);
-                        queue.push(neighbor);
-                    }
-                    else if (color.get(neighbor) === currentColor) {
-                        // Same color as current node - not bipartite
-                        return false;
-                    }
-                }
-            }
-        }
-    }
-    return true;
-}
-/**
- * Reconstruct path from predecessor map
- */
-function reconstructPath(target, predecessor) {
-    const path = [];
-    let current = target;
-    while (current !== null) {
-        path.unshift(current);
-        current = predecessor.get(current) ?? null;
-    }
-    return path;
-}
+// Re-export unified implementations that automatically optimize for large graphs
+export { breadthFirstSearch, isBipartite, shortestPathBFS, singleSourceShortestPathBFS, } from "./bfs-unified.js";
 //# sourceMappingURL=bfs.js.map

package/dist/src/algorithms/traversal/bfs.js.map

@@ -1 +1 @@
-{"version":3,"file":"bfs.js","sourceRoot":"","sources":["../../../../src/algorithms/traversal/bfs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bfs.js","sourceRoot":"","sources":["../../../../src/algorithms/traversal/bfs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,iFAAiF;AACjF,OAAO,EACH,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,2BAA2B,GAC9B,MAAM,kBAAkB,CAAC"}

package/dist/src/benchmark-all-algorithms.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Comprehensive benchmark suite for ALL 98 algorithms in @graphty/algorithms
+ *
+ * Two modes:
+ * - Full benchmark: Completes in under 1 hour
+ * - Quick benchmark: Completes in under 2 minutes
+ */
+interface BenchmarkResult {
+    algorithm: string;
+    category: string;
+    executionTime: number;
+    success: boolean;
+    error?: string;
+    nodeCount: number;
+    edgeCount: number;
+    mode: "quick" | "full";
+}
+/**
+ * Main benchmark runner
+ */
+export declare function runAllAlgorithmsBenchmark(mode?: "quick" | "full"): BenchmarkResult[];
+export {};
+//# sourceMappingURL=benchmark-all-algorithms.d.ts.map

package/dist/src/benchmark-all-algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark-all-algorithms.d.ts","sourceRoot":"","sources":["../../src/benchmark-all-algorithms.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAKH,UAAU,eAAe;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;CAC1B;AAqGD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,GAAE,OAAO,GAAG,MAAe,GAAG,eAAe,EAAE,CA2D5F"}

package/dist/src/benchmark-all-algorithms.js

@@ -0,0 +1,462 @@
+/* eslint-disable no-console */
+/**
+ * Comprehensive benchmark suite for ALL 98 algorithms in @graphty/algorithms
+ *
+ * Two modes:
+ * - Full benchmark: Completes in under 1 hour
+ * - Quick benchmark: Completes in under 2 minutes
+ */
+import * as algorithms from "./algorithms/index.js";
+import { Graph } from "./core/graph.js";
+const ALGORITHM_CATEGORIES = {
+    traversal: {
+        algorithms: [
+            "breadthFirstSearch",
+            "isBipartite",
+            "shortestPathBFS",
+            "singleSourceShortestPathBFS",
+            "depthFirstSearch",
+            "findStronglyConnectedComponents",
+            "hasCycleDFS",
+            "topologicalSort",
+        ],
+        config: {
+            name: "Traversal",
+            quick: { nodes: 1000, edges: 5000, runs: 3 },
+            full: { nodes: 10000, edges: 50000, runs: 10 },
+        },
+    },
+    shortestPath: {
+        algorithms: [
+            "bellmanFord",
+            "bellmanFordPath",
+            "hasNegativeCycle",
+            "allPairsShortestPath",
+            "dijkstra",
+            "dijkstraPath",
+            "singleSourceShortestPath",
+            "floydWarshall",
+            "floydWarshallPath",
+            "transitiveClosure",
+        ],
+        config: {
+            name: "Shortest Path",
+            quick: { nodes: 100, edges: 500, runs: 1 }, // Smaller for O(V³) algorithms
+            full: { nodes: 500, edges: 2500, runs: 3 },
+        },
+    },
+    centrality: {
+        algorithms: [
+            "betweennessCentrality",
+            "closenessCentrality",
+            "degreeCentrality",
+            "eigenvectorCentrality",
+            "hits",
+            "katzCentrality",
+            "pageRank",
+            "personalizedPageRank",
+        ],
+        config: {
+            name: "Centrality",
+            quick: { nodes: 500, edges: 2500, runs: 1 },
+            full: { nodes: 2000, edges: 10000, runs: 3 },
+        },
+    },
+    components: {
+        algorithms: [
+            "connectedComponents",
+            "connectedComponentsDFS",
+            "stronglyConnectedComponents",
+            "weaklyConnectedComponents",
+            "isConnected",
+            "isStronglyConnected",
+            "isWeaklyConnected",
+            "numberOfConnectedComponents",
+            "largestConnectedComponent",
+            "getConnectedComponent",
+        ],
+        config: {
+            name: "Components",
+            quick: { nodes: 2000, edges: 10000, runs: 3 },
+            full: { nodes: 10000, edges: 50000, runs: 10 },
+        },
+    },
+    mst: {
+        algorithms: ["kruskalMST", "primMST", "minimumSpanningTree"],
+        config: {
+            name: "Minimum Spanning Tree",
+            quick: { nodes: 1000, edges: 5000, runs: 5 },
+            full: { nodes: 5000, edges: 25000, runs: 10 },
+        },
+    },
+    community: {
+        algorithms: ["girvanNewman", "labelPropagation", "leiden", "louvain"],
+        config: {
+            name: "Community Detection",
+            quick: { nodes: 200, edges: 1000, runs: 1 }, // Very expensive algorithms
+            full: { nodes: 1000, edges: 5000, runs: 2 },
+        },
+    },
+    matching: {
+        algorithms: ["bipartitePartition", "greedyBipartiteMatching", "maximumBipartiteMatching"],
+        config: {
+            name: "Matching",
+            quick: { nodes: 500, edges: 1000, runs: 3 },
+            full: { nodes: 2000, edges: 4000, runs: 5 },
+        },
+    },
+};
+/**
+ * Main benchmark runner
+ */
+export function runAllAlgorithmsBenchmark(mode = "full") {
+    const startTime = Date.now();
+    const timeLimit = mode === "quick" ? 2 * 60 * 1000 : 60 * 60 * 1000; // 2 min or 1 hour
+    console.log(`🚀 ${mode === "quick" ? "Quick" : "Comprehensive"} Benchmark - All ${String(getTotalAlgorithmCount())} Algorithms`);
+    console.log(`=${"=".repeat(60)}`);
+    console.log(`Time limit: ${mode === "quick" ? "2 minutes" : "1 hour"}`);
+    console.log(`Start time: ${new Date().toLocaleTimeString()}\n`);
+    const results = [];
+    let totalTested = 0;
+    let totalPassed = 0;
+    for (const [categoryKey, categoryData] of Object.entries(ALGORITHM_CATEGORIES)) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed > timeLimit) {
+            console.log("⏰ Time limit reached, stopping benchmark");
+            break;
+        }
+        console.log(`\n📊 ${categoryData.config.name} Algorithms`);
+        console.log("-".repeat(categoryData.config.name.length + 12));
+        const config = categoryData.config[mode];
+        const graph = createTestGraph(config.nodes, config.edges, categoryKey);
+        for (const algoName of categoryData.algorithms) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed > timeLimit) {
+                console.log(`⏰ Time limit reached in category ${categoryData.config.name}`);
+                break;
+            }
+            const result = benchmarkAlgorithm(algoName, categoryData.config.name, graph, config.runs, mode);
+            results.push(result);
+            totalTested++;
+            if (result.success) {
+                totalPassed++;
+                console.log(`  ✅ ${algoName}: ${result.executionTime.toFixed(2)}ms`);
+            }
+            else {
+                console.log(`  ❌ ${algoName}: ${result.error?.substring(0, 50) ?? "Failed"}`);
+            }
+        }
+    }
+    const totalTime = (Date.now() - startTime) / 1000;
+    console.log("\n📈 Benchmark Complete");
+    console.log("===================");
+    console.log(`Total time: ${totalTime.toFixed(1)}s`);
+    console.log(`Algorithms tested: ${String(totalTested)}`);
+    console.log(`Success rate: ${String(totalPassed)}/${String(totalTested)} (${(totalPassed / totalTested * 100).toFixed(1)}%)`);
+    if (mode === "full") {
+        displayDetailedResults(results);
+    }
+    return results;
+}
+/**
+ * Benchmark a single algorithm
+ */
+function benchmarkAlgorithm(algoName, category, graph, runs, mode) {
+    const algo = algorithms[algoName];
+    if (!algo || typeof algo !== "function") {
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: 0,
+            success: false,
+            error: "Algorithm not found or not a function",
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    }
+    try {
+        const times = [];
+        for (let i = 0; i < runs; i++) {
+            const args = getAlgorithmArgs(algoName, graph);
+            const start = performance.now();
+            algo(...args);
+            const time = performance.now() - start;
+            times.push(time);
+        }
+        // Use median time to avoid outliers
+        times.sort((a, b) => a - b);
+        const medianTime = times[Math.floor(times.length / 2)] ?? 0;
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: medianTime,
+            success: true,
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    }
+    catch (error) {
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: 0,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    }
+}
+/**
+ * Get appropriate arguments for each algorithm
+ */
+function getAlgorithmArgs(algoName, graph) {
+    // Get random nodes for algorithms that need them
+    const nodes = Array.from(graph.nodes()).map((n) => n.id);
+    const randomNode = nodes[Math.floor(Math.random() * nodes.length)];
+    const randomNode2 = nodes[Math.floor(Math.random() * nodes.length)];
+    // Algorithm-specific argument mapping
+    switch (algoName) {
+        // Single source algorithms
+        case "breadthFirstSearch":
+        case "depthFirstSearch":
+        case "singleSourceShortestPathBFS":
+        case "singleSourceShortestPath":
+        case "dijkstra":
+        case "bellmanFord":
+            return [graph, randomNode];
+        // PageRank algorithms need directed graph
+        case "pageRank": {
+            const directedForPR = createDirectedGraph(graph);
+            return [directedForPR];
+        }
+        case "personalizedPageRank": {
+            const directedForPPR = createDirectedGraph(graph);
+            const personalNodes = [randomNode]; // Array of nodes for personalization
+            return [directedForPPR, personalNodes];
+        }
+        // Two node algorithms
+        case "shortestPathBFS":
+        case "dijkstraPath":
+        case "bellmanFordPath":
+            return [graph, randomNode, randomNode2];
+        // Component-specific algorithms
+        case "getConnectedComponent":
+            return [graph, randomNode];
+        // Algorithms that need specific graph types
+        case "topologicalSort":
+        case "findStronglyConnectedComponents":
+        case "stronglyConnectedComponents":
+        case "weaklyConnectedComponents":
+        case "isStronglyConnected":
+        case "isWeaklyConnected": {
+            // Create a directed version of the graph for these algorithms
+            const directedGraph = createDirectedGraph(graph);
+            return [directedGraph];
+        }
+        // Bipartite algorithms need bipartite graphs
+        case "bipartitePartition":
+        case "greedyBipartiteMatching":
+        case "maximumBipartiteMatching": {
+            const bipartiteGraph = createBipartiteGraph(Math.floor(graph.nodeCount / 2));
+            return [bipartiteGraph];
+        }
+        // Community detection algorithms
+        case "labelPropagation":
+        case "leiden":
+        case "louvain":
+        case "girvanNewman":
+            return [graph, {}]; // Pass empty options
+        // Default: just the graph
+        default:
+            return [graph];
+    }
+}
+/**
+ * Create test graph appropriate for each algorithm category
+ */
+function createTestGraph(nodes, edges, category) {
+    const graph = new Graph();
+    // Add nodes
+    for (let i = 0; i < nodes; i++) {
+        graph.addNode(i);
+    }
+    // Create different graph structures for different algorithm categories
+    switch (category) {
+        case "shortestPath":
+            // Sparse connected graph for shortest path algorithms
+            createConnectedGraph(graph, Math.min(edges, nodes * 3));
+            break;
+        case "centrality":
+            // Small-world graph good for centrality analysis
+            createSmallWorldGraph(graph, Math.floor(edges / nodes));
+            break;
+        case "community":
+            // Graph with community structure
+            createCommunityGraph(graph, edges);
+            break;
+        default:
+            // Random connected graph
+            createConnectedGraph(graph, edges);
+    }
+    return graph;
+}
+/**
+ * Create a connected random graph
+ */
+function createConnectedGraph(graph, targetEdges) {
+    const nodes = graph.nodeCount;
+    // First create a spanning tree to ensure connectivity
+    for (let i = 1; i < nodes; i++) {
+        const parent = Math.floor(Math.random() * i);
+        graph.addEdge(parent, i);
+    }
+    // Add remaining edges randomly
+    let edgesAdded = nodes - 1;
+    while (edgesAdded < targetEdges) {
+        const source = Math.floor(Math.random() * nodes);
+        const target = Math.floor(Math.random() * nodes);
+        if (source !== target && !graph.hasEdge(source, target)) {
+            graph.addEdge(source, target);
+            edgesAdded++;
+        }
+    }
+}
+/**
+ * Create small-world graph (Watts-Strogatz model)
+ */
+function createSmallWorldGraph(graph, avgDegree) {
+    const nodes = graph.nodeCount;
+    const k = Math.floor(avgDegree / 2);
+    // Ring lattice
+    for (let i = 0; i < nodes; i++) {
+        for (let j = 1; j <= k; j++) {
+            const target = (i + j) % nodes;
+            graph.addEdge(i, target);
+        }
+    }
+    // Rewire some edges
+    const rewireProb = 0.1;
+    for (let i = 0; i < nodes; i++) {
+        for (let j = 1; j <= k; j++) {
+            if (Math.random() < rewireProb) {
+                const oldTarget = (i + j) % nodes;
+                const newTarget = Math.floor(Math.random() * nodes);
+                if (newTarget !== i && !graph.hasEdge(i, newTarget)) {
+                    graph.removeEdge(i, oldTarget);
+                    graph.addEdge(i, newTarget);
+                }
+            }
+        }
+    }
+}
+/**
+ * Create graph with community structure
+ */
+function createCommunityGraph(graph, targetEdges) {
+    const nodes = graph.nodeCount;
+    const communities = Math.min(5, Math.floor(nodes / 20)); // 5 communities max
+    const communitySize = Math.floor(nodes / communities);
+    let edgesAdded = 0;
+    // Create dense connections within communities
+    for (let c = 0; c < communities; c++) {
+        const start = c * communitySize;
+        const end = Math.min((c + 1) * communitySize, nodes);
+        for (let i = start; i < end && edgesAdded < targetEdges; i++) {
+            for (let j = i + 1; j < end && edgesAdded < targetEdges; j++) {
+                if (Math.random() < 0.8) { // High probability within community
+                    graph.addEdge(i, j);
+                    edgesAdded++;
+                }
+            }
+        }
+    }
+    // Add sparse connections between communities
+    while (edgesAdded < targetEdges) {
+        const source = Math.floor(Math.random() * nodes);
+        const target = Math.floor(Math.random() * nodes);
+        if (source !== target && !graph.hasEdge(source, target)) {
+            graph.addEdge(source, target);
+            edgesAdded++;
+        }
+    }
+}
+/**
+ * Create directed version of graph
+ */
+function createDirectedGraph(undirectedGraph) {
+    const directedGraph = new Graph({ directed: true });
+    // Copy nodes
+    for (const node of undirectedGraph.nodes()) {
+        directedGraph.addNode(node.id);
+    }
+    // Copy edges as directed
+    for (const edge of undirectedGraph.edges()) {
+        directedGraph.addEdge(edge.source, edge.target);
+    }
+    return directedGraph;
+}
+/**
+ * Create bipartite graph
+ */
+function createBipartiteGraph(nodesPerPartition) {
+    const graph = new Graph();
+    // Add nodes (0 to n-1 in first partition, n to 2n-1 in second)
+    for (let i = 0; i < nodesPerPartition * 2; i++) {
+        graph.addNode(i);
+    }
+    // Add edges only between partitions
+    for (let i = 0; i < nodesPerPartition; i++) {
+        for (let j = nodesPerPartition; j < nodesPerPartition * 2; j++) {
+            if (Math.random() < 0.3) { // Sparse bipartite graph
+                graph.addEdge(i, j);
+            }
+        }
+    }
+    return graph;
+}
+/**
+ * Get total algorithm count
+ */
+function getTotalAlgorithmCount() {
+    return Object.values(ALGORITHM_CATEGORIES).reduce((total, category) => total + category.algorithms.length, 0);
+}
+/**
+ * Display detailed results for full benchmark
+ */
+function displayDetailedResults(results) {
+    console.log("\n📊 Detailed Results");
+    console.log("==================");
+    const categories = new Map();
+    for (const result of results) {
+        if (!categories.has(result.category)) {
+            categories.set(result.category, []);
+        }
+        categories.get(result.category)?.push(result);
+    }
+    for (const [category, categoryResults] of categories) {
+        console.log(`\n${category}:`);
+        console.log("-".repeat(category.length + 1));
+        const successful = categoryResults.filter((r) => r.success);
+        const failed = categoryResults.filter((r) => !r.success);
+        if (successful.length > 0) {
+            const avgTime = successful.reduce((sum, r) => sum + r.executionTime, 0) / successful.length;
+            console.log(`  Average time: ${avgTime.toFixed(2)}ms`);
+            const minTime = Math.min(...successful.map((r) => r.executionTime));
+            const maxTime = Math.max(...successful.map((r) => r.executionTime));
+            console.log(`  Range: ${minTime.toFixed(2)}ms - ${maxTime.toFixed(2)}ms`);
+        }
+        if (failed.length > 0) {
+            console.log(`  Failed algorithms: ${failed.map((r) => r.algorithm).join(", ")}`);
+        }
+    }
+}
+// Run benchmark if called directly
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1] ?? ""}`) {
+    const mode = process.argv.includes("--quick") ? "quick" : "full";
+    runAllAlgorithmsBenchmark(mode);
+}
+//# sourceMappingURL=benchmark-all-algorithms.js.map