Analyze a graph to find cyclic loops
Simple dependency graph.
Analyize recursive (cyclic) JSON Schema types
Run operations on a graph, maximizing parallelism
Sort items in a graph using a topological sort while resolving cycles with priority groups
Simple path related functions for graphology.
Types for the TypeScript-ESTree AST spec
A dependency free library to create and traverse directed graphs
Snyk dependency graph library
🚇 The JavaScript bundler for React Native.
TypeScript definitions for toposort
Find strongly connected components of a directed graph using [Tarjan's algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm).
A 3D Force-Directed Graph component for A-Frame.
This package contains the core components of kabelsalat:
Fastest, most accurate & effecient user agent string parser, uses Browserscope's research for parsing
Visualize Graphs generated from Skott
JSOG (JavaScript Object Graph) is a simple convention which allows arbitrary object graphs to be represented in JSON. It allows a large, complicated, cyclic object graph to be seriazlied and deserialized to and from JSON.
Declarative dataflow graph construction for @thi.ng/rstream
Analyze TypeScript projects
Microsoft Graph Client Library
Get the graph of dependents in a monorepo
Sort items in a graph using a topological sort while resolving cycles with priority groups
2D force-directed graph rendered on HTML5 canvas
Convert a SVG to multiple image formats (without puppeteer or a headless browser)
Pure Ruby graph algorithms, particularly e.g. Hamiltonian cycles
Build and resolve dependency graphs using topological sort, detect cycles, generate parallel execution batches, query dependencies and dependents, find shortest paths, and extract subgraphs.
Graph data structure supporting directed and undirected modes with adjacency list storage. Includes BFS, DFS, Dijkstra shortest path, topological sort, cycle detection, connected components, minimum spanning tree, maximum flow, graph coloring, bipartiteness checking, strongly connected components, and DOT/JSON serialization.
In computer science, a disjoint-set data structure, also called a union–find data structure or merge–find set, is a data structure that keeps track of a set of elements partitioned into a number of disjoint (non-overlapping) subsets. It provides near-constant-time operations (bounded by the inverse Ackermann function) to add new sets, to merge existing sets, and to determine whether elements are in the same set. In addition to many other uses (see the Applications section), disjoint-sets play a key role in Kruskal's algorithm for finding the minimum spanning tree of a graph. A disjoint-set forest consists of a number of elements each of which stores an id, a parent pointer, and, in efficient algorithms, a value called the "rank". The parent pointers of elements are arranged to form one or more trees, each representing a set. If an element's parent pointer points to no other element, then the element is the root of a tree and is the representative member of its set. A set may consist of only a single element. However, if the element has a parent, the element is part of whatever set is identified by following the chain of parents upwards until a representative element (one without a parent) is reached at the root of the tree. Forests can be represented compactly in memory as arrays in which parents are indicated by their array index. Disjoint-set data structures model the partitioning of a set, for example to keep track of the connected components of an undirected graph. This model can then be used to determine whether two vertices belong to the same component, or whether adding an edge between them would result in a cycle. The Union–Find algorithm is used in high-performance implementations of unification. This data structure is used by the Boost Graph Library to implement its Incremental Connected Components functionality. It is also a key component in implementing Kruskal's algorithm to find the minimum spanning tree of a graph. Note that the implementation as disjoint-set forests doesn't allow the deletion of edges, even without path compression or the rank heuristic. Sharir and Agarwal report connections between the worst-case behavior of disjoint-sets and the length of Davenport–Schinzel sequences, a combinatorial structure from computational geometry.