tree-set-typed 2.3.0

package/dist/types/data-structures/tree/tree.d.ts

@@ -0,0 +1,62 @@
+export declare class TreeNode<V = any> {
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
+    constructor(key: string, value?: V, children?: TreeNode<V>[]);
+    protected _key: string;
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key(): string;
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value: string);
+    protected _value?: V | undefined;
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): V | undefined;
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value: V | undefined);
+    protected _children?: TreeNode<V>[] | undefined;
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children(): TreeNode<V>[] | undefined;
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value: TreeNode<V>[] | undefined);
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
+    addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
+    getHeight(): number;
+}

package/dist/types/data-structures/trie/index.d.ts

@@ -0,0 +1 @@
+export * from './trie';

package/dist/types/data-structures/trie/trie.d.ts

@@ -0,0 +1,412 @@
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback, TrieOptions } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * Node used by Trie to store one character and its children.
+ * @remarks Time O(1), Space O(1)
+ */
+export declare class TrieNode {
+    /**
+     * Create a Trie node with a character key.
+     * @remarks Time O(1), Space O(1)
+     * @returns New TrieNode instance.
+     */
+    constructor(key: string);
+    protected _key: string;
+    /**
+     * Get the character key of this node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Character key string.
+     */
+    get key(): string;
+    /**
+     * Set the character key of this node.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New character key.
+     * @returns void
+     */
+    set key(value: string);
+    protected _children: Map<string, TrieNode>;
+    /**
+     * Get the child map of this node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Map from character to child node.
+     */
+    get children(): Map<string, TrieNode>;
+    /**
+     * Replace the child map of this node.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New map of character → node.
+     * @returns void
+     */
+    set children(value: Map<string, TrieNode>);
+    protected _isEnd: boolean;
+    /**
+     * Check whether this node marks the end of a word.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if this node ends a word.
+     */
+    get isEnd(): boolean;
+    /**
+     * Mark this node as the end of a word or not.
+     * @remarks Time O(1), Space O(1)
+     * @param value - Whether this node ends a word.
+     * @returns void
+     */
+    set isEnd(value: boolean);
+}
+/**
+ * Prefix tree (Trie) for fast prefix queries and word storage.
+ * @remarks Time O(1), Space O(1)
+ * @template R
+ * 1. Node Structure: Each node in a Trie represents a string (or a part of a string). The root node typically represents an empty string.
+ * 2. Child Node Relationship: Each node's children represent the strings that can be formed by adding one character to the string at the current node. For example, if a node represents the string 'ca', one of its children might represent 'cat'.
+ * 3. Fast Retrieval: Trie allows retrieval in O(m) time complexity, where m is the length of the string to be searched.
+ * 4. Space Efficiency: Trie can store a large number of strings very space-efficiently, especially when these strings share common prefixes.
+ * 5. Autocomplete and Prediction: Trie can be used for implementing autocomplete and word prediction features, as it can quickly find all strings with a common prefix.
+ * 6. Sorting: Trie can be used to sort a set of strings in alphabetical order.
+ * 7. String Retrieval: For example, searching for a specific string in a large set of strings.
+ * 8. Autocomplete: Providing recommended words or phrases as a user types.
+ * 9. Spell Check: Checking the spelling of words.
+ * 10. IP Routing: Used in certain types of IP routing algorithms.
+ * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
+ * @example
+ * // basic Trie creation and add words
+ *  // Create a simple Trie with initial words
+ *     const trie = new Trie(['apple', 'app', 'apply']);
+ *
+ *     // Verify size
+ *     console.log(trie.size); // 3;
+ *
+ *     // Check if words exist
+ *     console.log(trie.has('apple')); // true;
+ *     console.log(trie.has('app')); // true;
+ *
+ *     // Add a new word
+ *     trie.add('application');
+ *     console.log(trie.size); // 4;
+ * @example
+ * // Trie getWords and prefix search
+ *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
+ *
+ *     // Get all words with prefix 'app'
+ *     const appWords = trie.getWords('app');
+ *     console.log(appWords); // contains 'app';
+ *     console.log(appWords); // contains 'apple';
+ *     console.log(appWords); // contains 'apply';
+ *     console.log(appWords); // contains 'application';
+ *     expect(appWords).not.toContain('apricot');
+ * @example
+ * // Trie isPrefix and isAbsolutePrefix checks
+ *  const trie = new Trie(['tree', 'trial', 'trick', 'trip', 'trie']);
+ *
+ *     // Check if string is a prefix of any word
+ *     console.log(trie.hasPrefix('tri')); // true;
+ *     console.log(trie.hasPrefix('tr')); // true;
+ *     console.log(trie.hasPrefix('xyz')); // false;
+ *
+ *     // Check if string is an absolute prefix (not a complete word)
+ *     console.log(trie.hasPurePrefix('tri')); // true;
+ *     console.log(trie.hasPurePrefix('tree')); // false; // 'tree' is a complete word
+ *
+ *     // Verify size
+ *     console.log(trie.size); // 5;
+ * @example
+ * // Trie delete and iteration
+ *  const trie = new Trie(['car', 'card', 'care', 'careful', 'can', 'cat']);
+ *
+ *     // Delete a word
+ *     trie.delete('card');
+ *     console.log(trie.has('card')); // false;
+ *
+ *     // Word with same prefix still exists
+ *     console.log(trie.has('care')); // true;
+ *
+ *     // Size decreased
+ *     console.log(trie.size); // 5;
+ *
+ *     // Iterate through all words
+ *     const allWords = [...trie];
+ *     console.log(allWords.length); // 5;
+ * @example
+ * // Trie for autocomplete search index
+ *  // Trie is perfect for autocomplete: O(m + k) where m is prefix length, k is results
+ *     const searchIndex = new Trie(['typescript', 'javascript', 'python', 'java', 'rust', 'ruby', 'golang', 'kotlin']);
+ *
+ *     // User types 'j' - get all suggestions
+ *     const jResults = searchIndex.getWords('j');
+ *     console.log(jResults); // contains 'javascript';
+ *     console.log(jResults); // contains 'java';
+ *     console.log(jResults.length); // 2;
+ *
+ *     // User types 'ja' - get more specific suggestions
+ *     const jaResults = searchIndex.getWords('ja');
+ *     console.log(jaResults); // contains 'javascript';
+ *     console.log(jaResults); // contains 'java';
+ *     console.log(jaResults.length); // 2;
+ *
+ *     // User types 'jav' - even more specific
+ *     const javResults = searchIndex.getWords('jav');
+ *     console.log(javResults); // contains 'javascript';
+ *     console.log(javResults); // contains 'java';
+ *     console.log(javResults.length); // 2;
+ *
+ *     // Check for common prefix
+ *
+ *     console.log(searchIndex.hasCommonPrefix('ja')); // false; // Not all words start with 'ja'
+ *
+ *     // Total words in index
+ *     console.log(searchIndex.size); // 8;
+ *
+ *     // Get height (depth of tree)
+ *     const height = searchIndex.getHeight();
+ *     console.log(typeof height); // 'number';
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *  // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     dictionary.add('JavaScript');
+ *
+ *     // Test lookups with different casings
+ *     console.log(dictionary.has('hello')); // true;
+ *     console.log(dictionary.has('HELLO')); // true;
+ *     console.log(dictionary.has('Hello')); // true;
+ *     console.log(dictionary.has('javascript')); // true;
+ *     console.log(dictionary.has('JAVASCRIPT')); // true;
+ * @example
+ * // File System Path Operations
+ *  const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/';
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt'];
+ * @example
+ * // IP Address Routing Table
+ *  // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
+ *
+ *     // Check IP address prefix matching
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true;
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true;
+ *
+ *     // Validate IP address belongs to subnet
+ *     const ip = '192.168.1.100';
+ *     const subnet = ip.split('.').slice(0, 3).join('.');
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true;
+ */
+export declare class Trie<R = any> extends IterableElementBase<string, R> {
+    /**
+     * Create a Trie and optionally bulk-insert words.
+     * @remarks Time O(totalChars), Space O(totalChars)
+     * @param [words] - Iterable of strings (or raw records if toElementFn is provided).
+     * @param [options] - Options such as toElementFn and caseSensitive.
+     * @returns New Trie instance.
+     */
+    constructor(words?: Iterable<string> | Iterable<R>, options?: TrieOptions<R>);
+    protected _size: number;
+    /**
+     * Get the number of stored words.
+     * @remarks Time O(1), Space O(1)
+     * @returns Word count.
+     */
+    get size(): number;
+    protected _caseSensitive: boolean;
+    /**
+     * Get whether comparisons are case-sensitive.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if case-sensitive.
+     */
+    get caseSensitive(): boolean;
+    protected _root: TrieNode;
+    /**
+     * Get the root node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Root TrieNode.
+     */
+    get root(): TrieNode;
+    /**
+     * (Protected) Get total count for base class iteration.
+     * @remarks Time O(1), Space O(1)
+     * @returns Total number of elements.
+     */
+    protected get _total(): number;
+    /**
+     * Insert one word into the trie.
+     * @remarks Time O(L), Space O(L)
+     * @param word - Word to insert.
+     * @returns True if the word was newly added.
+     */
+    add(word: string): boolean;
+    /**
+     * Insert many words from an iterable.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param words - Iterable of strings (or raw records if toElementFn is provided).
+     * @returns Array of per-word 'added' flags.
+     */
+    addMany(words: Iterable<string> | Iterable<R>): boolean[];
+    /**
+     * Check whether a word exists.
+     * @remarks Time O(L), Space O(1)
+     * @param word - Word to search for.
+     * @returns True if present.
+     */
+    has(word: string): boolean;
+    /**
+     * Check whether the trie is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if size is 0.
+     */
+    isEmpty(): boolean;
+    /**
+     * Remove all words and reset to a fresh root.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear(): void;
+    /**
+     * Delete one word if present.
+     * @remarks Time O(L), Space O(1)
+     * @param word - Word to delete.
+     * @returns True if a word was removed.
+     */
+    delete(word: string): boolean;
+    /**
+     * Compute the height (max depth) of the trie.
+     * @remarks Time O(N), Space O(H)
+     * @returns Maximum depth from root to a leaf.
+     */
+    getHeight(): number;
+    /**
+     * Check whether input is a proper prefix of at least one word.
+     * @remarks Time O(L), Space O(1)
+     * @param input - String to test as prefix.
+     * @returns True if input is a prefix but not a full word.
+     */
+    hasPurePrefix(input: string): boolean;
+    /**
+     * Check whether any word starts with input.
+     * @remarks Time O(L), Space O(1)
+     * @param input - String to test as prefix.
+     * @returns True if input matches a path from root.
+     */
+    hasPrefix(input: string): boolean;
+    /**
+     * Check whether the trie’s longest common prefix equals input.
+     * @remarks Time O(min(H,L)), Space O(1)
+     * @param input - Candidate longest common prefix.
+     * @returns True if input equals the common prefix.
+     */
+    hasCommonPrefix(input: string): boolean;
+    /**
+     * Return the longest common prefix among all words.
+     * @remarks Time O(H), Space O(1)
+     * @returns The longest common prefix string.
+     */
+    getLongestCommonPrefix(): string;
+    /**
+     * Collect words under a prefix up to a maximum count.
+     * @remarks Time O(K·L), Space O(K·L)
+     * @param [prefix] - Prefix to match; default empty string for root.
+     * @param [max] - Maximum number of words to return; default is Number.MAX_SAFE_INTEGER.
+     * @param [isAllWhenEmptyPrefix] - When true, collect from root even if prefix is empty.
+     * @returns Array of collected words (at most max).
+     */
+    getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    /**
+     * Deep clone this trie by iterating and inserting all words.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @returns A new trie with the same words and options.
+     */
+    clone(): this;
+    /**
+     * Filter words into a new trie of the same class.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param predicate - Predicate (word, index, trie) → boolean to keep word.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new trie containing words that satisfy the predicate.
+     */
+    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): this;
+    map<RM>(callback: ElementCallback<string, R, string>, options?: TrieOptions<RM>, thisArg?: any): Trie<RM>;
+    /**
+     * Map words into a new trie (possibly different record type).
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (word, index, trie) → newWord (string).
+     * @param [options] - Options for the output trie (e.g., toElementFn, caseSensitive).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Trie constructed from mapped words.
+     */
+    map<EM, RM>(callback: ElementCallback<string, R, EM>, options?: TrieOptions<RM>, thisArg?: any): IterableElementBase<EM, RM>;
+    /**
+     * Map words into a new trie of the same element type.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @param callback - Mapping function (word, index, trie) → string.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new trie with mapped words.
+     */
+    mapSame(callback: ElementCallback<string, R, string>, thisArg?: any): this;
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind trie instance.
+     */
+    protected _createInstance(options?: TrieOptions<R>): this;
+    /**
+     * (Protected) Create a like-kind trie and seed it from an iterable.
+     * @remarks Time O(ΣL), Space O(ΣL)
+     * @template RM
+     * @param [elements] - Iterable used to seed the new trie.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Trie instance.
+     */
+    protected _createLike<RM>(elements?: Iterable<string> | Iterable<RM>, options?: TrieOptions<RM>): Trie<RM>;
+    /**
+     * (Protected) Spawn an empty like-kind trie instance.
+     * @remarks Time O(1), Space O(1)
+     * @template RM
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind Trie instance.
+     */
+    protected _spawnLike<RM>(options?: TrieOptions<RM>): Trie<RM>;
+    /**
+     * (Protected) Iterate all words in lexicographic order of edges.
+     * @remarks Time O(ΣL), Space O(H)
+     * @returns Iterator of words.
+     */
+    protected _getIterator(): IterableIterator<string>;
+    /**
+     * (Protected) Normalize a string according to case sensitivity.
+     * @remarks Time O(L), Space O(L)
+     * @param str - Input string to normalize.
+     * @returns Normalized string based on caseSensitive.
+     */
+    protected _caseProcess(str: string): string;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @packageDocumentation
+ * @module tree-set-typed
+ *
+ * TreeSet - A sorted set implementation based on Red-Black Tree
+ *
+ * @example
+ * ```typescript
+ * import { TreeSet } from 'tree-set-typed';
+ *
+ * const set = new TreeSet<number>();
+ * set.add(5);
+ * set.add(3);
+ * set.add(7);
+ *
+ * console.log([...set]); // [3, 5, 7] - always sorted
+ * console.log(set.has(5)); // true
+ * console.log(set.first()); // 3
+ * console.log(set.last()); // 7
+ * ```
+ */
+export { TreeSet } from 'data-structure-typed';
+export type { TreeSetOptions } from 'data-structure-typed';

