doubly-linked-list-typed 2.2.7 → 2.2.8

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

@@ -147,7 +147,7 @@ export declare class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K
      * @param [count] - How much to increase the node's count (default 1).
      * @returns True if inserted/updated; false if ignored.
      */
-    add(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
+    set(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
     /**
      * Delete a node (or decrement its count) and rebalance if needed.
      * @remarks Time O(log N), Space O(1)

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

@@ -132,8 +132,8 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      * @returns True if it's a AVLTreeMultiMapNode, false otherwise.
      */
     isNode(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): keyNodeOrEntry is AVLTreeMultiMapNode<K, V>;
-    add(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
-    add(key: K, value: V): boolean;
+    set(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+    set(key: K, value: V): boolean;
     /**
      * Delete a single value from the bucket at a given key. Removes the key if the bucket becomes empty.
      * @remarks Time O(log N), Space O(1)

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

@@ -112,7 +112,7 @@ export declare class AVLTreeNode<K = any, V = any> {
 }
 /**
  * Represents a self-balancing AVL (Adelson-Velsky and Landis) Tree.
- * This tree extends BST and performs rotations on add/delete to maintain balance.
+ * This tree extends BST and performs rotations on set/delete to maintain balance.
  *
  * @template K - The type of the key.
  * @template V - The type of the value.
@@ -145,7 +145,7 @@ export declare class AVLTreeNode<K = any, V = any> {
  *     console.log(tree.size); // 5;
  *
  *     // Add a new element
- *     tree.add(3);
+ *     tree.set(3);
  *     console.log(tree.size); // 6;
  *     console.log([...tree.keys()]); // [1, 2, 3, 5, 8, 9];
  * @example
@@ -208,7 +208,7 @@ export declare class AVLTreeNode<K = any, V = any> {
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Add more universities
- *     universityTree.add(6, { name: 'Oxford', rank: 6, students: 2000 });
+ *     universityTree.set(6, { name: 'Oxford', rank: 6, students: 2000 });
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Delete and verify balance is maintained
@@ -288,9 +288,9 @@ export declare class AVLTreeNode<K = any, V = any> {
 export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements IBinaryTree<K, V, R> {
     /**
      * Creates an instance of AVLTree.
-     * @remarks Time O(N log N) (from `addMany` with balanced add). Space O(N).
+     * @remarks Time O(N log N) (from `setMany` with balanced set). Space O(N).
      *
-     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
      * @param [options] - Configuration options for the AVL tree.
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: AVLTreeOptions<K, V, R>);
@@ -312,14 +312,14 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      */
     isNode(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is AVLTreeNode<K, V>;
     /**
-     * Adds a new node to the AVL tree and balances the tree path.
-     * @remarks Time O(log N) (O(H) for BST add + O(H) for `_balancePath`). Space O(H) for path/recursion.
+     * Sets a new node to the AVL tree and balances the tree path.
+     * @remarks Time O(log N) (O(H) for BST set + O(H) for `_balancePath`). Space O(H) for path/recursion.
      *
-     * @param keyNodeOrEntry - The key, node, or entry to add.
+     * @param keyNodeOrEntry - The key, node, or entry to set.
      * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
      */
-    add(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
+    set(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
      * Deletes a node from the AVL tree and re-balances the tree.
      * @remarks Time O(log N) (O(H) for BST delete + O(H) for `_balancePath`). Space O(H) for path/recursion.
@@ -339,7 +339,7 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
     perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * Creates a new AVLTree by mapping each [key, value] pair.
-     * @remarks Time O(N log N) (O(N) iteration + O(log M) `add` for each item into the new tree). Space O(N) for the new tree.
+     * @remarks Time O(N log N) (O(N) iteration + O(log M) `set` for each item into the new tree). Space O(N) for the new tree.
      *
      * @template MK - New key type.
      * @template MV - New value type.

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

@@ -113,7 +113,7 @@ export declare class BinaryTreeNode<K = any, V = any> {
  *
  * @remarks
  * This class implements a basic Binary Tree, not a Binary Search Tree.
- * The `add` operation inserts nodes level-by-level (BFS) into the first available slot.
+ * The `set` operation inserts nodes level-by-level (BFS) into the first available slot.
  *
  * @template K - The type of the key.
  * @template V - The type of the value.
@@ -145,7 +145,7 @@ export declare class BinaryTreeNode<K = any, V = any> {
  *     console.log(tree.size); // 9;
  *
  *     // Add new element
- *     tree.add(10, 'ten');
+ *     tree.set(10, 'ten');
  *     console.log(tree.size); // 10;
  * @example
  * // BinaryTree get and has operations
@@ -269,9 +269,9 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
     iterationType: IterationType;
     /**
      * Creates an instance of BinaryTree.
-     * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `add` operation). Space O(N) for storing the nodes.
+     * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `set` operation). Space O(N) for storing the nodes.
      *
-     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
      * @param [options] - Configuration options for the tree.
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: BinaryTreeOptions<K, V, R>);
@@ -434,49 +434,48 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
      *
      * @param keyNodeOrEntry - The key, node, or entry to add.
-     * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
      */
-    add(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
+    add(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
     /**
      * Adds or updates a new node to the tree.
-     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+     * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation sets the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
      *
-     * @param keyNodeOrEntry - The key, node, or entry to add or update.
+     * @param keyNodeOrEntry - The key, node, or entry to set or update.
      * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
      */
     set(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
      * Adds multiple items to the tree.
-     * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+     * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
      *
-     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param keysNodesEntriesOrRaws - An iterable of items to set.
      * @param [values] - An optional parallel iterable of values.
-     * @returns An array of booleans indicating the success of each individual `add` operation.
+     * @returns An array of booleans indicating the success of each individual `set` operation.
      */
-    addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
+    addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>): boolean[];
     /**
      * Adds or updates multiple items to the tree.
-     * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+     * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
      *
-     * @param keysNodesEntriesOrRaws - An iterable of items to add or update.
+     * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
      * @param [values] - An optional parallel iterable of values.
-     * @returns An array of booleans indicating the success of each individual `add` operation.
+     * @returns An array of booleans indicating the success of each individual `set` operation.
      */
     setMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
     /**
-     * Merges another tree into this one by adding all its nodes.
-     * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).
+     * Merges another tree into this one by seting all its nodes.
+     * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
      *
      * @param anotherTree - The tree to merge.
      */
     merge(anotherTree: BinaryTree<K, V, R>): void;
     /**
      * Clears the tree and refills it with new items.
-     * @remarks Time O(N) (for `clear`) + O(N * M) (for `addMany`) = O(N * M). Space O(M) (from `addMany`).
+     * @remarks Time O(N) (for `clear`) + O(N * M) (for `setMany`) = O(N * M). Space O(M) (from `setMany`).
      *
-     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param keysNodesEntriesOrRaws - An iterable of items to set.
      * @param [values] - An optional parallel iterable of values.
      */
     refill(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): void;
@@ -624,14 +623,14 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
     morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): ReturnType<C>[];
     /**
      * Clones the tree.
-     * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `add`, and `add` is O(M)). Space O(N) for the new tree and the BFS queue.
+     * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
      *
      * @returns A new, cloned instance of the tree.
      */
     clone(): this;
     /**
      * Creates a new tree containing only the entries that satisfy the predicate.
-     * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `add` for each item). Space O(N) for the new tree.
+     * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `set` for each item). Space O(N) for the new tree.
      *
      * @param predicate - A function to test each [key, value] pair.
      * @param [thisArg] - `this` context for the predicate.
@@ -722,8 +721,8 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      */
     protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): [BinaryTreeNode<K, V> | null | undefined, V | undefined];
     /**
-     * (Protected) Helper for cloning. Performs a BFS and adds all nodes to the new tree.
-     * @remarks Time O(N * M) (O(N) BFS + O(M) `add` for each node).
+     * (Protected) Helper for cloning. Performs a BFS and sets all nodes to the new tree.
+     * @remarks Time O(N * M) (O(N) BFS + O(M) `set` for each node).
      *
      * @param cloned - The new, empty tree instance to populate.
      */

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

@@ -145,8 +145,8 @@ export declare class BSTNode<K = any, V = any> {
  *     console.log(bst.size); // 16;
  *
  *     // Add new elements
- *     bst.add(17);
- *     bst.add(0);
+ *     bst.set(17);
+ *     bst.set(0);
  *     console.log(bst.size); // 18;
  *
  *     // Verify keys are searchable
@@ -192,7 +192,7 @@ export declare class BSTNode<K = any, V = any> {
  *
  *     // Merge datasets into a single BinarySearchTree
  *     const merged = new BST<number, string>(dataset1);
- *     merged.addMany(dataset2);
+ *     merged.setMany(dataset2);
  *     merged.merge(dataset3);
  *
  *     // Verify merged dataset is in sorted order
@@ -276,7 +276,7 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * Creates an instance of BST.
      * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
      *
-     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+     * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
      * @param [options] - Configuration options for the BST, including comparator.
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | BSTNode | [K | null | undefined, V | undefined] | null | undefined | R>, options?: BSTOptions<K, V, R>);
@@ -359,24 +359,24 @@ export declare class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R>
      * Adds a new node to the BST based on key comparison.
      * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
      *
-     * @param keyNodeOrEntry - The key, node, or entry to add.
+     * @param keyNodeOrEntry - The key, node, or entry to set.
      * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
      */
-    add(keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
+    set(keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
      * Adds multiple items to the tree.
-     * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced add).
+     * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced set).
      * If false, adds items one by one. Time O(N * H), which is O(N^2) worst-case.
      * Space O(N) for sorting and recursion/iteration stack.
      *
-     * @param keysNodesEntriesOrRaws - An iterable of items to add.
+     * @param keysNodesEntriesOrRaws - An iterable of items to set.
      * @param [values] - An optional parallel iterable of values.
      * @param [isBalanceAdd=true] - If true, builds a balanced tree from the items.
-     * @param [iterationType=this.iterationType] - The traversal method for balanced add (recursive or iterative).
-     * @returns An array of booleans indicating the success of each individual `add` operation.
+     * @param [iterationType=this.iterationType] - The traversal method for balanced set (recursive or iterative).
+     * @returns An array of booleans indicating the success of each individual `set` operation.
      */
-    addMany(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
+    setMany(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
     /**
      * Returns the first key with a value >= target.
      * Equivalent to Java TreeMap.ceiling.

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

@@ -242,7 +242,7 @@ export declare class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R
      * @param [value]- See parameter type for details.
      * @returns True if inserted or updated; false if ignored.
      */
-    add(keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
+    set(keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
      * Delete a node by key/node/entry and rebalance as needed.
      * @remarks Time O(log n), Space O(1)

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

@@ -154,7 +154,7 @@ export declare class TreeCounter<K = any, V = any, R = any> extends RedBlackTree
      * @param [count] - How much to increase the node's count (default 1).
      * @returns True if inserted/updated; false if ignored.
      */
-    add(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
+    set(keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
     /**
      * Delete a node (or decrement its count) and rebalance if needed.
      * @remarks Time O(log N), Space O(1)

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

@@ -297,8 +297,8 @@ export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTre
      * @returns True if it's a TreeMultiMapNode, false otherwise.
      */
     isNode(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): keyNodeOrEntry is TreeMultiMapNode<K, V>;
-    add(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
-    add(key: K, value: V): boolean;
+    set(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+    set(key: K, value: V): boolean;
     /**
      * Delete a single value from the bucket at a given key. Removes the key if the bucket becomes empty.
      * @remarks Time O(log N), Space O(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doubly-linked-list-typed",
-  "version": "2.2.7",
+  "version": "2.2.8",
   "description": "Doubly Linked List",
   "browser": "dist/umd/doubly-linked-list-typed.min.js",
   "umd:main": "dist/umd/doubly-linked-list-typed.min.js",
@@ -102,6 +102,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^2.2.7"
+    "data-structure-typed": "^2.2.8"
   }
 }

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -200,7 +200,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     options?: AVLTreeCounterOptions<K, V, R>
   ) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -243,7 +243,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
@@ -252,7 +252,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     if (newNode === undefined) return false;
 
     const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode, newValue);
+    const inserted = super.set(newNode, newValue);
     if (inserted) {
       this._count += orgNodeCount;
     }
@@ -380,9 +380,9 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     const out = this._createInstance();
 
     if (this._isMapMode) {
-      this.bfs(node => out.add(node.key, undefined, node.count));
+      this.bfs(node => out.set(node.key, undefined, node.count));
     } else {
-      this.bfs(node => out.add(node.key, node.value, node.count));
+      this.bfs(node => out.set(node.key, node.value, node.count));
     }
 
     if (this._isMapMode) out._store = this._store;
@@ -410,7 +410,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -199,7 +199,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
   ) {
     super([], { ...options, isMapMode: true });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -220,29 +220,29 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
     return keyNodeOrEntry instanceof AVLTreeMultiMapNode;
   }
 
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
-  override add(key: K, value: V): boolean;
+  override set(key: K, value: V): boolean;
 
   /**
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
     value?: V
   ): boolean {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const _addToValues = () => {
+      const _setToValues = () => {
         const existingValues = this.get(key);
         if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
@@ -251,12 +251,12 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
         return false;
       };
 
-      const _addByNode = () => {
+      const _setByNode = () => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === undefined) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== undefined) {
@@ -266,14 +266,14 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
       };
 
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {
@@ -392,7 +392,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
   ): AVLTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/binary-tree/avl-tree.ts

@@ -182,7 +182,7 @@ export class AVLTreeNode<K = any, V = any> {
 
 /**
  * Represents a self-balancing AVL (Adelson-Velsky and Landis) Tree.
- * This tree extends BST and performs rotations on add/delete to maintain balance.
+ * This tree extends BST and performs rotations on set/delete to maintain balance.
  *
  * @template K - The type of the key.
  * @template V - The type of the value.
@@ -215,7 +215,7 @@ export class AVLTreeNode<K = any, V = any> {
  *     console.log(tree.size); // 5;
  *
  *     // Add a new element
- *     tree.add(3);
+ *     tree.set(3);
  *     console.log(tree.size); // 6;
  *     console.log([...tree.keys()]); // [1, 2, 3, 5, 8, 9];
  * @example
@@ -278,7 +278,7 @@ export class AVLTreeNode<K = any, V = any> {
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Add more universities
- *     universityTree.add(6, { name: 'Oxford', rank: 6, students: 2000 });
+ *     universityTree.set(6, { name: 'Oxford', rank: 6, students: 2000 });
  *     console.log(universityTree.isAVLBalanced()); // true;
  *
  *     // Delete and verify balance is maintained
@@ -358,9 +358,9 @@ export class AVLTreeNode<K = any, V = any> {
 export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements IBinaryTree<K, V, R> {
   /**
    * Creates an instance of AVLTree.
-   * @remarks Time O(N log N) (from `addMany` with balanced add). Space O(N).
+   * @remarks Time O(N log N) (from `setMany` with balanced set). Space O(N).
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the AVL tree.
    */
   constructor(
@@ -370,8 +370,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     options?: AVLTreeOptions<K, V, R>
   ) {
     super([], options);
-    // Note: super.addMany is called, which in BST defaults to balanced add.
-    if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
+    // Note: super.setMany is called, which in BST defaults to balanced set.
+    if (keysNodesEntriesOrRaws) super.setMany(keysNodesEntriesOrRaws);
   }
 
   /**
@@ -400,19 +400,19 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
   }
 
   /**
-   * Adds a new node to the AVL tree and balances the tree path.
-   * @remarks Time O(log N) (O(H) for BST add + O(H) for `_balancePath`). Space O(H) for path/recursion.
+   * Sets a new node to the AVL tree and balances the tree path.
+   * @remarks Time O(log N) (O(H) for BST set + O(H) for `_balancePath`). Space O(H) for path/recursion.
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
     if (keyNodeOrEntry === null) return false;
-    const inserted = super.add(keyNodeOrEntry, value);
+    const inserted = super.set(keyNodeOrEntry, value);
     // If insertion was successful, balance the path from the new node up to the root.
     if (inserted) this._balancePath(keyNodeOrEntry);
     return inserted;
@@ -477,7 +477,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
 
   /**
    * Creates a new AVLTree by mapping each [key, value] pair.
-   * @remarks Time O(N log N) (O(N) iteration + O(log M) `add` for each item into the new tree). Space O(N) for the new tree.
+   * @remarks Time O(N log N) (O(N) iteration + O(log M) `set` for each item into the new tree). Space O(N) for the new tree.
    *
    * @template MK - New key type.
    * @template MV - New value type.
@@ -497,8 +497,8 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
     let index = 0;
     // Iterates in-order
     for (const [key, value] of this) {
-      // `add` on the new tree will be O(log N) and will self-balance.
-      out.add(callback.call(thisArg, value, key, index++, this));
+      // `set` on the new tree will be O(log N) and will self-balance.
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/binary-tree.ts

@@ -71,7 +71,7 @@ export class BinaryTreeNode<K = any, V = any> {
    */
   set left(v: BinaryTreeNode<K, V> | null | undefined) {
     if (v) {
-      v.parent = this as unknown as BinaryTreeNode<K, V>;
+      v.parent = this;
     }
     this._left = v;
   }
@@ -193,7 +193,7 @@ export class BinaryTreeNode<K = any, V = any> {
  *
  * @remarks
  * This class implements a basic Binary Tree, not a Binary Search Tree.
- * The `add` operation inserts nodes level-by-level (BFS) into the first available slot.
+ * The `set` operation inserts nodes level-by-level (BFS) into the first available slot.
  *
  * @template K - The type of the key.
  * @template V - The type of the value.
@@ -225,7 +225,7 @@ export class BinaryTreeNode<K = any, V = any> {
  *     console.log(tree.size); // 9;
  *
  *     // Add new element
- *     tree.add(10, 'ten');
+ *     tree.set(10, 'ten');
  *     console.log(tree.size); // 10;
  * @example
  * // BinaryTree get and has operations
@@ -353,9 +353,9 @@ export class BinaryTree<K = any, V = any, R = any>
 
   /**
    * Creates an instance of BinaryTree.
-   * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `add` operation). Space O(N) for storing the nodes.
+   * @remarks Time O(N * M), where N is the number of items in `keysNodesEntriesOrRaws` and M is the tree size at insertion time (due to O(M) `set` operation). Space O(N) for storing the nodes.
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the tree.
    */
   constructor(
@@ -374,7 +374,7 @@ export class BinaryTree<K = any, V = any, R = any>
       else if (toEntryFn) throw TypeError('toEntryFn must be a function type');
     }
 
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _isMapMode = true;
@@ -640,13 +640,27 @@ export class BinaryTree<K = any, V = any, R = any>
    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
    *
    * @param keyNodeOrEntry - The key, node, or entry to add.
-   * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
   add(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): boolean {
+    return this.set(keyNodeOrEntry);
+  }
+
+  /**
+   * Adds or updates a new node to the tree.
+   * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation sets the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+   *
+   * @param keyNodeOrEntry - The key, node, or entry to set or update.
+   * @param [value] - The value, if providing just a key.
+   * @returns True if the addition was successful, false otherwise.
+   */
+  set(
     keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
+
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
@@ -699,29 +713,30 @@ export class BinaryTree<K = any, V = any, R = any>
   }
 
   /**
-   * Adds or updates a new node to the tree.
-   * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
+   * Adds multiple items to the tree.
+   * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add or update.
-   * @param [value] - The value, if providing just a key.
-   * @returns True if the addition was successful, false otherwise.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
+   * @param [values] - An optional parallel iterable of values.
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  set(
-    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
-    value?: V
-  ): boolean {
-    return this.add(keyNodeOrEntry, value);
+  addMany(
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    >
+  ): boolean[] {
+    return this.setMany(keysNodesEntriesOrRaws);
   }
 
   /**
-   * Adds multiple items to the tree.
-   * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
+   * Adds or updates multiple items to the tree.
+   * @remarks Time O(N * M), where N is the number of items to set and M is the size of the tree at insertion (due to O(M) `set` operation). Space O(M) (from `set`) + O(N) (for the `inserted` array).
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
    * @param [values] - An optional parallel iterable of values.
-   * @returns An array of booleans indicating the success of each individual `add` operation.
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  addMany(
+  setMany(
     keysNodesEntriesOrRaws: Iterable<
       K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
     >,
@@ -744,44 +759,27 @@ export class BinaryTree<K = any, V = any, R = any>
         }
       }
       if (this.isRaw(keyNodeEntryOrRaw)) keyNodeEntryOrRaw = this._toEntryFn!(keyNodeEntryOrRaw);
-      inserted.push(this.add(keyNodeEntryOrRaw, value));
+      inserted.push(this.set(keyNodeEntryOrRaw, value));
     }
 
     return inserted;
   }
 
   /**
-   * Adds or updates multiple items to the tree.
-   * @remarks Time O(N * M), where N is the number of items to add and M is the size of the tree at insertion (due to O(M) `add` operation). Space O(M) (from `add`) + O(N) (for the `inserted` array).
-   *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add or update.
-   * @param [values] - An optional parallel iterable of values.
-   * @returns An array of booleans indicating the success of each individual `add` operation.
-   */
-  setMany(
-    keysNodesEntriesOrRaws: Iterable<
-      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
-    >,
-    values?: Iterable<V | undefined>
-  ): boolean[] {
-    return this.addMany(keysNodesEntriesOrRaws, values);
-  }
-
-  /**
-   * Merges another tree into this one by adding all its nodes.
-   * @remarks Time O(N * M), same as `addMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `add`).
+   * Merges another tree into this one by seting all its nodes.
+   * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
    *
    * @param anotherTree - The tree to merge.
    */
   merge(anotherTree: BinaryTree<K, V, R>) {
-    this.addMany(anotherTree, []);
+    this.setMany(anotherTree, []);
   }
 
   /**
    * Clears the tree and refills it with new items.
-   * @remarks Time O(N) (for `clear`) + O(N * M) (for `addMany`) = O(N * M). Space O(M) (from `addMany`).
+   * @remarks Time O(N) (for `clear`) + O(N * M) (for `setMany`) = O(N * M). Space O(M) (from `setMany`).
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
    * @param [values] - An optional parallel iterable of values.
    */
   refill(
@@ -791,7 +789,7 @@ export class BinaryTree<K = any, V = any, R = any>
     values?: Iterable<V | undefined>
   ): void {
     this.clear();
-    this.addMany(keysNodesEntriesOrRaws, values);
+    this.setMany(keysNodesEntriesOrRaws, values);
   }
 
   /**
@@ -1830,7 +1828,7 @@ export class BinaryTree<K = any, V = any, R = any>
 
   /**
    * Clones the tree.
-   * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `add`, and `add` is O(M)). Space O(N) for the new tree and the BFS queue.
+   * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
    *
    * @returns A new, cloned instance of the tree.
    */
@@ -1842,7 +1840,7 @@ export class BinaryTree<K = any, V = any, R = any>
 
   /**
    * Creates a new tree containing only the entries that satisfy the predicate.
-   * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `add` for each item). Space O(N) for the new tree.
+   * @remarks Time O(N * M), where N is nodes in this tree, and M is size of the new tree during insertion (O(N) iteration + O(M) `set` for each item). Space O(N) for the new tree.
    *
    * @param predicate - A function to test each [key, value] pair.
    * @param [thisArg] - `this` context for the predicate.
@@ -1851,7 +1849,7 @@ export class BinaryTree<K = any, V = any, R = any>
   filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this {
     const out = this._createInstance<K, V, R>();
     let i = 0;
-    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.add([k, v]);
+    for (const [k, v] of this) if (predicate.call(thisArg, v, k, i++, this)) out.set([k, v]);
     return out;
   }
 
@@ -1874,7 +1872,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): BinaryTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(cb.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(cb.call(thisArg, v, k, i++, this));
     return out;
   }
 
@@ -2204,8 +2202,8 @@ export class BinaryTree<K = any, V = any, R = any>
   }
 
   /**
-   * (Protected) Helper for cloning. Performs a BFS and adds all nodes to the new tree.
-   * @remarks Time O(N * M) (O(N) BFS + O(M) `add` for each node).
+   * (Protected) Helper for cloning. Performs a BFS and sets all nodes to the new tree.
+   * @remarks Time O(N * M) (O(N) BFS + O(M) `set` for each node).
    *
    * @param cloned - The new, empty tree instance to populate.
    */
@@ -2213,10 +2211,10 @@ export class BinaryTree<K = any, V = any, R = any>
     // Use BFS with nulls to preserve the tree structure
     this.bfs(
       node => {
-        if (node === null) cloned.add(null);
+        if (node === null) cloned.set(null);
         else {
-          if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
-          else cloned.add([node.key, node.value]);
+          if (this._isMapMode) cloned.set([node.key, this._store.get(node.key)]);
+          else cloned.set([node.key, node.value]);
         }
       },
       this._root,

package/src/data-structures/binary-tree/bst.ts

@@ -219,8 +219,8 @@ export class BSTNode<K = any, V = any> {
  *     console.log(bst.size); // 16;
  *
  *     // Add new elements
- *     bst.add(17);
- *     bst.add(0);
+ *     bst.set(17);
+ *     bst.set(0);
  *     console.log(bst.size); // 18;
  *
  *     // Verify keys are searchable
@@ -266,7 +266,7 @@ export class BSTNode<K = any, V = any> {
  *
  *     // Merge datasets into a single BinarySearchTree
  *     const merged = new BST<number, string>(dataset1);
- *     merged.addMany(dataset2);
+ *     merged.setMany(dataset2);
  *     merged.merge(dataset3);
  *
  *     // Verify merged dataset is in sorted order
@@ -350,7 +350,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Creates an instance of BST.
    * @remarks Time O(N log N) or O(N^2) depending on `isBalanceAdd` in `addMany` and input order. Space O(N).
    *
-   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to add.
+   * @param [keysNodesEntriesOrRaws=[]] - An iterable of items to set.
    * @param [options] - Configuration options for the BST, including comparator.
    */
   constructor(
@@ -370,7 +370,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       this._comparator = this._createDefaultComparator();
     }
 
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected override _root?: BSTNode<K, V> = undefined;
@@ -625,7 +625,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     if (isRange) {
       predicate = node => {
         if (!node) return false;
-        return (keyNodeEntryOrPredicate as Range<K>).isInRange(node.key, this._comparator);
+        return (keyNodeEntryOrPredicate).isInRange(node.key, this._comparator);
       };
     } else {
       predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
@@ -637,7 +637,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (!this.isRealNode(cur.left)) return false;
       if (isRange) {
         // Range search: Only go left if the current key is >= the lower bound
-        const range = keyNodeEntryOrPredicate as Range<K>;
+        const range = keyNodeEntryOrPredicate;
         const leftS = range.low;
         const leftI = range.includeLow;
         return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
@@ -655,7 +655,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (!this.isRealNode(cur.right)) return false;
       if (isRange) {
         // Range search: Only go right if current key <= upper bound
-        const range = keyNodeEntryOrPredicate as Range<K>;
+        const range = keyNodeEntryOrPredicate;
         const rightS = range.high;
         const rightI = range.includeHigh;
         return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
@@ -716,11 +716,11 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * Adds a new node to the BST based on key comparison.
    * @remarks Time O(log N), where H is tree height. O(N) worst-case (unbalanced tree), O(log N) average. Space O(1).
    *
-   * @param keyNodeOrEntry - The key, node, or entry to add.
+   * @param keyNodeOrEntry - The key, node, or entry to set.
    * @param [value] - The value, if providing just a key.
    * @returns True if the addition was successful, false otherwise.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
@@ -766,17 +766,17 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
   /**
    * Adds multiple items to the tree.
-   * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced add).
+   * @remarks If `isBalanceAdd` is true, sorts the input and builds a balanced tree. Time O(N log N) (due to sort and balanced set).
    * If false, adds items one by one. Time O(N * H), which is O(N^2) worst-case.
    * Space O(N) for sorting and recursion/iteration stack.
    *
-   * @param keysNodesEntriesOrRaws - An iterable of items to add.
+   * @param keysNodesEntriesOrRaws - An iterable of items to set.
    * @param [values] - An optional parallel iterable of values.
    * @param [isBalanceAdd=true] - If true, builds a balanced tree from the items.
-   * @param [iterationType=this.iterationType] - The traversal method for balanced add (recursive or iterative).
-   * @returns An array of booleans indicating the success of each individual `add` operation.
+   * @param [iterationType=this.iterationType] - The traversal method for balanced set (recursive or iterative).
+   * @returns An array of booleans indicating the success of each individual `set` operation.
    */
-  override addMany(
+  override setMany(
     keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, BSTNode<K, V>>>,
     values?: Iterable<V | undefined>,
     isBalanceAdd = true,
@@ -790,7 +790,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       for (let kve of keysNodesEntriesOrRaws) {
         const val = valuesIterator?.next().value;
         if (this.isRaw(kve)) kve = this._toEntryFn!(kve);
-        inserted.push(this.add(kve, val));
+        inserted.push(this.set(kve, val));
       }
       return inserted;
     }
@@ -831,9 +831,9 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       const { key, value, orgIndex } = arr[mid];
       if (this.isRaw(key)) {
         const entry = this._toEntryFn!(key);
-        inserted[orgIndex] = this.add(entry);
+        inserted[orgIndex] = this.set(entry);
       } else {
-        inserted[orgIndex] = this.add(key, value);
+        inserted[orgIndex] = this.set(key, value);
       }
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
@@ -852,9 +852,9 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
         const { key, value, orgIndex } = sorted[m];
         if (this.isRaw(key)) {
           const entry = this._toEntryFn!(key);
-          inserted[orgIndex] = this.add(entry);
+          inserted[orgIndex] = this.set(entry);
         } else {
-          inserted[orgIndex] = this.add(key, value);
+          inserted[orgIndex] = this.set(key, value);
         }
         stack.push([m + 1, r]);
         stack.push([l, m - 1]);
@@ -1369,7 +1369,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     let index = 0;
     // Iterates in-order
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
@@ -1441,7 +1441,6 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    */
   protected _createDefaultComparator(): Comparator<K> {
     return (a: K, b: K): number => {
-      debugger;
       // If both keys are comparable (primitive types), use direct comparison
       if (isComparable(a) && isComparable(b)) {
         if (a > b) return 1;

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -292,7 +292,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     this._root = this.NIL;
 
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -350,7 +350,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @param [value]- See parameter type for details.
    * @returns True if inserted or updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
@@ -469,7 +469,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/tree-counter.ts

@@ -204,7 +204,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     options?: TreeCounterOptions<K, V, R>
   ) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -255,14 +255,14 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.add(newNode, newValue);
+    const isSuccessAdded = super.set(newNode, newValue);
     if (isSuccessAdded) {
       this._count += orgCount;
       return true;
@@ -437,7 +437,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -364,7 +364,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ) {
     super([], { ...options });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -385,29 +385,29 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     return keyNodeOrEntry instanceof TreeMultiMapNode;
   }
 
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
-  override add(key: K, value: V): boolean;
+  override set(key: K, value: V): boolean;
 
   /**
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
     value?: V
   ): boolean {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const _addToValues = () => {
+      const _setToValues = () => {
         const existingValues = this.get(key);
         if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
@@ -416,12 +416,12 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
         return false;
       };
 
-      const _addByNode = () => {
+      const _setByNode = () => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === undefined) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== undefined) {
@@ -431,14 +431,14 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
       };
 
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {
@@ -503,7 +503,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }