node-trees ==========
Utility helpers for converting JSX/HTML to Takumi node trees and handling resources.
React component for rendering .pen file node trees as SVG
Incrementally merge directories.
Builder for creating a traversal which can traverse node trees in SiteVision.
Binary Search Trees
Parse Figma clipboard paste data and .fig files into structured node trees
Layout algorithms for visualizing hierarchical data.
Creates abstracted node trees by performing logical and sequential reading operations on strings.
A sorted list of key-value pairs in a fast, typed in-memory B+ tree with a powerful API.
unist utility to get the position of a node
Delightful JavaScript Testing.
Broccoli plugin to merge multiple trees into one
Utilities for watching file trees.
Delightful JavaScript Testing.
Different binary search tree implementations, including a self-balancing one (AVL)
hast utility to create trees
unist utility to create a new tree by mapping all nodes
No description provided.
unist utility to create a new trees with a nice syntax
Highlighting system for Lezer parse trees
Incremental Markdown parser that consumes and emits Lezer trees
A super fast, lightweight (roughly **1kb** gzipped) and reactive series of utility functions, used to build HTML node trees and stateful functional components. Can be used either directly via the `h` function, or from transpiled `JSX`.
The Merkle Trees package contains typescript implementations of the various Merkle Trees required by the system.
A Rust library for creating and manipulating PowerPoint (.pptx) files
This crate is designed to be a bunch of tools for interacting with the Steam API.
This crate is designed to be a bunch of tools for interacting with the Steam API.
This crate is designed to be a bunch of tools for interacting with the Steam API.
This crate is designed to be a bunch of tools for interacting with the Steam API.
My data structure homework
A simple binary tree gem with level order, postorder tree traversal
Non intrusive simple node implementation
This Gem eagerly loads trees by indexing the nodes of the tree. The number of queries needed for loading a tree is N, Where N is the number of different models(ActiveRecords) in the tree. Each inner object in the tree have an index node instance that is connecting it to the root. When the root of the tree is loaded, only the objects that are in the tree are fetched(Pruning). The index nodes are created when the root element is saved and stored in the IndexNode model.
This gem is designed for transformation of Ruby source code (eiher in the form of files or strings) to the Ruby nodes (syntax trees) used by Ruby MRI internals. Obtained nodes can be serialized to the platform-dependent binary or ASCII strings and restored and launched from serialized format. Such kind of transformation is irreversible and can be used for source code protection; the similar principle is used by RubyEncoder commercial software.
CallableTree provides a framework for organizing complex logic into a tree of callable nodes. It allows you to chain execution from a root node to leaf nodes based on matching conditions. Key features include multiple traversal strategies: `seekable` (like nested `if`/`case`), `broadcastable` (one-to-many execution), and `composable` (pipelined processing). Supports class-based, builder-style and factory-style definitions.
A self-balancing binary tree optimised for fast access to frequently used nodes. Useful for implementing caches and garbage collection algorithms.
To make it easier to build and manipulate SQL queries, sql_tree can parse an SQL query to represent it as a tree of nodes and can generate an SQL query given a tree as input
Rind is a templating engine that turns HTML (and XML) into node trees and allows you to create custom tags or reuse someone else’s genius. Rind gives web devs tags to work with and provides the same thing to app devs as an object. This project is just getting started so watch out for sharp corners and unfinished rooms.
Nodewrap is Ruby module that provides direct access to Ruby's internal node structure. Originally this started as a proof-of-concept to allow Node objects to be dumped and loaded using Ruby's builtin marshalling mechanism. Methods to dump and load classes and modules are were also added, and with a little work, nodewrap can be used to dump entire class hierarchies from one Ruby process and load them into another.
RubyTree is a Ruby implementation of the generic tree data structure. It provides simple APIs to store named nodes, and to access, modify, and traverse the tree. The data model is node-centric, where nodes in the tree are the primary structural elements. It supports all common tree-traversal methods (pre-order, post-order, and breadth first). RubyTree mixes in the Enumerable and Comparable modules and behaves like a standard Ruby collection (iteration, comparison, etc.). RubyTree also includes a binary tree implementation, which provides in-order node traversal besides the other methods. RubyTree can import from and export to JSON, and supports Ruby’s object marshaling.
Provides a generic tree data structure with ability to store keyed node elements in the tree. The implementation mixes in the Enumerable module.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.