package/dist/types/interfaces/binary-tree.d.ts

@@ -0,0 +1,60 @@
+import { BinaryTreeNode } from '../data-structures';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BTNRep, DFSOrderPattern, EntryCallback, IterationType, NodeCallback, NodePredicate, OptNodeOrNull, ReduceEntryCallback, ToEntryFn } from '../types';
+/**
+ * Public, implementation-agnostic binary tree API.
+ * K = key, V = value, R = raw/record used with toEntryFn (optional).
+ * Transforming methods like `map` use method-level generics MK/MV/MR.
+ */
+export interface IBinaryTree<K = any, V = any, R = any> {
+    readonly size: number;
+    readonly root: BinaryTreeNode<K, V> | null | undefined;
+    readonly isMapMode: boolean;
+    iterationType: IterationType;
+    readonly NIL: BinaryTreeNode<K, V>;
+    readonly store: Map<K, V | undefined>;
+    readonly toEntryFn?: ToEntryFn<K, V, R>;
+    readonly isDuplicate: boolean;
+    createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+    createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
+    add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
+    set(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
+    addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
+    delete(keyNodeEntryRawOrPredicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
+    clear(): void;
+    isEmpty(): boolean;
+    get(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): V | undefined;
+    has(keyNodeEntryOrPredicate?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
+    hasValue(value: V): boolean;
+    find(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): [K, V | undefined] | undefined;
+    [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
+    entries(): IterableIterator<[K, V | undefined]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V | undefined>;
+    forEach(callbackfn: EntryCallback<K, V | undefined, void>, thisArg?: unknown): void;
+    every(callbackfn: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): boolean;
+    some(callbackfn: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): boolean;
+    reduce<U>(reducer: ReduceEntryCallback<K, V | undefined, U>, initialValue: U): U;
+    getNode(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): OptNodeOrNull<BinaryTreeNode<K, V>>;
+    getLeftMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
+    getRightMost<C extends NodeCallback<BinaryTreeNode<K, V> | undefined>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>;
+    dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
+    bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    morris<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, pattern?: DFSOrderPattern, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): ReturnType<C>[];
+    leaves<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    getPathToRoot<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, callback?: C, isReverse?: boolean): ReturnType<C>[];
+    getDepth(dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): number;
+    getHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
+    getMinHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
+    isPerfectlyBalanced(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
+    isBST(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
+    search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean, callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    clone(): this;
+    filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this;
+    map<MK = K, MV = V, MR = any>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): IBinaryTree<MK, MV, MR>;
+    merge(anotherTree: IBinaryTree<K, V, R>): void;
+    refill(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): void;
+}

package/dist/types/interfaces/doubly-linked-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/interfaces/graph.d.ts

@@ -0,0 +1,21 @@
+import { VertexKey } from '../types';
+export interface IGraph<V, E, VO, EO> {
+    createVertex(key: VertexKey, value?: V): VO;
+    createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
+    getVertex(vertexKey: VertexKey): VO | undefined;
+    hasVertex(vertexOrKey: VO | VertexKey): boolean;
+    addVertex(vertex: VO): boolean;
+    addVertex(key: VertexKey, value?: V): boolean;
+    deleteVertex(vertexOrKey: VO | VertexKey): boolean;
+    deleteEdge(edge: EO): EO | undefined;
+    getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | undefined;
+    degreeOf(vertexOrKey: VO | VertexKey): number;
+    edgeSet(): EO[];
+    edgesOf(vertexOrKey: VO | VertexKey): EO[];
+    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
+    getEndsOfEdge(edge: EO): [VO, VO] | undefined;
+    isEmpty(): boolean;
+    clear(): void;
+    clone(): this;
+    filter(...args: any[]): this;
+}

package/dist/types/interfaces/heap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/interfaces/index.d.ts

@@ -0,0 +1,8 @@
+export * from './graph';
+export * from './binary-tree';
+export * from './doubly-linked-list';
+export * from './heap';
+export * from './navigator';
+export * from './priority-queue';
+export * from './segment-tree';
+export * from './singly-linked-list';

package/dist/types/interfaces/navigator.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/interfaces/priority-queue.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/interfaces/segment-tree.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/interfaces/singly-linked-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/common.d.ts

@@ -0,0 +1,15 @@
+export type CP = 1 | -1 | 0;
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
+export type Comparator<K> = (a: K, b: K) => number;
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
+export type NodeDisplayLayout = [string[], number, number, number];
+export interface IterableWithSize<T> extends Iterable<T> {
+    size: number | ((...args: any[]) => number);
+}
+export interface IterableWithLength<T> extends Iterable<T> {
+    length: number | ((...args: any[]) => number);
+}
+export type OptValue<V> = V | undefined;
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

package/dist/types/types/data-structures/base/base.d.ts

@@ -0,0 +1,13 @@
+import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
+import { LinearBase } from '../../../data-structures/base/linear-base';
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
+export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
+export type ReduceElementCallback<E, R, U = E> = (accumulator: U, value: E, index: number, self: IterableElementBase<E, R>) => U;
+export type ReduceLinearCallback<E, RT = E> = (accumulator: RT, element: E, index: number, original: LinearBase<E>) => RT;
+export type IterableElementBaseOptions<E, R> = {
+    toElementFn?: (rawElement: R) => E;
+};
+export type LinearBaseOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    maxLen?: number;
+};

package/dist/types/types/data-structures/base/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

package/dist/types/types/data-structures/binary-tree/avl-tree-counter.d.ts

@@ -0,0 +1,2 @@
+import { AVLTreeOptions } from './avl-tree';
+export type AVLTreeCounterOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/dist/types/types/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -0,0 +1,2 @@
+import type { AVLTreeOptions } from './avl-tree';
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/dist/types/types/data-structures/binary-tree/avl-tree.d.ts

@@ -0,0 +1,2 @@
+import { BSTOptions } from './bst';
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};