data-structure-typed 2.2.7 → 2.2.8

package/dist/cjs/index.cjs

@@ -6995,9 +6995,9 @@ var BinaryTree = class extends IterableEntryBase {
   iterationType = "ITERATIVE";
   /**
    * 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 = [], options) {
@@ -7010,7 +7010,7 @@ var BinaryTree = class extends IterableEntryBase {
       if (typeof toEntryFn === "function") this._toEntryFn = toEntryFn;
       else if (toEntryFn) throw TypeError("toEntryFn must be a function type");
     }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _isMapMode = true;
   /**
@@ -7224,10 +7224,20 @@ var BinaryTree = class extends IterableEntryBase {
    * @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.
+   * @returns True if the addition was successful, false otherwise.
+   */
+  add(keyNodeOrEntry) {
+    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.
    */
-  add(keyNodeOrEntry, value) {
+  set(keyNodeOrEntry, value) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (!this._root) {
@@ -7271,25 +7281,25 @@ var BinaryTree = class extends IterableEntryBase {
     return false;
   }
   /**
-   * 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, value) {
-    return this.add(keyNodeOrEntry, value);
+  addMany(keysNodesEntriesOrRaws) {
+    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(keysNodesEntriesOrRaws, values) {
+  setMany(keysNodesEntriesOrRaws, values) {
     const inserted = [];
     let valuesIterator;
     if (values) {
@@ -7304,40 +7314,29 @@ var BinaryTree = class extends IterableEntryBase {
         }
       }
       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, values) {
-    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) {
-    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(keysNodesEntriesOrRaws, values) {
     this.clear();
-    this.addMany(keysNodesEntriesOrRaws, values);
+    this.setMany(keysNodesEntriesOrRaws, values);
   }
   /**
    * Deletes a node from the tree.
@@ -8002,7 +8001,7 @@ var BinaryTree = class extends IterableEntryBase {
   }
   /**
    * 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.
    */
@@ -8013,7 +8012,7 @@ var BinaryTree = class extends IterableEntryBase {
   }
   /**
    * 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.
@@ -8022,7 +8021,7 @@ var BinaryTree = class extends IterableEntryBase {
   filter(predicate, thisArg) {
     const out = this._createInstance();
     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;
   }
   /**
@@ -8040,7 +8039,7 @@ var BinaryTree = class extends IterableEntryBase {
   map(cb, options, thisArg) {
     const out = this._createLike([], 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;
   }
   /**
@@ -8292,18 +8291,18 @@ var BinaryTree = class extends IterableEntryBase {
     return [this.createNode(keyNodeOrEntry, value), value];
   }
   /**
-   * (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.
    */
   _clone(cloned) {
     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,
@@ -8636,7 +8635,7 @@ var BST = class extends BinaryTree {
    * 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 = [], options) {
@@ -8650,7 +8649,7 @@ var BST = class extends BinaryTree {
     } else {
       this._comparator = this._createDefaultComparator();
     }
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _root = void 0;
   /**
@@ -8866,11 +8865,11 @@ var BST = class extends BinaryTree {
    * 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, value) {
+  set(keyNodeOrEntry, value) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (this._root === void 0) {
@@ -8907,24 +8906,24 @@ var BST = class extends BinaryTree {
   }
   /**
    * 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, values, isBalanceAdd = true, iterationType = this.iterationType) {
+  setMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
     const inserted = [];
     const valuesIterator = values?.[Symbol.iterator]();
     if (!isBalanceAdd) {
       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;
     }
@@ -8952,9 +8951,9 @@ var BST = class extends BinaryTree {
       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));
@@ -8971,9 +8970,9 @@ var BST = class extends BinaryTree {
         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]);
@@ -9248,7 +9247,7 @@ var BST = class extends BinaryTree {
     const out = this._createLike([], options);
     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;
   }
@@ -10435,14 +10434,14 @@ var AVLTree = class extends BST {
   }
   /**
    * 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 = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) super.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) super.setMany(keysNodesEntriesOrRaws);
   }
   /**
    * (Protected) Creates a new AVL tree node.
@@ -10466,16 +10465,16 @@ var AVLTree = class extends BST {
     return keyNodeOrEntry instanceof AVLTreeNode;
   }
   /**
-   * 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, value) {
+  set(keyNodeOrEntry, value) {
     if (keyNodeOrEntry === null) return false;
-    const inserted = super.add(keyNodeOrEntry, value);
+    const inserted = super.set(keyNodeOrEntry, value);
     if (inserted) this._balancePath(keyNodeOrEntry);
     return inserted;
   }
@@ -10527,7 +10526,7 @@ var AVLTree = class extends BST {
   }
   /**
    * 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.
@@ -10541,7 +10540,7 @@ var AVLTree = class extends BST {
     const out = this._createLike([], options);
     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;
   }
@@ -10967,7 +10966,7 @@ var RedBlackTree = class extends BST {
     super([], options);
     this._root = this.NIL;
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   _root;
@@ -11015,7 +11014,7 @@ var RedBlackTree = class extends BST {
    * @param [value]- See parameter type for details.
    * @returns True if inserted or updated; false if ignored.
    */
-  add(keyNodeOrEntry, value) {
+  set(keyNodeOrEntry, value) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (!this.isRealNode(newNode)) return false;
     const insertStatus = this._insert(newNode);
@@ -11109,7 +11108,7 @@ var RedBlackTree = class extends BST {
     const out = this._createLike([], options);
     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;
   }
@@ -11497,7 +11496,7 @@ var AVLTreeMultiMap = class extends AVLTree {
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], { ...options, isMapMode: true });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   createNode(key, value = []) {
@@ -11517,27 +11516,27 @@ var AVLTreeMultiMap = class extends AVLTree {
    * 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.
    */
-  add(keyNodeOrEntry, value) {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+  set(keyNodeOrEntry, value) {
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
     const _commonAdd = /* @__PURE__ */ __name((key, values) => {
       if (key === void 0 || key === null) return false;
-      const _addToValues = /* @__PURE__ */ __name(() => {
+      const _setToValues = /* @__PURE__ */ __name(() => {
         const existingValues = this.get(key);
         if (existingValues !== void 0 && values !== void 0) {
           for (const value2 of values) existingValues.push(value2);
           return true;
         }
         return false;
-      }, "_addToValues");
-      const _addByNode = /* @__PURE__ */ __name(() => {
+      }, "_setToValues");
+      const _setByNode = /* @__PURE__ */ __name(() => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === void 0) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== void 0) {
@@ -11547,13 +11546,13 @@ var AVLTreeMultiMap = class extends AVLTree {
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
-      }, "_addByNode");
+      }, "_setByNode");
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     }, "_commonAdd");
     if (this.isEntry(keyNodeOrEntry)) {
       const [key, values] = keyNodeOrEntry;
@@ -11621,7 +11620,7 @@ var AVLTreeMultiMap = class extends AVLTree {
   map(callback, options, thisArg) {
     const out = this._createLike([], 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;
   }
   /**
@@ -11804,7 +11803,7 @@ var TreeMultiMap = class extends RedBlackTree {
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], { ...options });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
   createNode(key, value = []) {
@@ -11824,27 +11823,27 @@ var TreeMultiMap = class extends RedBlackTree {
    * 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.
    */
-  add(keyNodeOrEntry, value) {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+  set(keyNodeOrEntry, value) {
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
     const _commonAdd = /* @__PURE__ */ __name((key, values) => {
       if (key === void 0 || key === null) return false;
-      const _addToValues = /* @__PURE__ */ __name(() => {
+      const _setToValues = /* @__PURE__ */ __name(() => {
         const existingValues = this.get(key);
         if (existingValues !== void 0 && values !== void 0) {
           for (const value2 of values) existingValues.push(value2);
           return true;
         }
         return false;
-      }, "_addToValues");
-      const _addByNode = /* @__PURE__ */ __name(() => {
+      }, "_setToValues");
+      const _setByNode = /* @__PURE__ */ __name(() => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === void 0) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== void 0) {
@@ -11854,13 +11853,13 @@ var TreeMultiMap = class extends RedBlackTree {
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
-      }, "_addByNode");
+      }, "_setByNode");
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     }, "_commonAdd");
     if (this.isEntry(keyNodeOrEntry)) {
       const [key, values] = keyNodeOrEntry;
@@ -11900,7 +11899,7 @@ var TreeMultiMap = class extends RedBlackTree {
   map(callback, options, thisArg) {
     const out = this._createLike([], 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;
   }
   /**
@@ -12085,7 +12084,7 @@ var TreeCounter = class extends RedBlackTree {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _count = 0;
   /**
@@ -12125,10 +12124,10 @@ var TreeCounter = class extends RedBlackTree {
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  add(keyNodeOrEntry, value, count = 1) {
+  set(keyNodeOrEntry, value, count = 1) {
     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;
@@ -12281,7 +12280,7 @@ var TreeCounter = class extends RedBlackTree {
     const out = this._createLike([], options);
     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;
   }
@@ -12537,7 +12536,7 @@ var AVLTreeCounter = class extends AVLTree {
    */
   constructor(keysNodesEntriesOrRaws = [], options) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
   _count = 0;
   get count() {
@@ -12572,11 +12571,11 @@ var AVLTreeCounter = class extends AVLTree {
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  add(keyNodeOrEntry, value, count = 1) {
+  set(keyNodeOrEntry, value, count = 1) {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     if (newNode === void 0) return false;
     const orgNodeCount = newNode?.count || 0;
-    const inserted = super.add(newNode, newValue);
+    const inserted = super.set(newNode, newValue);
     if (inserted) {
       this._count += orgNodeCount;
     }
@@ -12684,9 +12683,9 @@ var AVLTreeCounter = class extends AVLTree {
   clone() {
     const out = this._createInstance();
     if (this._isMapMode) {
-      this.bfs((node) => out.add(node.key, void 0, node.count));
+      this.bfs((node) => out.set(node.key, void 0, 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;
     return out;
@@ -12706,7 +12705,7 @@ var AVLTreeCounter = class extends AVLTree {
     const out = this._createLike([], options);
     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;
   }